Playfair cipher: Difference between revisions

Implement a [[wp: Playfair cipher| Playfair cipher]] for encryption and decryption.

 

 

The output of the encrypted and decrypted message must be in capitalized digraphs, separated by spaces.

 

 

=={{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>

 

=={{header|J}}==

Rather than implement two versions of the rules, one for encrypt, one for decrypt, let's just make a lookup table (mapping character pairs to character pairs). To decrypt we can look up in the other direction.

 

''

)

restrict=: ] -. -.~

 

key=. ~.norm y,alph

inds0=. (0 3,:2 1)&{@,"2 inds

)

)

)

 

 

setkey 'playfair example'

encrypt 'Hide the gold in the tree stump'

 

=={{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}}

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

</pre>

 

=={{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.

{{out}}

<pre>

Decoded text is : HI DE TH EG OL DI NT HE TR E_ ES TU MP

</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,

 

return

my @list = canon($red).comb(/(.) (.?) <?{ $1 ne $0 }>/);

~@list.map: { .chars == 1 ?? %ENC{$_~'X'} !! %ENC{$_} }

},

my @list = canon($black).comb(/../);

~@list.map: { %DEC{$_} }

 

my $red = decode $black;

{{out}}

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

=={{header|REXX}}==

Quite a bit of the REXX code deals with error checking, accepting arguments, and displaying the options used, and displaying input and output.

<br>Also, more thanks are due to Walter Pachl for finding that the cipher key can't contain the OMIT character.

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

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

if omit=='' | omit==',' then omit= 'J' /*the "omitted" character string. */

if text='' then text= 'Hide the gold in the tree stump!!' /*default.*/

newKey = scrub(key, 1) /*scrub old cipher key ──► newKey */

newText= scrub(text ) /* " " text ──► newText */

if length(omit)\==1 then call err 'OMIT letter must be only one letter.'

if \datatype(omit, 'M') then call err 'OMIT letter must be a Latin alphabet letter.'

if pos(omit, newText)\==0 then call err 'TEXT' @cant

if pos(omit, newKey) \==0 then call err 'cipher key' @cant

xx= 'X' /*character used for double characters.*/

if omit==xx then xx= 'Q' /* " " " " " */

fill= space( translate(fill, , newKey), 0) /*remove any cipher characters. */

grid= newKey || fill /*only first 25 characters are used. */

padL= 14 + 2

call show 'cleansed', newText

do row =1 for 5 /*build array of individual cells. */

do col=1 for 5; #= # + 1; @.row.col= substr(grid, #, 1)

show: arg ,y; say; say right(arg(1) 'text: ',padL) digram(y); say pad space(y, 0); return

/*──────────────────────────────────────────────────────────────────────────────────────*/

do k=1 while i==1; _= substr(T, k, 1); if _==' ' then leave

if _==substr(T, k+1, 1) then T= left(T, k) || Lxx || substr(T, k + 1)

upper T

return $

/*──────────────────────────────────────────────────────────────────────────────────────*/

return strip($)

/*──────────────────────────────────────────────────────────────────────────────────────*/

$=; do j=1 for length(xxx); _= substr(xxx, j, 1)

if unique==1 then if pos(_, $)\==0 then iterate /*is unique?*/

end /*j*/

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

<br><br>

════════════════Playfair encryption──► decryption──► encryption worked.

</pre>

 

=={{header|Sidef}}==

 

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 {

variable grid lookup excluder

constructor {{keyword "PLAYFAIR EXAMPLE"} {exclude "J"}} {

 

}

# Worker to apply a consistent cleanup/split rule

method Clean {str} {

}

# These public methods are implemented by a single non-public method

forward encode my Transform 1

forward decode my Transform -1

# The application of the Playfair cypher transform

method Transform {direction message} {

 

}

Demonstrating:

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

set encoded [cypher encode $plaintext]

puts "Original: $plaintext"

puts "Encoded: $encoded"

{{out}}

<pre>

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

</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

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

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

 

=={{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>