Data commit

Task/Substitution-cipher/00-META.yaml

@@ -0,0 +1,5 @@
+---
+category:
+- String manipulation
+from: http://rosettacode.org/wiki/Substitution_cipher
+note: Encryption

Task/Substitution-cipher/00-TASK.txt

@@ -0,0 +1,19 @@
+Substitution Cipher Implementation - File Encryption/Decryption
+
+
+;Task:
+Encrypt an input/source file by replacing every upper/lower case alphabets of the source file with another predetermined upper/lower case alphabets or symbols and save it into another output/encrypted file and then again convert that output/encrypted file into original/decrypted file.
+
+This type of Encryption/Decryption scheme is often called a Substitution Cipher. 
+
+
+;Related tasks:
+* [[Caesar cipher]]
+* [[Rot-13]]
+* [[Vigenère Cipher/Cryptanalysis]]
+
+
+;See also:
+* [[wp:Substitution_cipher|Wikipedia: Substitution cipher]]
+<br><br>
+

Task/Substitution-cipher/11l/substitution-cipher.11l

@@ -0,0 +1,18 @@
+V key = ‘]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\C1yxJ’
+
+F encode(s)
+   V r = ‘’
+   L(c) s
+      r ‘’= :key[c.code - 32]
+   R r
+
+F decode(s)
+   V r = ‘’
+   L(c) s
+      r ‘’= Char(code' :key.index(c) + 32)
+   R r
+
+V s = ‘The quick brown fox jumps over the lazy dog, who barks VERY loudly!’
+V enc = encode(s)
+print(‘Encoded:  ’enc)
+print(‘Decoded:  ’decode(enc))

Task/Substitution-cipher/Ada/substitution-cipher.ada

@@ -0,0 +1,46 @@
+with Ada.Command_Line; use Ada.Command_Line;
+with Ada.Sequential_IO;
+with Ada.Strings.Maps; use Ada.Strings.Maps;
+with Ada.Text_IO;
+
+procedure Cipher is
+   package Char_IO is new Ada.Sequential_IO (Character);
+   use Char_IO;
+   Alphabet: constant String := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+   Key :     constant String := "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN";
+   My_Map : Character_Mapping;
+   Input, Output : File_Type;
+   Buffer        : Character;
+begin
+   declare
+      use Ada.Text_IO;
+   begin
+      if Argument_Count /= 1 then
+	 Put_Line("Usage: " & Command_Name & " <encode|decode>");
+      else
+	 if Argument(1) = "encode" then
+	    My_Map := To_Mapping(From => Alphabet, To => Key);
+	 elsif Argument(1) = "decode" then
+	    My_Map := To_Mapping(From => Key, To => Alphabet);
+	 else
+	    Put_Line("Unrecognised Argument: " & Argument(1));
+	    return;
+	 end if;
+      end if;
+   end;
+   Open       (File => Input,  Mode => In_File,  Name => "input.txt");
+   Create     (File => Output, Mode => Out_File, Name => "output.txt");
+   loop
+      Read  (File => Input,  Item => Buffer);
+      Buffer := Value(Map => My_Map, Element => Buffer);
+      Write (File => Output, Item => Buffer);
+   end loop;
+exception
+   when Char_IO.End_Error =>
+      if Is_Open(Input) then
+         Close (Input);
+      end if;
+      if Is_Open(Output) then
+         Close (Output);
+      end if;
+end Cipher;

Task/Substitution-cipher/Arturo/substitution-cipher-1.arturo

@@ -0,0 +1,21 @@
+key: {:]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\C1yxJ:}
+
+encode: function [str][
+    bs: new []
+    loop split str 'ch ->
+        'bs ++ to :string key\[(to :integer to :char ch)-32]
+    return join bs
+]
+
+decode: function [str][
+    bs: new []
+    loop split str 'ch ->
+        'bs ++ to :string to :char (index key ch)+32
+    return join bs
+]
+
+s: "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+
+enc: encode s
+print ["encoded:" enc]
+print ["decoded:" decode enc]

Task/Substitution-cipher/Arturo/substitution-cipher-2.arturo

@@ -0,0 +1,27 @@
+alfabeto := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+codebeto := "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+textToEncode := "Encrypt an input/source file by replacing every upper/lower case alphabets of the source file with another predetermined upper/lower case alphabets or symbols and save it into another output/encrypted file and then again convert that output/encrypted file into original/decrypted file. This type of Encryption/Decryption scheme is often called a Substitution Cipher."
+
+loop,parse,textToEncode
+	{
+		posit := InStr(alfabeto,a_loopfield,1)
+		if posit
+			textEncoded .= substr(codebeto,posit,1)
+		else
+			textEncoded .= A_LoopField
+	}
+msgbox % "ENCODED TEXT: " . textEncoded
+
+loop,parse,textEncoded
+	{
+		posit := InStr(codebeto,a_loopfield,1)
+		if posit
+			textDecoded .= substr(alfabeto,posit,1)
+		else
+			textDecoded .= A_LoopField
+	}
+msgbox % "DECODED TEXT: " . textDecoded
+ExitApp
+
+~Esc::
+ExitApp

Task/Substitution-cipher/C++/substitution-cipher.cpp

@@ -0,0 +1,70 @@
+#include <iostream>
+#include <string>
+#include <fstream>
+
+class cipher {
+public:
+    bool work( std::string e, std::string f, std::string k ) {
+        if( e.length() < 1 ) return false;
+        fileBuffer = readFile( f );
+        if( "" == fileBuffer ) return false;
+        keyBuffer = readFile( k );
+        if( "" == keyBuffer ) return false;
+
+        outName = f;
+        outName.insert( outName.find_first_of( "." ), "_out" );
+
+        switch( e[0] ) {
+            case 'e': return encode();
+            case 'd': return decode();
+        }
+        return false;
+    }
+private:
+    bool encode() {
+        size_t idx, len = keyBuffer.length() >> 1;
+        for( std::string::iterator i = fileBuffer.begin(); i != fileBuffer.end(); i++ ) {
+            idx = keyBuffer.find_first_of( *i );
+            if( idx < len ) outBuffer.append( 1, keyBuffer.at( idx + len ) );
+            else outBuffer.append( 1, *i );
+        }
+        return saveOutput();
+    }
+    bool decode() {
+        size_t idx, l = keyBuffer.length(), len = l >> 1;
+        for( std::string::iterator i = fileBuffer.begin(); i != fileBuffer.end(); i++ ) {
+            idx = keyBuffer.find_last_of( *i );
+            if( idx >= len && idx < l ) outBuffer.append( 1, keyBuffer.at( idx - len ) );
+            else outBuffer.append( 1, *i );
+        }
+        return saveOutput();
+    }
+    bool saveOutput() {
+        std::ofstream o( outName.c_str() );
+        o.write( outBuffer.c_str(), outBuffer.size() );
+        o.close();
+        return true;
+    }
+    std::string readFile( std::string fl ) {
+        std::string buffer = "";
+        std::ifstream f( fl.c_str(), std::ios_base::in );
+        if( f.good() ) {
+            buffer = std::string( ( std::istreambuf_iterator<char>( f ) ), std::istreambuf_iterator<char>() );
+            f.close();
+        }
+        return buffer;
+    }
+    std::string fileBuffer, keyBuffer, outBuffer, outName;
+};
+
+int main( int argc, char* argv[] ) {
+    if( argc < 4 ) {
+        std::cout << "<d or e>\tDecrypt or Encrypt\n<filename>\tInput file, the output file will have"
+        "'_out' added to it.\n<key>\t\tfile with the key to encode/decode\n\n";
+    } else {
+        cipher c;
+        if( c.work( argv[1], argv[2], argv[3] ) ) std::cout << "\nFile successfully saved!\n\n";
+        else std::cout << "Something went wrong!\n\n";
+    }
+    return 0;
+}

Task/Substitution-cipher/C-sharp/substitution-cipher.cs

@@ -0,0 +1,144 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SubstitutionCipherProject
+{
+    class SubstitutionCipher
+    {
+        static void Main(string[] args)
+        {
+            doEncDec("e:\\source.txt", "enc.txt", true);
+            doEncDec("enc.txt", "dec.txt", false);
+            Console.WriteLine("Done");
+            Console.ReadKey();
+        }
+        static void doEncDec(String source, String target, bool IsEncrypt)
+        {
+            ITransform trans;
+
+            if (IsEncrypt)
+                trans = new Encrypt();
+            else
+                trans = new Decrypt();
+
+            FileInfo sfi = new FileInfo(source);
+            FileStream sstream = sfi.OpenRead();
+            StreamReader sr = new StreamReader(sstream);
+
+            FileInfo tfi = new FileInfo(target);
+            FileStream tstream = tfi.OpenWrite();
+            TransformWriter tw = new TransformWriter(tstream, trans);
+            StreamWriter sw = new StreamWriter(tw);
+
+            String line;
+            while ((line = sr.ReadLine()) != null)
+                sw.WriteLine(line);
+            sw.Close();
+        }
+    }
+    public interface ITransform
+    {
+        byte transform(byte ch);
+    }
+    public class Encrypt : ITransform
+    {
+        const String str = "xyfagchbimpourvnqsdewtkjzl";
+        byte ITransform.transform(byte ch)
+        {
+            if (char.IsLower((char)ch))
+                ch = (byte)str[ch - (byte)'a'];
+            return ch;
+        }
+    }
+    class Decrypt : ITransform
+    {
+        const String str = "xyfagchbimpourvnqsdewtkjzl";
+        byte ITransform.transform(byte ch)
+        {
+            if (char.IsLower((char)ch))
+                ch = (byte)(str.IndexOf((char)ch) + 'a');
+            return ch;
+        }
+    }
+    class TransformWriter : Stream, IDisposable
+    {
+        private Stream outs;
+        private ITransform trans;
+
+        public TransformWriter(Stream s, ITransform t)
+        {
+            this.outs = s;
+            this.trans = t;
+        }
+
+        public override bool CanRead
+        {
+            get { return false; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return true; }
+        }
+        public override void Flush()
+        {
+            outs.Flush();
+        }
+
+        public override long Length
+        {
+            get { return outs.Length; }
+        }
+        public override long Position
+        {
+            get
+            {
+                return outs.Position;
+            }
+            set
+            {
+                outs.Position = value;
+            }
+        }
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return outs.Seek(offset, origin);
+        }
+
+        public override void SetLength(long value)
+        {
+            outs.SetLength(value);
+        }
+
+        public override void Write(byte[] buf, int off, int len)
+        {
+            for (int i = off; i < off + len; i++)
+                buf[i] = trans.transform(buf[i]);
+            outs.Write(buf, off, len);
+        }
+
+        void IDisposable.Dispose()
+        {
+            outs.Dispose();
+        }
+
+        public override void Close()
+        {
+            outs.Close();
+        }
+
+        public override int Read(byte[] cbuf, int off, int count)
+        {
+            return outs.Read(cbuf, off, count);
+        }
+    }
+}

Task/Substitution-cipher/C/substitution-cipher.c

@@ -0,0 +1,64 @@
+#include<stdlib.h>
+#include<stdio.h>
+#include<wchar.h>
+
+#define ENCRYPT 0
+#define DECRYPT 1
+#define ALPHA 33
+#define OMEGA 126
+
+int wideStrLen(wchar_t* str){
+	int i = 0;
+	while(str[i++]!=00);
+	
+	return i;
+}
+
+void processFile(char* fileName,char plainKey, char cipherKey,int flag){
+	
+	FILE* inpFile = fopen(fileName,"r");
+	FILE* outFile;
+	
+	int i,len, diff = (flag==ENCRYPT)?(int)cipherKey - (int)plainKey:(int)plainKey - (int)cipherKey;
+	wchar_t str[1000], *outStr;
+	char* outFileName = (char*)malloc((strlen(fileName)+5)*sizeof(char));
+
+	sprintf(outFileName,"%s_%s",fileName,(flag==ENCRYPT)?"ENC":"DEC");
+	
+	outFile = fopen(outFileName,"w");
+	
+	while(fgetws(str,1000,inpFile)!=NULL){
+		len = wideStrLen(str);
+		
+		outStr = (wchar_t*)malloc((len + 1)*sizeof(wchar_t));
+		
+		for(i=0;i<len;i++){
+			if((int)str[i]>=ALPHA && (int)str[i]<=OMEGA && flag == ENCRYPT)
+				outStr[i] = (wchar_t)((int)str[i]+diff);
+			 else if((int)str[i]-diff>=ALPHA && (int)str[i]-diff<=OMEGA && flag == DECRYPT)
+				outStr[i] = (wchar_t)((int)str[i]-diff);
+			else
+				outStr[i] = str[i];
+		}
+		outStr[i]=str[i];
+		
+		fputws(outStr,outFile);
+		
+		free(outStr);
+	}
+	
+	fclose(inpFile);
+	fclose(outFile);
+}
+
+int main(int argC,char* argV[]){
+	if(argC!=5)
+		printf("Usage : %s <file name, plain key, cipher key, action (E)ncrypt or (D)ecrypt>",argV[0]);
+	else{
+		processFile(argV[1],argV[2][0],argV[3][0],(argV[4][0]=='E'||argV[4][0]=='e')?ENCRYPT:DECRYPT);
+		
+		printf("File %s_%s has been written to the same location as input file.",argV[1],(argV[4][0]=='E'||argV[4][0]=='e')?"ENC":"DEC");
+	}
+	
+	return 0;
+}

Task/Substitution-cipher/D/substitution-cipher.d

@@ -0,0 +1,30 @@
+import std.stdio;
+import std.string;
+import std.traits;
+
+string text =
+`Here we have to do is there will be a input/source
+ file in which we are going to Encrypt the file by replacing every
+ upper/lower case alphabets of the source file with another
+ predetermined upper/lower case alphabets or symbols and save
+ it into another output/encrypted file and then again convert
+ that output/encrypted file into original/decrypted file. This
+ type of Encryption/Decryption scheme is often called a
+ Substitution Cipher.`;
+
+void main() {
+    auto enc = encode(text);
+    writeln("Encoded: ", enc);
+    writeln;
+    writeln("Decoded: ", decode(enc));
+}
+
+enum FORWARD = "A~B!C@D#E$F%G^H&I*J(K)L+M=N[O]P{Q}R<S>T/U?V:W;X.Y,Z a\tbcdefghijkl\nmnopqrstuvwxyz";
+auto encode(string input) {
+    return tr(input, FORWARD, REVERSE);
+}
+
+enum REVERSE = "VsciBjedgrzy\nHalvXZKtUP um\tGf?I/w>J<x.q,OC:F;R{A]p}n[D+h=Q)W(o*b&L^k%E$S#Y@M!T~N";
+auto decode(string input) {
+    return tr(input, REVERSE, FORWARD);
+}

Task/Substitution-cipher/Factor/substitution-cipher.factor

@@ -0,0 +1,51 @@
+USING: assocs combinators combinators.short-circuit command-line
+hashtables io io.encodings.utf8 io.files kernel math.order
+multiline namespaces qw sequences ;
+IN: rosetta-code.substitution-cipher
+
+CONSTANT: alphabet
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+CONSTANT: default-key
+    "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+
+SYMBOL: key
+
+STRING: usage
+Usage:
+  substitution
+  <encode|decode>
+  input-file
+  output-file
+  [key-file]  (Optional -- for custom alphabet keys.)
+
+Example:
+  substitution encode my-poem.txt my-encoded-poem.txt
+;
+
+: check-args ( seq -- ? )
+    {
+        [ length 3 4 between? not ]
+        [ first qw{ encode decode } member? not ]
+    } 1|| [ usage print f ] [ t ] if ;
+
+: init-key ( seq -- )
+    dup length 4 = [ last utf8 file-contents ]
+    [ drop default-key ] if key set ;
+
+: >sub-map ( seq -- assoc )
+    [ alphabet key get ] dip first "encode" = [ swap ] unless
+    zip >hashtable ;
+
+: encipher ( seq assoc -- newseq )
+    [ dupd at dup [ nip ] [ drop ] if ] curry { } map-as ;
+
+: substitute ( seq -- )
+    { [ init-key ] [ second ] [ >sub-map ] [ third ] } cleave
+    [ utf8 file-contents ] [ encipher ]
+    [ utf8 set-file-contents ] tri* ;
+
+: main ( -- )
+    command-line get dup check-args [ substitute ] [ drop ] if ;
+
+MAIN: main

Task/Substitution-cipher/Fortran/substitution-cipher.f

@@ -0,0 +1,94 @@
+program substitution
+  implicit none
+
+  integer, parameter :: len_max = 256
+  integer, parameter :: eof = -1
+  integer :: in_unit = 9, out_unit = 10, ios
+  character(len_max) :: line
+
+  open(in_unit, file="plain.txt",  iostat=ios)
+  if (ios /= 0) then
+    write(*,*) "Error opening plain.txt file"
+    stop
+  end if
+
+  open(out_unit, file="encrypted.txt", iostat=ios)
+  if (ios /= 0) then
+    write(*,*) "Error opening encrypted.txt file"
+    stop
+  end if
+
+! Encryption
+  do
+    read(in_unit, "(a)", iostat=ios) line
+    if (ios > 0) then
+      write(*,*) "Error reading plain.txt file"
+      stop
+    else if (ios == eof) then
+      exit
+    end if
+
+    call cipher(trim(line))
+    write(out_unit, "(a)", iostat=ios) trim(line)
+    if (ios /= 0) then
+      write(*,*) "Error writing encrypted.txt file"
+      stop
+    end if
+  end do
+
+  close(in_unit)
+  close(out_unit)
+
+  open(in_unit, file="encrypted.txt",  iostat=ios)
+  if (ios /= 0) then
+    write(*,*) "Error opening encrypted.txt file"
+    stop
+  end if
+
+  open(out_unit, file="decrypted.txt", iostat=ios)
+  if (ios /= 0) then
+    write(*,*) "Error opening decrypted.txt file"
+    stop
+  end if
+
+! Decryption
+  do
+    read(in_unit, "(a)", iostat=ios) line
+    if (ios > 0) then
+      write(*,*) "Error reading encrypted.txt file"
+      stop
+    else if (ios == eof) then
+      exit
+    end if
+
+    call cipher(trim(line))
+    write(out_unit, "(a)", iostat=ios) trim(line)
+    if (ios /= 0) then
+      write(*,*) "Error writing decrypted.txt file"
+      stop
+    end if
+  end do
+
+  close(in_unit)
+  close(out_unit)
+
+contains
+
+subroutine cipher(text)
+  character(*), intent(in out) :: text
+  integer :: i
+
+! Substitutes A -> Z, B -> Y ... Y -> B, Z -> A and ditto for lower case
+! works for both encryption and decryption
+
+  do i = 1, len(text)
+    select case(text(i:i))
+      case ('A':'Z')
+        text(i:i) = achar(155 - iachar(text(i:i)))
+      case ('a':'z')
+        text(i:i) = achar(219 - iachar(text(i:i)))
+    end select
+  end do
+end subroutine
+
+end program

Task/Substitution-cipher/FreeBASIC/substitution-cipher.basic

@@ -0,0 +1,40 @@
+' FB 1.05.0 Win64
+
+' uses same alphabet and key as Ada language example
+Const string1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+Const string2 = "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+
+Sub process(inputFile As String, outputFile As String, encrypt As Boolean)
+   Open inputFile For Input As #1
+   If err > 0 Then
+     Print "Unable to open input file"
+     Sleep
+     End
+   End If
+   Dim As String alpha, key
+   If encrypt Then
+     alpha = string1 : key = string2
+   Else
+     alpha = string2 : key = string1
+   End If
+   Open outputFile For Output As #2
+   Dim s As String
+   Dim p As Integer
+   While Not Eof(1)
+     Line Input #1, s
+     For i As Integer = 0 To Len(s) - 1
+       If (s[i] >= 65 AndAlso s[i] <= 90) OrElse (s[i] >= 97 AndAlso s[i] <= 122) Then
+         p =  Instr(alpha, Mid(s, i + 1, 1)) - 1
+         s[i] = key[p]
+       End If
+     Next
+     Print #2, s
+   Wend
+   Close #1 : Close #2
+End Sub
+
+process "plain.txt", "encrypted.txt", true
+process "encrypted.txt", "decrypted.txt", false
+Print
+Print "Press any key to quit"
+Sleep

Task/Substitution-cipher/Go/substitution-cipher.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+    "fmt"
+    "strings"
+)
+
+var key = "]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+
+func encode(s string) string {
+    bs := []byte(s)
+    for i := 0; i < len(bs); i++ {
+        bs[i] = key[int(bs[i]) - 32]
+    }
+    return string(bs)
+}
+
+func decode(s string) string {
+    bs := []byte(s)
+    for i := 0; i < len(bs); i++ {
+        bs[i] = byte(strings.IndexByte(key, bs[i]) + 32)
+    }
+    return string(bs)
+}
+
+func main() {
+    s := "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+    enc := encode(s)
+    fmt.Println("Encoded: ", enc)
+    fmt.Println("Decoded: ", decode(enc))
+}

Task/Substitution-cipher/Haskell/substitution-cipher.hs

@@ -0,0 +1,36 @@
+import Data.Char          (chr)
+import Data.Maybe         (fromMaybe)
+import Data.Tuple         (swap)
+import System.Environment (getArgs)
+
+data Command = Cipher String | Decipher String | Invalid
+
+alphabet :: String
+alphabet = chr <$> [32..126]
+
+cipherMap :: [(Char, Char)]
+cipherMap = zip alphabet (shuffle 20 alphabet)
+
+shuffle :: Int -> [a] -> [a]
+shuffle n xs = iterate go xs !! n
+  where
+    go [] = []
+    go xs = go (drop 2 xs) <> take 2 xs
+
+convert :: Eq a => [(a, a)] -> [a] -> [a]
+convert m = map (\x -> fromMaybe x (lookup x m))
+
+runCommand :: Command -> String
+runCommand (Cipher s)   = convert cipherMap s
+runCommand (Decipher s) = convert (swap <$> cipherMap) s
+runCommand Invalid = "Invalid arguments. Usage: simplecipher c|d <text>"
+
+parseArgs :: [String] -> Command
+parseArgs (x:y:xs)
+  | x == "c" = Cipher y
+  | x == "d" = Decipher y
+  | otherwise = Invalid
+parseArgs _ = Invalid
+
+main :: IO ()
+main = parseArgs <$> getArgs >>= putStrLn . runCommand

Task/Substitution-cipher/IS-BASIC/substitution-cipher.basic

@@ -0,0 +1,53 @@
+100 PROGRAM "SuChiper.bas"
+110 STRING ST$(1 TO 2)*52,K$*1
+120 LET ST$(1)="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+130 LET ST$(2)="VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+140 CLEAR SCREEN:PRINT "1 - encode, 2 - decode"
+150 DO
+160   LET K$=INKEY$
+170 LOOP UNTIL K$="1" OR K$="2"
+180 IF K$="1" THEN
+190   INPUT PROMPT "File name: ":NAME$
+200   IF OPENFILE(NAME$) THEN CALL CHIPER(1)
+210 ELSE
+220   IF OPENFILE("Encrypte.txt") THEN CALL CHIPER(2)
+230 END IF
+240 DEF OPENFILE(N$)
+250   LET OPENFILE=0
+260   WHEN EXCEPTION USE OPENERROR
+270     OPEN #1:N$
+280   END WHEN
+290   LET OPENFILE=-1
+300 END DEF
+310 DEF CHIPER(FUNC)
+320   LET EOF=0
+330   WHEN EXCEPTION USE OPENERROR
+340     IF FUNC=1 THEN
+350       OPEN #2:"Encrypte.txt" ACCESS OUTPUT
+360       LET OUTP=2
+370     ELSE
+380       OPEN #2:"Decrypte.txt" ACCESS OUTPUT
+390       LET OUTP=1
+400     END IF
+410   END WHEN
+420   WHEN EXCEPTION USE IOERROR
+430     DO
+440       GET #1:K$
+450       IF UCASE$(K$)>="A" AND UCASE$(K$)<="Z" THEN
+460         PRINT #2:ST$(OUTP)(POS(ST$(FUNC),K$));
+470       ELSE
+480         PRINT #2:K$;
+490       END IF
+500     LOOP UNTIL EOF
+510   END WHEN
+520   HANDLER IOERROR
+530     IF EXTYPE<>9228 THEN PRINT EXSTRING$(EXTYPE)
+540     CLOSE #2
+550     CLOSE #1
+560     LET EOF=1
+570   END HANDLER
+580 END DEF
+590 HANDLER OPENERROR
+600   PRINT EXSTRING$(EXTYPE)
+610   END
+620 END HANDLER

Task/Substitution-cipher/J/substitution-cipher.j

@@ -0,0 +1,9 @@
+keysubst=: [`(a.i.])`(a."_)}
+key=: 'Taehist' keysubst '!@#$%^&'
+enc=: a. {~ key i. ]
+dec=: key {~ a. i. ]
+
+   enc 'This is a test.'
+!$%^ %^ @ &#^&.
+   dec '!$%^ %^ @ &#^&.'
+This is a test.

Task/Substitution-cipher/Java/substitution-cipher.java

@@ -0,0 +1,38 @@
+public class SubstitutionCipher {
+
+    final static String key = "]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N"
+            + "[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ";
+
+    static String text = "Here we have to do is there will be a input/source "
+            + "file in which we are going to Encrypt the file by replacing every "
+            + "upper/lower case alphabets of the source file with another "
+            + "predetermined upper/lower case alphabets or symbols and save "
+            + "it into another output/encrypted file and then again convert "
+            + "that output/encrypted file into original/decrypted file. This "
+            + "type of Encryption/Decryption scheme is often called a "
+            + "Substitution Cipher.";
+
+    public static void main(String[] args) {
+        String enc = encode(text);
+        System.out.println("Encoded: " + enc);
+        System.out.println("\nDecoded: " + decode(enc));
+    }
+
+    static String encode(String s) {
+        StringBuilder sb = new StringBuilder(s.length());
+
+        for (char c : s.toCharArray())
+            sb.append(key.charAt((int) c - 32));
+
+        return sb.toString();
+    }
+
+    static String decode(String s) {
+        StringBuilder sb = new StringBuilder(s.length());
+
+        for (char c : s.toCharArray())
+            sb.append((char) (key.indexOf((int) c) + 32));
+
+        return sb.toString();
+    }
+}

Task/Substitution-cipher/Jq/substitution-cipher.jq

@@ -0,0 +1,25 @@
+def key:
+  "]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ";
+
+def encode:
+  (key|explode) as $key
+  | explode as $exploded
+  | reduce range(0;length) as $i ([];
+        . + [$key[ $exploded[$i] - 32]] )
+  | implode;
+
+def decode:
+  (key|explode) as $key
+  | explode as $exploded
+  | reduce range(0;length) as $i ([];
+       $exploded[$i] as $c
+       | . + [ $key | index($c) + 32] )
+  | implode ;
+
+def task:
+  "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+   | encode as $encoded
+   |"Encoded:  \($encoded)",
+    "Decoded:  \($encoded|decode)" ;
+
+task

Task/Substitution-cipher/Julia/substitution-cipher-1.julia

@@ -0,0 +1,23 @@
+module SubstitutionCiphers
+
+using Compat
+
+const key = "]kYV}(!7P\$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+
+function encode(s::AbstractString)
+    buf = IOBuffer()
+    for c in s
+        print(buf, key[Int(c) - 31])
+    end
+    return String(take!(buf))
+end
+
+function decode(s::AbstractString)
+    buf = IOBuffer()
+    for c in s
+        print(buf, Char(findfirst(==(c), key) + 31))
+    end
+    return String(take!(buf))
+end
+
+end  # module SubstitutionCiphers

Task/Substitution-cipher/Julia/substitution-cipher-2.julia

@@ -0,0 +1,5 @@
+let s = "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+    enc = SubstitutionCiphers.encode(s)
+    dec = SubstitutionCiphers.decode(enc)
+    println("Original: ", s, "\n -> Encoded: ", enc, "\n -> Decoded: ", dec)
+end

Task/Substitution-cipher/Klingphix/substitution-cipher.klingphix

@@ -0,0 +1,24 @@
+include ..\Utilitys.tlhy
+
+" ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+" VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+"A simple example"
+
+:Encode %mode !mode
+    %i %t
+    $mode not [rot rot swap rot] if
+    len [
+        !i
+        $i get swap !t
+        rot swap find
+        rot swap get
+        $t swap $i set
+    ] for
+    $mode not [rot rot swap rot] if
+;
+
+dup ?
+true Encode dup ?
+false Encode ?
+
+" " input

Task/Substitution-cipher/Kotlin/substitution-cipher.kotlin

@@ -0,0 +1,24 @@
+// version 1.0.6
+
+object SubstitutionCipher {
+    val key = "]kYV}(!7P\$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+
+    fun encode(s: String): String {
+        val sb = StringBuilder()
+        for (c in s) sb.append(key[c.toInt() - 32])
+        return sb.toString()
+    }
+
+    fun decode(s: String): String {
+        val sb = StringBuilder()
+        for (c in s) sb.append((key.indexOf(c) + 32).toChar())
+        return sb.toString()
+    }
+}
+
+fun main(args: Array<String>) {
+    val s = "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+    val enc = SubstitutionCipher.encode(s)
+    println("Encoded:  $enc")
+    println("Decoded:  ${SubstitutionCipher.decode(enc)}")
+}

Task/Substitution-cipher/Lambdatalk/substitution-cipher.lambdatalk

@@ -0,0 +1,52 @@
+{def small_ascii {S.map fromCharCode {S.serie 33 122}}}
+-> small_ascii
+
+{S.length {small_ascii}} = 90
+
+{def substitution
+
+ {def substitution.r
+  {lambda {:w :n :s :i}
+   {if {> :i :n}
+    then
+    else {let { {:s :s} {:c {W.char2code {A.get :i :w}}}
+              } {if {and {>= :c 33} {<= :c 122}}
+                 then {W.code2char {+ 33 {% {+ :c {- :s 33}} 90}}}
+                 else {if {= :c 248} then :c else}}
+         }{substitution.r :w :n :s {+ :i 1}} }}}
+
+ {lambda {:s :w}
+  {let { {:s :s} {:w {S.replace \s by ` in :w}}
+       } {S.replace `
+                 by space
+                 in {substitution.r {A.split :w}
+                                    {- {W.length :w} 1}
+                                    :s
+                                    0}} }}}
+-> substitution
+
+1) intitial text:
+
+{def txt
+Veni, Vidi, Vici is a Latin phrase popularly attributed to Julius Caesar who, according to Appian, used the phrase
+in a letter to the Roman Senate around 47 BC after he had achieved a quick victory in his short war against
+Pharnaces II of Pontus at the Battle of Zela.
+} -> txt
+
+2) choose the shift:
+
+{def shift 13}
+-> shift // valid in [0...90] except 5 10 15 29 30 50 53 70 74
+
+3) encoding the text
+
+ {substitution {shift} {txt}}
+-> cr!v9mcvqv9mcvpvmv&mnmYn'v!m#u%n&rm#"#(yn%y,mn''%vo('rqm'"mW(yv(&mPnr&n%m*u"9mnpp"%qv!tm'"mN##vn!9m(&rqm'urm#u%n&rmv!mnmyr''r%m'"m'urm_"zn!m r!n'rmn%"
+(!qmADmOPmns'r%murmunqmnpuvr)rqmnm$(vpxm)vp'"%,mv!muv&m&u"%'m*n%mntnv!&'m]un%!npr&mVVm"sm]"!'(&mn'm'urmOn''yrm"smgryn;
+
+4) decoding the text
+
+ {substitution {- 90 {shift}} {substitution {shift} {txt}}}
+-> Veni, Vidi, Vici is a Latin phrase popularly attributed to Julius Caesar who, according to Appian, used the phrase
+in a letter to the Roman Senate around 47 BC after he had achieved a quick victory in his short war against
+Pharnaces II of Pontus at the Battle of Zela.

Task/Substitution-cipher/Lua/substitution-cipher.lua

@@ -0,0 +1,51 @@
+-- Generate a random substitution cipher for ASCII characters 65 to 122
+function randomCipher ()
+    local cipher, rnd = {plain = {}, encoded = {}}
+    for ascii = 65, 122 do
+        table.insert(cipher.plain, string.char(ascii))
+        table.insert(cipher.encoded, string.char(ascii))
+    end
+    for i = 1, #cipher.encoded do
+        rnd = math.random(#cipher.encoded)
+        cipher.encoded[i], cipher.encoded[rnd] = cipher.encoded[rnd], cipher.encoded[i]
+    end
+    return cipher
+end
+
+-- Encipher text using cipher.  Decipher if decode is true.
+function encode (text, cipher, decode)
+    local output, letter, found, source, dest = ""
+    if decode then
+        source, dest = cipher.encoded, cipher.plain
+    else
+        source, dest = cipher.plain, cipher.encoded
+    end
+    for pos = 1, #text do
+        letter = text:sub(pos, pos)
+        found = false
+        for k, v in pairs(source) do
+            if letter == v then
+                output = output .. dest[k]
+                found = true
+                break
+            end
+        end
+        if not found then output = output .. letter end
+    end
+    return output
+end
+
+-- Main procedure
+math.randomseed(os.time())
+local subCipher = randomCipher()
+print("Cipher generated:")
+print("\tPlain:", table.concat(subCipher.plain))
+print("\tCoded:", table.concat(subCipher.encoded))
+local inFile = io.open("C:\\ulua\\taskDescription.txt", "r")
+local input = inFile:read("*all")
+inFile:close()
+local encoded = encode(input, subCipher)
+print("\nEncoded file contents:")
+print("\t" .. encoded)
+print("\nAbove text deciphers to: ")
+print("\t" .. encode(encoded, subCipher, true))

Task/Substitution-cipher/Mathematica/substitution-cipher.math

@@ -0,0 +1,11 @@
+SeedRandom[1234];
+a=Characters@"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ";
+map=Thread[a->RandomSample[a]];
+ClearAll[SubstitutionCipherEncode,SubstitutionCipherDecode]
+SubstitutionCipherEncode[input_String,map_]:=StringReplace[input,map]
+SubstitutionCipherDecode[input_String,map_]:=StringReplace[input,Reverse/@map]
+
+str="The quick brown fox jumps over the lazy dog,who barks VERY loudly!";
+encoded=SubstitutionCipherEncode[str,map]
+decoded=SubstitutionCipherDecode[encoded,map]
+str===decoded

Task/Substitution-cipher/MiniScript/substitution-cipher.mini

@@ -0,0 +1,24 @@
+alphabet = "abcdefghijklmnopqrstuvwxyz".split("")
+cipher = alphabet[0:]
+cipher.shuffle
+encode = {}
+decode = {}
+for i in alphabet.indexes
+    encode[alphabet[i]] = cipher[i]
+    decode[cipher[i]] = alphabet[i]
+    encode[alphabet[i].upper] = cipher[i].upper
+    decode[cipher[i].upper] = alphabet[i].upper
+end for
+
+apply = function(map, s)
+    chars = s.split("")
+    for i in chars.indexes
+        if map.hasIndex(chars[i]) then chars[i] = map[chars[i]]
+    end for
+    return chars.join("")
+end function
+
+msg = "Now is the time for all good men (and women) to come together."
+secretCode = apply(encode, msg)
+print secretCode
+print apply(decode, secretCode)

Task/Substitution-cipher/Nim/substitution-cipher.nim

@@ -0,0 +1,29 @@
+import sequtils, strutils
+
+proc encrypt(key: seq[char]; msg: string): string =
+  result.setLen(msg.len)
+  for i, c in msg:
+    result[i] = key[ord(c) - 32]
+
+proc decrypt(key: seq[char]; msg: string): string =
+  result.setLen(msg.len)
+  for i, c in msg:
+    result[i] = chr(key.find(c) + 32)
+
+when isMainModule:
+
+  import random
+  randomize()
+
+  # Build a random key.
+  var key = toSeq(32..126).mapIt(chr(it))   # All printable characters.
+  key.shuffle()
+
+  const Message = "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+  let encrypted = key.encrypt(Message)
+  let decrypted = key.decrypt(encrypted)
+
+  echo "Key =       “$#”" % key.join()
+  echo "Message =   “$#”" % Message
+  echo "Encrypted = “$#”" % encrypted
+  echo "Decrypted = “$#”" % decrypted

Task/Substitution-cipher/PHP/substitution-cipher.php

@@ -0,0 +1,19 @@
+<?php
+
+$alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+$key      = 'cPYJpjsBlaOEwRbVZIhQnHDWxMXiCtUToLkFrzdAGymKvgNufeSq';
+
+// Encode input.txt, and save result in output.txt
+file_put_contents('output.txt', strtr(file_get_contents('input.txt'), $alphabet, $key));
+
+$source  = file_get_contents('input.txt');
+$encoded = file_get_contents('output.txt');
+$decoded = strtr($encoded, $key, $alphabet);
+
+echo
+    '== SOURCE ==', PHP_EOL,
+    $source, PHP_EOL, PHP_EOL,
+    '== ENCODED ==', PHP_EOL,
+    $encoded, PHP_EOL, PHP_EOL,
+    '== DECODED ==', PHP_EOL,
+    $decoded, PHP_EOL, PHP_EOL;

Task/Substitution-cipher/Perl/substitution-cipher.pl

@@ -0,0 +1,43 @@
+sub encode {
+    my $source = shift;
+    my $key = shift;
+    my $out = q();
+
+    @ka = split //, $key;
+    foreach $ch (split //, $source) {
+        $idx = ord($ch) - 32;
+        $out .= $ka[$idx];
+    }
+
+    return $out;
+}
+
+sub decode {
+    my $source = shift;
+    my $key = shift;
+    my $out = q();
+
+    foreach $ch (split //, $source) {
+        $idx = index $key, $ch;
+        $val = chr($idx + 32);
+        $out .= $val;
+    }
+
+    return $out;
+}
+
+my $key = q(]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\C1yxJ);
+my $text = "Here we have to do is there will be a input/source "
+         . "file in which we are going to Encrypt the file by replacing every "
+         . "upper/lower case alphabets of the source file with another "
+         . "predetermined upper/lower case alphabets or symbols and save "
+         . "it into another output/encrypted file and then again convert "
+         . "that output/encrypted file into original/decrypted file. This "
+         . "type of Encryption/Decryption scheme is often called a "
+         . "Substitution Cipher.";
+
+my $ct = encode($text, $key);
+print "Encoded: $ct\n";
+
+my $pt = decode($ct, $key);
+print "Decoded: $pt\n";

Task/Substitution-cipher/Phix/substitution-cipher.phix

@@ -0,0 +1,19 @@
+(phixonline)-->
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">plain</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'Z'</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'A'</span><span style="color: #0000FF;">)&</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'z'</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'a'</span><span style="color: #0000FF;">),</span>
+          <span style="color: #000000;">key</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">plain</span><span style="color: #0000FF;">)</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">encode</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">decrypt</span><span style="color: #0000FF;">=</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">decrypt</span><span style="color: #0000FF;">?{</span><span style="color: #000000;">plain</span><span style="color: #0000FF;">,</span><span style="color: #000000;">key</span><span style="color: #0000FF;">}:{</span><span style="color: #000000;">key</span><span style="color: #0000FF;">,</span><span style="color: #000000;">plain</span><span style="color: #0000FF;">})</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">ki</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">ki</span> <span style="color: #008080;">then</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">[</span><span style="color: #000000;">ki</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #004080;">string</span> <span style="color: #000000;">original</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"A simple example."</span><span style="color: #0000FF;">,</span>
+        <span style="color: #000000;">encoded</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">encode</span><span style="color: #0000FF;">(</span><span style="color: #000000;">original</span><span style="color: #0000FF;">),</span>
+        <span style="color: #000000;">decoded</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">encode</span><span style="color: #0000FF;">(</span><span style="color: #000000;">encoded</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
+
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"original: %s\nencoded: %s\ndecoded: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">original</span><span style="color: #0000FF;">,</span><span style="color: #000000;">encoded</span><span style="color: #0000FF;">,</span><span style="color: #000000;">decoded</span><span style="color: #0000FF;">})</span>
+<!--

Task/Substitution-cipher/Phixmonti/substitution-cipher.phixmonti

@@ -0,0 +1,22 @@
+include ..\Utilitys.pmt
+
+" ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+" VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+"A simple example"
+
+def Encode
+    >ps
+    tps not if >ps swap ps> endif
+    len for
+        >ps
+        tps get swap >ps
+        rot swap find
+        rot swap get
+        ps> swap ps> set
+    endfor
+    ps> not if >ps swap ps> endif
+enddef
+
+dup ?
+true Encode dup ?
+false Encode ?

Task/Substitution-cipher/Picat/substitution-cipher-1.picat

@@ -0,0 +1,40 @@
+main =>
+  S = "The quick brown fox jumped over the lazy dog",
+  cypher(S,E),  % encrypt
+  println(E),
+
+  cypher(D, E), % decrypt
+  println(D),
+
+  S == D,
+  println(ok).
+
+cypher(O, S) :-
+  nonvar(O),
+  var(S),
+  sub_chars(O,S).
+cypher(O, S) :-
+  nonvar(S),
+  var(O),
+  sub_chars(O,S).
+
+base("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ").
+subs("VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWob LkESYMTN").
+
+sub_chars(Original,Subbed) :-
+  base(Base),
+  subs(Subs),
+  maplist($sub_char(Base,Subs),Original,Subbed).
+
+sub_char([Co|_],[Cs|_],Co,Cs) :- !.
+sub_char([_|To],[_|Ts], Co, Cs) :- sub_char(To,Ts,Co,Cs).
+
+maplist(Goal, List1, List2) :-
+    maplist_(List1, List2, Goal).
+
+maplist_([], X, _) :- X = [].
+maplist_([Elem1|Tail1],
+         [Elem2|Tail2],
+         Goal) :-
+    call(Goal, Elem1, Elem2),
+    maplist_(Tail1, Tail2, Goal).

Task/Substitution-cipher/Picat/substitution-cipher-2.picat

@@ -0,0 +1,23 @@
+main =>
+  S = "The quick brown fox jumped over the lazy dog!!!",
+  E = encrypt(S),
+  println(E),
+  D = decrypt(E),
+  println(D),
+
+  D == S,
+  println(ok),
+  nl.
+
+encrypt(L) = [EncryptMap.get(C,C) : C in L] =>
+  base(Base),
+  subs(Subs),
+  EncryptMap = new_map([B=S : {B,S} in zip(Base,Subs)]).
+
+decrypt(L) = [DecryptMap.get(C,C) : C in L] =>
+  base(Base),
+  subs(Subs),
+  DecryptMap = new_map([S=B : {B,S} in zip(Base,Subs)]).
+
+base("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ").
+subs("VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWob LkESYMTN").

Task/Substitution-cipher/PicoLisp/substitution-cipher.l

@@ -0,0 +1,19 @@
+(setq *A (chop "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"))
+(setq *K (chop "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"))
+
+(de cipher (Str D)
+   (let (K *K  A *A)
+      (and D (xchg 'A 'K))
+      (pack
+         (mapcar
+            '((N)
+               (or
+                  (pick
+                     '((A K) (and (= A N) K))
+                     A
+                     K )
+                  N ) )
+            (chop Str) ) ) ) )
+(and
+   (println 'encode (cipher "The quick brown fox jumped over the lazy dog's back"))
+   (println 'decode (cipher @ T)) )

Task/Substitution-cipher/Pike/substitution-cipher.pike

@@ -0,0 +1,11 @@
+string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+string key      = "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN";
+mapping key_mapping = mkmapping(alphabet/1, key/1);
+object c = Crypto.Substitution()->set_key(key_mapping);
+
+string msg = "The quick brown fox jumped over the lazy dogs";
+string msg_enc = c->encrypt(msg);
+string msg_dec = c->decrypt(msg_enc);
+
+write("Encrypted: %s\n", msg_enc);
+write("Decrypted: %s\n", msg_dec);

Task/Substitution-cipher/Prolog/substitution-cipher.pro

@@ -0,0 +1,24 @@
+cypher(O, S) :-
+	nonvar(O),
+	var(S),
+	atom_chars(O,Oc),
+	sub_chars(Oc,Sc),
+	atom_chars(S,Sc).
+cypher(O, S) :-
+	nonvar(S),
+	var(O),
+	atom_chars(S,Sc),
+	sub_chars(Oc,Sc),
+	atom_chars(O,Oc).	
+	
+% mapping based on ADA implementation but have added space character	
+base(['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,' ']).
+subs(['V',s,c,i,'B',j,e,d,g,r,z,y,'H',a,l,v,'X','Z','K',t,'U','P',u,m,'G',f,'I',w,'J',x,q,'O','C','F','R','A',p,n,'D',h,'Q','W',o,b,' ','L',k,'E','S','Y','M','T','N']).
+
+sub_chars(Original,Subbed) :-
+	base(Base),
+	subs(Subs),
+	maplist(sub_char(Base,Subs),Original,Subbed).	
+	
+sub_char([Co|_],[Cs|_],Co,Cs) :- !.
+sub_char([_|To],[_|Ts], Co, Cs) :- sub_char(To,Ts,Co,Cs).

Task/Substitution-cipher/Python/substitution-cipher-1.py

@@ -0,0 +1,19 @@
+from string import printable
+import random
+
+EXAMPLE_KEY = ''.join(sorted(printable, key=lambda _:random.random()))
+
+def encode(plaintext, key):
+    return ''.join(key[printable.index(char)] for char in plaintext)
+
+def decode(plaintext, key):
+    return ''.join(printable[key.index(char)] for char in plaintext)
+
+original = "A simple example."
+encoded = encode(original, EXAMPLE_KEY)
+decoded = decode(encoded, EXAMPLE_KEY)
+print("""The original is: {}
+Encoding it with the key: {}
+Gives: {}
+Decoding it by the same key gives: {}""".format(
+    original, EXAMPLE_KEY, encoded, decoded))

Task/Substitution-cipher/Python/substitution-cipher-2.py

@@ -0,0 +1,7 @@
+The original is: A simple example.
+Encoding it with the key: dV1>r7:TLlJa<EFBFBD>uY o]MjH\hI^X	cPN#!fmv[
+<e=04|O'~{y$bAq@}U.WtF*)x/K?
+Q%S(<EFBFBD>RB;25&s6Z9C3+D-_8kn,`Egiwzp"G
+Gives:
+iPMhX\YiYmJhX\Y5
+Decoding it by the same key gives: A simple example.

Task/Substitution-cipher/Quackery/substitution-cipher.quackery

@@ -0,0 +1,45 @@
+  [ stack ]                      is encryption  (   --> s )
+  [ stack ]                      is decryption  (   --> s )
+
+  [ [] 95 times [ i^ join ]
+    shuffle encryption put ]     is makeencrypt (   -->   )
+
+  [ encryption share
+    0 95 of swap
+    witheach
+      [ i^ unrot poke ]
+    decryption put ]             is makedecrypt (   -->   )
+
+  [ makeencrypt makedecrypt ]    is makekeys    (   -->   )
+
+  [ witheach [ char ! + emit ] ] is echokey     ( s -->   )
+
+  [ encryption release
+    decryption release ]         is releasekeys (   -->   )
+
+  [ [] swap witheach
+      [ dup char ! char ~ 1+
+        within if
+          [ char ! -
+            encryption share
+            swap peek char ! + ]
+        join ] ]                 is encrypt     ( $ --> $ )
+
+  [ [] swap witheach
+      [ dup char ! char ~ 1+
+        within if
+          [ char ! -
+            decryption share
+            swap peek char ! + ]
+        join ] ]                 is decrypt    ( $ --> $ )
+
+  randomise
+  makekeys
+  say "Encryption key is: " encryption share echokey cr
+  say "Decryption key is: " decryption share echokey cr
+  cr
+  $ "Encryption matters, and it is not just for spies and philanderers."
+  say "Plaintext: " dup echo$ cr
+  say "Encrypted: " encrypt dup echo$ cr
+  say "Decrypted: " decrypt echo$ cr
+  releasekeys

Task/Substitution-cipher/REXX/substitution-cipher.rexx

@@ -0,0 +1,41 @@
+/*REXX program implements & demonstrates a substitution cipher for the records in a file*/
+parse arg fid.1 fid.2 fid.3 fid.4 .              /*obtain optional arguments from the CL*/
+if fid.1==''  then fid.1= "CIPHER.IN"            /*Not specified?  Then use the default.*/
+if fid.2==''  then fid.2= "CIPHER.OUT"           /* "      "         "   "   "     "    */
+if fid.3==''  then fid.3= "CIPHER.KEY"           /* "      "         "   "   "     "    */
+if fid.4==''  then fid.4= "CIPHER.ORI"           /* "      "         "   "   "     "    */
+say '    input file: '   fid.1                   /*display the fileID used for  input.  */
+say '   output file: '   fid.2                   /*   "     "     "     "   "  output.  */
+say '   cipher file: '   fid.3                   /*   "     "     "     "   " cipher-key*/
+say 'decrypted file: '   fid.4                   /*   "     "     "     "   "  decrypted*/
+call closer                                      /*close all files in case they're open.*/
+           do c=1  while lines(fid.3)\==0        /*read (hopefully 2 records) from key. */
+           @.c= space( linein(fid.3), 0)         /*assign input record to an  @.  array.*/
+           end   /*c*/
+c= c - 1                                         /*adjust the number of records (for DO)*/
+if c==0                       then call ser fid.3,  'not found or is empty.'
+if c>2                        then call ser fid.3,  'has too many records  (>2).'
+if c<2                        then call ser fid.3,  'has too few records   (<2).'
+if length(@.1)\==length(@.2)  then call ser fid.3,  'has unequal length records.'
+call encrypt  fid.1, fid.2                       /*encrypt the input file  ───►  output.*/
+_=@.1;    @.1=@.2;   @.2=_                       /*switch the cipher keys for decryption*/
+call encrypt  fid.2, fid.4                       /*decrypt the output file ───► decrypt.*/
+call show     'cipher file ('fid.3")" , fid.3    /*display the cipher─key file.         */
+call show      'input file ('fid.1")" , fid.1    /*   "     "     input     "           */
+call show     'output file ('fid.2")" , fid.2    /*   "     "    output     "           */
+call show ' decrypted file ('fid.4")" , fid.4    /*   "     "   decrypted   "           */
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+closer:  do f=1  for 4;   call lineout fid.f;    end  /*f*/;            say;      return
+ser:     say  '***error!***  file '     arg(1)" "    arg(2);                      exit
+show:    say;   say center( arg(1), 79, '═');        "TYPE"  arg(2);              return
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+encrypt: parse arg @in,@out                      /* [↓] effectively deletes @out file by*/
+         call lineout @out,,1                    /*setting pointer to rec#1 for the file*/
+                                do j=0  while lines(@in)\==0       /*read the input file*/
+                                call lineout @out, translate( linein(@in), @.2, @.1)
+                                end   /*j*/
+         if j==0  then call ser @in, 'is empty.' /*was the file not found or was empty? */
+         say @in  ' records processed: '   j     /*show the number of records processed.*/
+         call closer                             /*close all the files to be neat & safe*/
+         return

Task/Substitution-cipher/RISC-V-Assembly/substitution-cipher.asm

@@ -0,0 +1,45 @@
+# gnu assembler syntax
+substitution_cipher: # char* str (a0), uint len (a1), const char lowerkey[26] (a2), const char upperkey[26] (a3)
+        # set up temporary registers t0, t1, t2, t3
+        li t0, 'a
+        li t1, 'z
+        li t2, 'A
+        li t3, 'Z
+        # char tmp (t4)
+        # char* cipher (t5)
+
+        .dcB:                           # begin loop
+        beqz a1, .dcE                   # break condition
+        lb t4, 0(a0)                    # load one character from a0
+        blt t4, t0, .dcU                # lowercase check
+        bgt t4, t1, .dcI
+        addi t4, t4, -'a
+        mv t5, a2
+        j .dcA
+        .dcU:                           # uppercase check
+        blt t4, t2, .dcI
+        bgt t4, t3, .dcI
+        addi t4, t4, -'A
+        mv t5, a3
+        .dcA:                           # convert and save ciphertext character
+        add t5, t5, t4
+        lb t5, 0(t5)
+        sb t5, 0(a0)
+        .dcI:                           # increment registers
+        addi a1, a1, -1
+        addi a0, a0, 1
+        j .dcB
+        .dcE: ret                       # end loop
+
+# You can use the following cipher keys, which correspond to the Atbash cipher,
+# to test the substitution. These keys are self-inverse, which means that
+# applying them twice to a given plaintext yields the original plaintext again.
+latbash:        .ascii "zyxwvutsrqponmlkjihgfedcba"
+uatbash:        .ascii "ZYXWVUTSRQPONMLKJIHGFEDCBA"
+
+# For keys that are non-self-inverse, you will need to keep a separate set of
+# encryption and decryption keys.
+lzebras:        .ascii "zebrascdfghijklmnopqtuvwxy"
+uzebras:        .ascii "ZEBRASCDFGHIJKLMNOPQTUVWXY"
+ldzebras:       .ascii "ecghbijklmnopqrstdfuvwxyza"
+udzebras:       .ascii "ECGHBIJKLMNOPQRSTDFUVWXYZA"

Task/Substitution-cipher/Racket/substitution-cipher.rkt

@@ -0,0 +1,55 @@
+#lang racket/base
+(require racket/list racket/function racket/file)
+
+(define abc "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
+
+;; Used to generate my-key for examples
+(define (random-key (alphabet abc))
+  (list->string (shuffle (string->list alphabet))))
+
+(define (cypher/decypher key (alphabet abc))
+  ;; alist is fine, hashes are better over 40 chars... so alist for
+  ;; abc, hash for ASCII.
+  (define ab-chars (string->list alphabet))
+  (define ky-chars (string->list key))
+  (define cypher-alist (map cons ab-chars ky-chars))
+  (define decypher-alist (map cons ky-chars ab-chars))
+  (define ((subst-map alist) str)
+    (list->string (map (lambda (c) (cond [(assoc c alist) => cdr] [else c]))
+                       (string->list str))))
+  (values (subst-map cypher-alist)
+          (subst-map decypher-alist)))
+
+(define (cypher/decypher-files key (alphabet abc))
+  (define-values (cypher decypher) (cypher/decypher key alphabet))
+  (define ((convert-file f) in out #:exists (exists-flag 'error))
+     (curry with-output-to-file out #:exists exists-flag
+            (lambda () (display (f (file->string in))))))
+  (values (convert-file cypher)
+          (convert-file decypher)))
+
+(module+ test
+  (require rackunit)
+  (define my-key "LXRWzUrIYPJiVQyMwKudbAaDjSEefvhlqmOkGcBZCFsNpxHTgton")
+
+  (define-values (cypher decypher) (cypher/decypher my-key abc))
+
+  (define in-text #<<T
+The quick brown fox...
+.. jumped over
+the lazy dog!
+T
+    )
+  (define cypher-text (cypher in-text))
+
+  (define plain-text (decypher cypher-text))
+  (displayln cypher-text)
+  (check-equal? plain-text in-text)
+
+  (define-values (file-cypher file-decypher) (cypher/decypher-files my-key abc))
+  (file-cypher "data/substitution.in.txt" "data/substitution.crypt.txt" #:exists 'replace)
+  (file-decypher "data/substitution.crypt.txt" "data/substitution.plain.txt" #:exists 'replace)
+  (displayln "---")
+  (displayln (file->string "data/substitution.crypt.txt"))
+  (check-equal? (file->string "data/substitution.in.txt")
+                (file->string "data/substitution.plain.txt")))

Task/Substitution-cipher/Raku/substitution-cipher.raku

@@ -0,0 +1,36 @@
+my $chr = (' ' .. '}').join('');
+my $key = $chr.comb.pick(*).join('');
+
+# Be very boring and use the same key every time to fit task reqs.
+$key = q☃3#}^",dLs*>tPMcZR!fmC rEKhlw1v4AOgj7Q]YI+|pDB82a&XFV9yzuH<WT%N;iS.0e:`G\n['6@_{bk)=-5qx(/?$JoU☃;
+
+sub MAIN ($action = 'encode', $file = '') {
+
+    die 'Only options are encode or decode.' unless $action ~~ any 'encode'|'decode';
+
+    my $text = qq:to/END/;
+        Here we have to do is there will be a input/source file in which
+        we are going to Encrypt the file by replacing every upper/lower
+        case alphabets of the source file with another predetermined
+        upper/lower case alphabets or symbols and save it into another
+        output/encrypted file and then again convert that output/encrypted
+        file into original/decrypted file. This type of Encryption/Decryption
+        scheme is often called a Substitution Cipher.
+        END
+
+    $text = $file.IO.slurp if $file;
+
+    say "Key = $key\n";
+
+    if $file {
+        say &::($action)($text);
+    } else {
+        my $encoded;
+        say "Encoded text: \n {$encoded = encode $text}";
+        say "Decoded text: \n {decode $encoded}";
+    }
+}
+
+sub encode ($text) { $text.trans($chr => $key) }
+
+sub decode ($text) { $text.trans($key => $chr) }

Task/Substitution-cipher/Ring/substitution-cipher.ring

@@ -0,0 +1,48 @@
+# Project : Substitution Cipher
+
+plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ciphertext = "ZEBRASCDFGHIJKLMNOPQTUVWXY"
+test = "flee at once. we are discovered!"
+encrypt = "SIAA ZQ LKBA. VA ZOA RFPBLUAOAR!"
+
+see "Plaintext : " + plaintext + nl
+see "Ciphertext : " + ciphertext + nl
+see "Test : " + test + nl
+see "Encoded : "
+encodetext = encode(test)
+see encodetext + nl
+see "Decoded : "
+decodetext = decode(encodetext)
+see decodetext + nl
+
+func encode(test)
+        str = ""
+        for n = 1 to len(test)
+              pos = substr(plaintext, upper(test[n]))
+              if test[n] = " "
+                 str = str + " "
+              elseif test[n] = "!"
+                 str = str + "!"
+              elseif test[n] = "."
+                 str = str + "."
+              else
+                 str = str + substr(ciphertext, pos, 1)
+              ok
+        next
+        return str
+
+func decode(test)
+        str = ""
+        for n = 1 to len(encodetext)
+              pos = substr(ciphertext, upper(encodetext[n]))
+              if test[n] = " "
+                 str = str + " "
+              elseif test[n] = "!"
+                 str = str + "!"
+              elseif test[n] = "."
+                 str = str + "."
+              else
+                 str = str + lower(substr(plaintext, pos, 1))
+              ok
+        next
+        return str

Task/Substitution-cipher/Ruby/substitution-cipher.rb

@@ -0,0 +1,9 @@
+Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+Key      = "VsciBjedgrzyHalvXZKtUPumGfIwJxqOCFRApnDhQWobLkESYMTN"
+
+def encrypt(str) = str.tr(Alphabet, Key)
+def decrypt(str) = str.tr(Key, Alphabet)
+
+str = 'All is lost, he thought. Everything is ruined. It’s ten past three.'
+p encrypted =   encrypt(str)
+p decrypt(encrypted)

Task/Substitution-cipher/Scala/substitution-cipher.scala

@@ -0,0 +1,30 @@
+object SubstitutionCipher extends App {
+  private val key = "]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N" + "[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+  private val text =
+    """"It was still dark, in the early morning hours of the twenty-second of December
+      | 1946, on the second floor of the house at Schilderskade 66 in our town,
+      | when the hero of this story, Frits van Egters, awoke."""".stripMargin
+
+  val enc = encode(text)
+  println("Encoded: " + enc)
+  println("Decoded: " + decode(enc))
+
+  private def encode(s: String) = {
+    val sb = new StringBuilder(s.length)
+    s.map {
+      case c if (' ' to '~').contains(c) => sb.append(key(c.toInt - 32))
+      case _ =>
+    }
+    sb.toString
+  }
+
+  private def decode(s: String) = {
+    val sb = new StringBuilder(s.length)
+    s.map {
+      case c if (' ' to '~').contains(c) =>
+        sb.append((key.indexOf(c.toInt) + 32).toChar)
+      case _ =>
+    }
+    sb.toString
+  }
+}

Task/Substitution-cipher/Sidef/substitution-cipher.sidef

@@ -0,0 +1,27 @@
+module SubstitutionCipher {
+
+    const key = %c"]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+
+    func encode(String s) {
+        var r = ""
+        s.each {|c|
+            r += key[c.ord - 32]
+        }
+        return r
+    }
+
+    func decode(String s) {
+        var r = ""
+        s.each {|c|
+            r += (key.first_index { _ == c } + 32 -> chr)
+        }
+        return r
+    }
+}
+
+
+with ("The quick brown fox jumps over the lazy dog, who barks VERY loudly!") { |s|
+    var enc = SubstitutionCipher::encode(s)
+    var dec = SubstitutionCipher::decode(enc)
+    say("Original: ", s, "\n -> Encoded: ", enc, "\n -> Decoded: ", dec)
+}

Task/Substitution-cipher/Tcl/substitution-cipher-1.tcl

@@ -0,0 +1,59 @@
+oo::class create SubCipher {
+    variable Alphabet
+    variable Key
+    variable EncMap
+    variable DecMap
+    constructor {{alphabet abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ} {cipherbet ""}} {
+        set Alphabet $alphabet
+        if {$cipherbet eq ""} {
+            my key [my RandomKey]
+        } else {
+            my key $cipherbet
+        }
+    }
+    method key args {
+        if {$args eq ""} {
+            return $Key
+        } elseif {[llength $args] > 1} {
+            throw {TCL WRONGARGS} "Expected \"[self class] key\" or \"[self class]\" key keystring"
+        }
+        lassign $args s
+
+        set size [string length $Alphabet]
+        if {[string length $s] != $size} {
+            return -code error "Key must be $size chars long!"
+        }
+        set encmap {}
+        set decmap {}
+        foreach c [split $Alphabet {}] e [split $s {}] {
+            dict set encmap $c $e
+            dict set decmap $e $c
+        }
+        if {[dict size $encmap] != $size} {
+            return -code error "Alphabet has repeating characters!"
+        }
+        if {[dict size $decmap] != $size} {
+            return -code error "Key has repeating characters!"
+        }
+        set Key $s
+        set EncMap $encmap
+        set DecMap $decmap
+    }
+    method RandomKey {} {
+        set chars $Alphabet
+        set key {}
+        for {set n [string length $chars]} {$n > 0} {incr n -1} {
+            set i [expr {int(rand()*$n)}]
+            append key [string index $chars $i]
+            set chars [string range $chars 0 $i-1][string range $chars $i+1 end]
+        }
+        return $key
+    }
+
+    method enc {s} {
+        string map $EncMap $s
+    }
+    method dec {s} {
+        string map $DecMap $s
+    }
+}

Task/Substitution-cipher/Tcl/substitution-cipher-2.tcl

@@ -0,0 +1,6 @@
+SubCipher create sc
+set text [read [open /etc/motd]]
+puts "Original:\n$text\n----\n"
+puts "Ciphered:\n[set cipher [sc enc $text]]\n----\n"
+puts "Decrypted:\n[sc dec $cipher]\n----\n"
+puts "Key:\n[sc key]\n----\n"

Task/Substitution-cipher/V-(Vlang)/substitution-cipher.v

@@ -0,0 +1,27 @@
+const
+(
+	key = "]kYV}(!7P\$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+	text = "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+)
+
+fn main() {
+	encoded := encode(text)
+	println(encoded)
+	println(decode(encoded))
+}
+
+fn encode(str string) string {
+	mut chr_arr := []u8{}
+	for chr in str {
+		chr_arr << key[u8(chr - 32)]
+	}
+	return chr_arr.bytestr()
+}
+
+fn decode(str string) string {
+	mut chr_arr := []u8{}
+	for chr in str {
+		chr_arr << u8(key.index_u8(chr) + 32)
+	}
+	return chr_arr.bytestr()
+}

Task/Substitution-cipher/VBScript/substitution-cipher.vb

@@ -0,0 +1,55 @@
+option explicit
+const maxk=94
+dim key(94)
+
+a="I'm working on modernizing Rosetta Code's infrastructure. Starting with communications."&_
+" Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)"
+
+sub gen     'swaps items not previusly affected by a swap
+  dim i,m,t
+  for i=0 to ubound(key)
+    key(i)=i+32
+  next
+  for i=0 to ubound(key)-1
+    if key(i)=i+32 then
+      m=i+int(rnd*(maxk-i))
+     if key(m)=m+32 then
+       t=key(m):key(m)=key(i):key(i)=t
+     end if
+   end if
+  next
+end sub
+
+function viewkey
+dim i,b
+b=""
+for i=1 to ubound(key)
+   b=b&chr(key(i))
+next
+viewkey=b
+end function
+
+function iif(a,b,c) if a then iif=b else iif =c end if: end function
+
+function docode(a)
+  dim b,i,ch,n
+  n=maxk+32
+  b=""
+  for i=1 to len(a)
+   ch=asc(mid(a,i,1))
+   'wscript.echo ch
+   b=b&chr(key(iif (ch>n or ch<32,0,ch-32)))
+  next
+  docode=b
+end function
+
+randomize timer
+dim a,b,c
+gen
+wscript.echo "Key:   " & viewkey & vbcrlf
+wscript.echo "Original: " & a & Vbcrlf
+b=docode(a)
+wscript.echo "Encoded: "&  b & Vbcrlf
+c=docode(b)
+wscript.echo "Decoded: " & c & Vbcrlf
+wscript.quit(0)

Task/Substitution-cipher/Wren/substitution-cipher.wren

@@ -0,0 +1,18 @@
+var key = "]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6\%ZXs\"v*N[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ"
+
+var encode = Fn.new { |s|
+    var res = ""
+    for (c in s) res = res + key[c.bytes[0] - 32]
+    return res
+}
+
+var decode = Fn.new { |s|
+    var res = ""
+    for (c in s) res = res + String.fromByte(key.indexOf(c) + 32)
+    return res
+}
+
+var s = "The quick brown fox jumps over the lazy dog, who barks VERY loudly!"
+var enc = encode.call(s)
+System.print("Encoded:  %(enc)")
+System.print("Decoded:  %(decode.call(enc))")

Task/Substitution-cipher/Zkl/substitution-cipher-1.zkl

@@ -0,0 +1,7 @@
+class SubstitutionCipher{
+   // 92 characters: " !"#$%&" ... "xyz{|}", doesn't include "~"
+   const KEY="]kYV}(!7P$n5_0i R:?jOWtF/=-pe'AD&@r6%ZXs\"v*N"
+             "[#wSl9zq2^+g;LoB`aGh{3.HIu4fbK)mU8|dMET><,Qc\\C1yxJ";
+   fcn encode(s){ s.apply(fcn(c){ try{ KEY[c.toAsc()-32] }catch{ c } }) }
+   fcn decode(s){ s.apply(fcn(c){ try{ (KEY.index(c)+32).toChar() }catch{ c } }) }
+}

Task/Substitution-cipher/Zkl/substitution-cipher-2.zkl

@@ -0,0 +1,11 @@
+text:="Here we have to do is there will be a input/source "
+      "file in which we are going to Encrypt the file by replacing every "
+      "upper/lower case alphabets of the source file with another "
+      "predetermined upper/lower case alphabets or symbols and save "
+      "it into another output/encrypted file and then again convert "
+      "that output/encrypted file into original/decrypted file. This "
+      "type of Encryption/Decryption scheme is often called a "
+      "Substitution Cipher.";
+encoded:=SubstitutionCipher.encode(text);
+println(  "Encoded: ",encoded);
+println("\nDecoded: ",SubstitutionCipher.decode(encoded));