Chaocipher: Difference between revisions

 

;Task:

<br><br>

=={{header|11l}}==

{{trans|Python}}

 

R string.filter(s -> s.is_alpha()).map(s -> s.uppercase()).join(‘’)

 

print()

 

 

{{out}}

YFJBGMTKWNOQXCHIDVALZRSPUE JIBMESWKYZXUCOPRTLNHFAGVQD

</pre>

=={{header|Ada}}==

This solution uses array slices to permute the left and right strings. Use of slices clarifies the looping logic.

Ada strings are indexed with the predefined subtype Positive which begins at 1.

with Ada.Text_IO; use Ada.Text_IO;

 

Put_Line ("The recovered plaintext is : " & plaintext2);

end chao_slices;

{{output}}

<pre>

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID

</pre>

 

=={{header|Arc}}==

(= rshift '((1 3) (4 15) (3 4) (15 26) (0 1)))

 

(chaocipher "HXUCZVAMDSLKPEFJRIGTWOBNYQ" "PTLNBQDEOYSFAVZKGJRIHWXUMC"

"OAHQHCNYNXTSZJRRHJBYHQKSOUJY" nil 1)

 

{{output}}

arc> (chaocipher "HXUCZVAMDSLKPEFJRIGTWOBNYQ" "PTLNBQDEOYSFAVZKGJRIHWXUMC"

"WELLDONEISBETTERTHANWELLSAID")

YFJBGMTKWNOQXCHIDVALZRSPUE JIBMESWKYZXUCOPRTLNHFAGVQD

"OAHQHCNYNXTSZJRRHJBYHQKSOUJY"

=={{header|AutoHotkey}}==

RghtW := "PTLNBQDEOYSFAVZKGJRIHWXUMC"

 

Arr[14] := ch ; place 2nd/3rd chr in pos 14

return Arr

{{out}}

<pre>Original text: WELLDONEISBETTERTHANWELLSAID

Cipher text: OAHQHCNYNXTSZJRRHJBYHQKSOUJY

Decipher text: WELLDONEISBETTERTHANWELLSAID</pre>

 

=={{header|C}}==

{{trans|Kotlin}}

#include <string.h>

#include <stdlib.h>

free(plain_text2);

return 0;

 

{{output}}

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|C sharp|C#}}==

{{trans|D}}

 

namespace Chaocipher {

}

}

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

 

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|C++}}==

{{trans|C#}}

 

enum class Mode {

 

return 0;

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

 

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|D}}==

{{trans|Kotlin}}

import std.string;

 

auto plainText2 = exec(cipherText, Mode.DECRYPT);

writeln("\nThe recovered plaintext is : ", plainText2);

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

{{libheader| System.SysUtils}}

{{Trans|Kotlin}}

program Chaocipher;

 

writeln(#10'The recovered plaintext is : ', plainText2);

readln;

 

=={{header|F_Sharp|F#}}==

===The Functions===

// Implement Chaocipher. Nigel Galloway: July 13th., 2019

let pL n=function g when g=n->0 |g when g=(n+1)%26->13 |g->let x=(25+g-n)%26 in if x<13 then x else x+1

let decrypt lW rW txt=Array.scan(fun (_,lW,rW) t->let n=Array.findIndex(fun n->n=t) lW in ((Array.item n rW,Array.permute(pL n) lW,(Array.permute(pR n) rW))))('0',lW,rW) txt

|>Array.skip 1|>Array.map(fun(n,_,_)->n)|>System.String

 

===The Task===

printfn "%s" (encrypt ("HXUCZVAMDSLKPEFJRIGTWOBNYQ".ToCharArray()) ("PTLNBQDEOYSFAVZKGJRIHWXUMC".ToCharArray()) ("WELLDONEISBETTERTHANWELLSAID".ToCharArray()))

printfn "%s" (decrypt ("HXUCZVAMDSLKPEFJRIGTWOBNYQ".ToCharArray()) ("PTLNBQDEOYSFAVZKGJRIHWXUMC".ToCharArray()) ("OAHQHCNYNXTSZJRRHJBYHQKSOUJY".ToCharArray()))

{{out}}

<pre>

WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|Factor}}==

prettyprint sequences sequences.extras strings ;

IN: rosetta-code.chaocipher

[ print ] bi@ ;

{{out}}

<pre>

WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import(

plainText2 := Chao(cipherText, Decrypt, false)

fmt.Println("\nThe recovered plaintext is :", plainText2)

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private enum Mode {

ENCRYPT,

println("\nThe recovered plaintext is : $plainText2")

}

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

 

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|Haskell}}==

 

chao _ _ _ [] = []

where

(src, dst)

(x, y) = splitAt src a

 

encode = False

decode = True

 

main = do

let chaoWheels =

plainText = "WELLDONEISBETTERTHANWELLSAID"

cipherText = chaoWheels encode plainText

{{Out}}

<pre>

"WELLDONEISBETTERTHANWELLSAID"</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

 

public class Chaocipher {

System.out.printf("\nThe recovered plaintext is : %s\n", plainText2);

}

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

 

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|JavaScript}}==

{{trans|C}}

Script source

const R_ALPHABET = "PTLNBQDEOYSFAVZKGJRIHWXUMC";

 

var decipher_text = chao(cipher_text, DECRYPT, false);

out.innerHTML += "<p>The recovered plaintext is : " + decipher_text + "</p>";

 

Solution page

<html>

<head>

<div id="content"></div>

</body>

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

The ciphertext is : OAHQHCNYNXTSZJRRHJBYHQKSOUJY

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|Julia}}==

Modified from the Kotlin and Raku entries.

const rightalphabet = "PTLNBQDEOYSFAVZKGJRIHWXUMC"

 

 

testchacocipher("WELLDONEISBETTERTHANWELLSAID")

<pre>

The original plaintext is: WELLDONEISBETTERTHANWELLSAID

Decoded, the recovered plaintext is: WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|Kotlin}}==

This is based on the C# implementation referred to in the task description, except that the encrypt and decrypt operations are combined into a single method.

 

enum class Mode { ENCRYPT, DECRYPT }

val plainText2 = Chao.exec(cipherText, Mode.DECRYPT)

println("\nThe recovered plaintext is : $plainText2")

 

{{output}}

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|Lua}}==

local Chaocipher = {

ct = "HXUCZVAMDSLKPEFJRIGTWOBNYQ",

print("The original text was: " .. plainText)

print("The encrypted text is: " .. encryptText)

{{out}}

<pre>HXUCZVAMDSLKPEFJRIGTWOBNYQ PTLNBQDEOYSFAVZKGJRIHWXUMC O W

The encrypted text is: OAHQHCNYNXTSZJRRHJBYHQKSOUJY

The decrypted text is: WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

ichaoalphabet = CharacterRange["A", "Z"];

iMoveToFront[l_List, sel_] := Module[{p},

]

ChaoCipher["WELLDONEISBETTERTHANWELLSAID",{Characters@"PTLNBQDEOYSFAVZKGJRIHWXUMC",Characters@"HXUCZVAMDSLKPEFJRIGTWOBNYQ"}]

{{out}}

<pre>OAHQHCNYNXTSZJRRHJBYHQKSOUJY</pre>

=={{header|Nim}}==

{{trans|Kotlin}}

 

type

echo &"\nThe ciphertext is: {cipherText}"

var plainText2 = chao(cipherText, Decrypt, false)

{{out}}

<pre>

===Another implementation===

Using functions from the stdlib instead of manual array manipulations:

 

type

echo "\nThe ciphertext is: ", cipherText

let plainText2 = chao(cipherText, Decrypt, false)

Same output as above.

=={{header|Objeck}}==

{{trans|Kotlin}}

L_ALPHABET : static : Char[];

R_ALPHABET : static : Char[];

 

enum Mode { ENCRYPT, DECRYPT }

 

{{output}}

The recovered plaintext is: WELLDONEISBETTERTHANWELLSAID

</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

Since <tt>rotate</tt> is not a built-in in Perl, using a custom one, not general-purpose but sufficient for this task.

@left = split '', 'HXUCZVAMDSLKPEFJRIGTWOBNYQ';

@right = split '', 'PTLNBQDEOYSFAVZKGJRIHWXUMC';

 

sub rotate {

my($n,$s,$e) = @_;

}

 

 

{{out}}

WELLDONEISBETTERTHANWELLSAID</pre>

 

=={{header|Phix}}==

Originally translated from C, but ended up more of a direct implementation of the algorithm in the pdf.

{{out}}

<pre>

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|Python}}==

===Procedural===

# left wheel = ciphertext wheel

# right wheel = plaintext wheel

return lalph, ralph

 

<pre>L: HXUCZVAMDSLKPEFJRIGTWOBNYQ

R: PTLNBQDEOYSFAVZKGJRIHWXUMC

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import chain, cycle, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>WELLDONEISBETTERTHANWELLSAID

OAHQHCNYNXTSZJRRHJBYHQKSOUJY

WELLDONEISBETTERTHANWELLSAID</pre>

 

=={{header|Raku}}==

{{works with|Rakudo|2018.03}}

 

my @right;

 

say 'WELLDONEISBETTERTHANWELLSAID'.comb».&encode.join;

reset;

{{out}}

<pre>OAHQHCNYNXTSZJRRHJBYHQKSOUJY

WELLDONEISBETTERTHANWELLSAID</pre>

=={{header|Ruby}}==

@left = "HXUCZVAMDSLKPEFJRIGTWOBNYQ".chars

@right = "PTLNBQDEOYSFAVZKGJRIHWXUMC".chars

 

puts txt.each_char.map{|c| encrypt(c) }.join

{{out}}

<pre>OAHQHCNYNXTSZJRRHJBYHQKSOUJY

</pre>

=={{header|Rust}}==

const RIGHT_ALPHABET_PT: &str = "PTLNBQDEOYSFAVZKGJRIHWXUMC";

const ZENITH: usize = 0;

println!("Plaintext: {}", SEQUENCE);

println!("Ciphertext: {}", ciphertext);

{{out}}

<pre>Plaintext: WELLDONEISBETTERTHANWELLSAID

Ciphertext: OAHQHCNYNXTSZJRRHJBYHQKSOUJY</pre>

=={{header|Tailspin}}==

templates chaocipher&{left:,right:,decode:}

templates permute

'OAHQHCNYNXTSZJRRHJBYHQKSOUJY' -> chaocipher&{left:'HXUCZVAMDSLKPEFJRIGTWOBNYQ', right:'PTLNBQDEOYSFAVZKGJRIHWXUMC',decode:1} -> '$;

' -> !OUT::write

 

{{out}}

WELLDONEISBETTERTHANWELLSAID

</pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

ReadOnly L_ALPHABET As String = "HXUCZVAMDSLKPEFJRIGTWOBNYQ"

End Sub

 

{{out}}

<pre>The original plaintext is : WELLDONEISBETTERTHANWELLSAID

 

The recovered plaintext is : WELLDONEISBETTERTHANWELLSAID</pre>

 

=={{header|Wren}}==

{{trans|Kotlin}}

static encrypt { 0 }

static decrypt { 1 }

System.print("\nThe ciphertext is : %(cipherText)")

var plainText2 = Chao.exec(cipherText, Chao.decrypt, false)

 

{{out}}

<pre>

=={{header|zkl}}==

{{trans|Raku}}

var [const private] lAlphabet = "HXUCZVAMDSLKPEFJRIGTWOBNYQ",

rAlphabet = "PTLNBQDEOYSFAVZKGJRIHWXUMC";

right.insert(13,right.pop(2)); // rotate [2..13] once

}

println("The original plaintext is : ",plainText);

println("\nThe left and right alphabets after each permutation"

 

plainText2:=Chao.decode(cipherText);

{{out}}

<pre style="height:45ex">