Playfair cipher: Difference between revisions

{{trans|Python}}

 

[Char] seen

L(x) seq

V enc = playfair.encode(orig)

print(‘Encoded: ’enc)

 

{{out}}

Encoded: BM OD ZB XD NA BE KU DM UI XM MO UV IF

Decoded: HI DE TH EG OL DI NT HE TR EX ES TU MP

</pre>

 

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

#include <string>

 

cout << "Enter the text: "; getline( cin, txt );

playfair pf; pf.doIt( key, txt, ij, e ); return system( "pause" );

{{out}}<pre>

(E)ncode or (D)ecode? e

=={{header|D}}==

{{trans|Python}}

std.conv, std.string, std.regex, std.typecons;

 

writeln(" Encoded: ", enc);

writeln(" Decoded: ", pf.decode(enc));

{{out}}

<pre>Original: Hide the gold in...the TREESTUMP!!!

 

=={{header|FreeBASIC}}==

 

Enum PlayFairOption

Print

Print "Press any key to quit"

Sample input/output:

{{out}}

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

decodedText := pf.decode(encodedText)

fmt.Println("Deccoded text is :", decodedText)

 

{{out}}

{{incorrect|Haskell|TREESTUMP -> TREXSTUMPX, should be TREXESTUMP}}

(My guess is that map (\[x, y] -> if x == y then [x, 'x'] else [x, y]).chunksOf 2 is simply discarding the y. [[User:Petelomax|Pete Lomax]] ([[User talk:Petelomax|talk]]) 05:54, 13 October 2018 (UTC))

import Control.Monad (guard)

import Data.Array (Array, assocs, elems, listArray, (!))

| odd (length str) = str ++ "x"

| otherwise = str

 

<pre>

 

'''Implementation:'''

sel=. 'Q' e. y

alph=: (sel { 'JQ') -.~ a. {~ 65 + i.26

decrypt=: verb define

 

'''Example use:'''

 

setkey 'playfair example'

BM OD ZB XD NA BE KU DM UI XM MO UV IF

decrypt 'BM OD ZB XD NA BE KU DM UI XM MO UV IF'

 

=={{header|Java}}==

import java.util.Scanner;

 

return text.toString();

}

 

=== alternative version ===

 

public class PlayfairCipherEncryption

sc.close();

}

 

=={{header|Julia}}==

to = (to == "" && from == "J") ? "I" : to

 

 

println("Decoded: ", playfair("Playfair example", encoded, false))

<pre>

Original: Hide the gold in...the TREESTUMP!!!

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

enum class PlayfairOption {

val decodedText = playfair.decode(encodedText)

println("Decoded text is : $decodedText")

 

{{out}}

 

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

MakeTranslationTable[tt_List] := Module[{poss, in, out},

poss = Tuples[Tuples[Range[5], 2], 2];

]

PlayfairCipher["Hide the gold in...the TREESTUMP!!!", "Playfair example"]

{{out}}

<pre>BM OD ZB XD NA BE KU DM UI XM MO UV IF

=={{header|Nim}}==

{{trans|Java}}

 

type

 

echo "Encoded message: ", enc

 

{{out}}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

{{out}}

<pre>

 

=={{header|ooRexx}}==

* REXX program implements a PLAYFAIR cipher (encryption & decryption).

* 11.11.2013 Walter Pachl revamped, for ooRexx, the REXX program

d=d||substr(x,j,2)' '

End

Output (sample):

<pre>old cipher key: this is my little key

=={{header|Perl}}==

{{trans|Raku}}

 

# Pregenerate all forward and reverse translations

print " orig:\t$orig\n";

print "black:\t$black\n";

{{out}}

<pre> orig: Hide the gold in...the TREESTUMP!!!

=={{header|Phix}}==

Originally translated from Kotlin, now uses a combined routine (playfair) for encoding and decoding, and direct char lookups, and x removal.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">keyword</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Playfair example"</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;">"Encoded text is : %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">encoded</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;">"Decoded text is : %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">decoded</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|Python}}==

{{trans|Raku}}

from itertools import product

from re import findall

enc = encode(orig)

print "Encoded:", enc

{{out}}

<pre>Original: Hide the gold in...the TREESTUMP!!!

=={{header|Raku}}==

(formerly Perl 6)

 

sub playfair( $key,

 

my $red = decode $black;

{{out}}

<pre> orig: Hide the gold in...the TREESTUMP!!!

A fair amount of code was added to massage the decrypted encryption to remove doubled &nbsp; '''X'''es &nbsp; so as to match the original text

<br>(this is the &nbsp; &nbsp; ''possible text'' &nbsp; &nbsp; part of the REXX code).

@abc= 'abcdefghijklmnopqrstuvwxyz'; @abcU= @abc /*literals for lower and upper ABC's.*/

parse arg omit key '(' text /*TEXT is the phrase to be used. */

if datatype(_, 'M') then $= $ || _ /*only use Latin letters. */

end /*j*/

Some older REXXes don't have a '''changestr''' bif, so one is included here ──► [[CHANGESTR.REX]].

<br><br>

Printing the cipher in pairs just advertises the mechanism of encoding; I've gone with the traditional grouping into sequences of five letters instead.

 

Size = 5

def initialize(key, missing)

end.join.split('').each_slice(5).map{|s|s.join}.join(' ')

end

 

{{Out}}

=={{header|Sidef}}==

{{trans|Raku}}

 

func canon(str) {

 

var red = decode(black)

{{out}}

<pre>

 

=={{header|SQL}}==

--Clean up previous run

IF EXISTS (SELECT *

WHERE NAME = 'FairPlayTable')

DROP TYPE FAIRPLAYTABLE

 

=={{header|Tcl}}==

 

{{works with|Tcl|8.6}}

 

oo::class create Playfair {

return $result

}

Demonstrating:

set plaintext "Hide the gold in...the TREESTUMP!!!"

set encoded [cypher encode $plaintext]

puts "Original: $plaintext"

puts "Encoded: $encoded"

{{out}}

<pre>

 

=={{header|VBA}}==

Option Explicit

 

SwapPairsDecoding = myTable(resD1.Row, resD1.Column) & myTable(resD2.Row, resD2.Column)

End Select

{{out}}

<pre>Enter your keyword : Playfair example

Decoded text is : HI DE TH EG OL DI NT HE TR EE ST UM PX</pre>

 

{{trans|Go}}

import strings

type PlayfairOption = int

decoded_text := pf.decode(encoded_text)

println("Deccoded text is : $decoded_text")

 

{{out}}

{{libheader|Wren-dynamic}}

{{libheader|Wren-str}}

{{libheader|Wren-ioutil}}

 

var PlayfairOption = Enum.create("PlayfairOption", ["NO_Q", "I_EQUALS_J"])

System.print("\nEncoded text is : %(encodedText)")

var decodedText = playfair.decode(encodedText)

 

{{out}}

 

=={{header|zkl}}==

deadChr=deadChr.toUpper();

key=key.toUpper().unique() - " " - deadChr;

return(key + (["A".."Z"].pump(String) - deadChr - key), deadChr);

keyTable,deadChr:=keytable;

text=text.toUpper();

})

.pump(String,Void.Read,"".create.fp(" ")).strip(); // insert blanks

keyTable,_=keyTable;

text-=" ";

.pump(String,Void.Read,"".create.fp(" ")).strip(); // insert blanks

}

keyTable:=genKeyTable("playfair example");

msg.println();

e:=playfair(msg,keyTable); e.println();

decodePF(e,keyTable).println();

{{out}}

<pre>