Playfair cipher: Difference between revisions

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

<br><br>

 

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

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

</pre>

 

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

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

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>

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

</pre>

 

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

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

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