Straddling checkerboard: Difference between revisions

{{trans|Python}}

[String(‘’), ‘H’, ‘O’, ‘L’, ‘’, ‘M’, ‘E’, ‘S’, ‘’, ‘R’, ‘T’],

[String(‘3’), ‘A’, ‘B’, ‘C’, ‘D’, ‘F’, ‘G’, ‘I’, ‘J’, ‘K’, ‘N’],

V O = ‘One night-it was on the twentieth of March, 1888-I was returning’

print(‘Encoded: ’straddle(O))

{{out}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

PRIO MIN=5, MAX=5;

))

Output:

<pre>

=={{header|AutoHotkey}}==

(

ET AON RIS

}

}

=={{header|C}}==

{{libheader|GLib}}

#include <stdlib.h>

#include <string.h>

return 0;

===Shorter version===

#include <stdlib.h>

decipher(enc, dec, 1); printf("decoded: %s\n", dec);

return 0;

encoded: 85621250626585107626916996966956265062650706225635247676226639162203702867623288640

decoded: IN THE WINTER 1965 WE WERE HUNGRY JUST BARELY ALIVE

No spaces:

encoded: 851250658510769169969669562650650702563524767622663912037028673288640

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

Translation of [[Straddling_checkerboard#Java|Java]] via [[Straddling_checkerboard#D|D]]

using System.Collections.Generic;

using System.Linq;

}

}

<pre>139539363509369743061399059745399365901344308320791798798798367430685972839363935

ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING</pre>

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

#include <string>

#include <map>

return out;

}

Test program:

{

StraddlingCheckerboard sc("HOLMESRTABCDFGIJKNPQUVWXYZ./", 3, 7);

return 0;

Output:

=={{header|D}}==

Partially based on the PicoLisp version:

immutable T = ["79|0|1|2|3|4|5|6|7|8|9", "|H|O|L||M|E|S||R|T",

writeln("Encoded: ", O.straddle);

writeln("Decoded: ", O.straddle.unStraddle);

{{out}}

<pre>Encoded: 139539363509369743061399059745399365901344308320791798798798367430685972839363935

{{trans|C++}}

Same output:

struct StraddlingCheckerboard {

writeln("Encoded: ", en);

writeln("Decoded: ", sc.decode(en));

===Dictionary-Based Version===

{{trans|Java}}

immutable string[const string] val2key, key2val;

s.encode.writeln;

s.encode.decode.writeln;

{{out}}

<pre>139539363509369743061399059745399365901344308320791798798798367430685972839363935

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

(*

Encode and Decode using StraddlingCheckerboard

Seq.iter2 (fun ng gn->a.[(char i,char ng)]<-string gn;b.[gn]<-i+ng) z l

{n=char n;i=char i;g=a;e=b}

{{out}}

{{out}}

let N = G "2" "6" "ETAONRIS" "BCDFGHJKLM" "PQ/UVWXYZ." ["0";"1";"2";"3";"4";"5";"6";"7";"8";"9"]

N.decode "450582425181653945125016505180125423293721256216286286288653970163758524"|>Seq.iter(fun n->printf "%s" n);; //ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING

N.encode "IN THE WINTER 1965 WE WERE HUNGRY JUST BARELY ALIVE"|>Seq.iter(fun n->printfn "%s" n);; //8562 125062 658510762 62162962662562 65062 6507062 256352476762 26639162 20370286762 3288640

N.decode "8562 125062 658510762 62162962662562 65062 6507062 256352476762 26639162 20370286762 3288640"|>Seq.iter(fun n->printf "%s" n);; //IN THE WINTER 1965 WE WERE HUNGRY JUST BARELY ALIVE

=={{header|Go}}==

import (

}

return

{{out}}

<pre>

=={{header|Haskell}}==

import Data.Map

in mapM_ putStrLn [ "Original: " ++ orig

, "Encoded: " ++ enc

{{out}}

=={{header|Icon}} and {{header|Unicon}}==

StraddlingCheckerBoard("setup","HOLMESRTABCDFGIJKNPQUVWXYZ./", 3,7)

}

}

Output:<pre>text = "One night. it was on the twentieth of March, 1888. I was returning"

=={{header|J}}==

'''Solution:'''

'Nums Alpha'=: '0123456789';'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

Charset=: Nums,Alpha,Stop

}.board {~ _2 (_&".)\ idx

end.

'''Example usage:'''

chkbrdRC=: chkbrd (3 7;'HOLMESRTABCDFGIJKNPQUVWXYZ./') NB. define adverb by applying Rosetta Code key to chkbrd conjunction

0 chkbrdRC preprocess 'One night-it was on the twentieth of March, 1888-I was returning'

139539363509369743061399059745399365901344308320791798798798367430685972839363935

1 chkbrdRC 0 chkbrdRC preprocess 'One night-it was on the twentieth of March, 1888-I was returning'

Or using the rules proposed by [[User:Util|Util]] on the discussion page:

1 chkbrdRC 0 chkbrdRC preprocess 'One night-it was on the twentieth of March, 1888-I was returning'

'''Solution:'''

NB. creates verbs encode and decode which change between unencoded text and lists of encoded numbers

setcode=: 3 :0

decode=: (alphabet {~ keys i. break f.) :. encode

i.0 0

'''Example usage:'''

preprocess=: (#~ alphabet e.~ ])@toupper

,":"0 encode message=: preprocess 'One night-it was on the twentieth of March, 1888-I was returning'

OWVKRNEOAMTMXROWOHTMTMTROTQ4SEMRRLRZLVSTTLLOROMHALSFOHECMRWESWEE

((10|-) 0 4 5 2$~$)&.encode s

=={{header|Java}}==

{{works with|Java|7}}

import java.util.Map;

import java.util.regex.*;

return sb.toString();

}

<pre>139539363509369743061399059745399365901344308320791798798798367430685972839363935

=={{header|JavaScript}}==

var alphabet=new Array("ESTONIA R","BCDFGHJKLM","PQUVWXYZ./") // scramble alphabet as you wish

var prefixes=new Array("",alphabet[0].indexOf(" "),alphabet[0].lastIndexOf(" "))

document.writeln(straddle(str))

document.writeln(unstraddle(straddle(str)))

Output:<pre>One night-it was on the twentieth of March, 1888-I was returning.

Unlike the precomputed table versions, this version takes a 30-character string specifying the 3 rows of the checkerboard

as an argument, recomputing the lookup table each run, which allows easier changes of keys without modifying the code.

function straddlingcheckerboard(board, msg, doencode)

lookup = Dict()

decoded = straddlingcheckerboard(btable, encoded, false)

println("Original: $message\nEncoded: $encoded\nDecoded: $decoded")

{{output}}

<pre>

=={{header|Kotlin}}==

val board = "ET AON RISBCDFGHJKLMPQ/UVWXYZ."

println("Decrypted : $decrypted")

}

{{out}}

=={{header|Lua}}==

local brd = { "HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./" }

local dicE, dicD, s1, s2 = {}, {}, 0, 0

-- entry point

enterText()

{{out}}

<pre>

=={{header|M2000 Interpreter}}==

module Straddling_checkerboard {

function encrypt$(message$, alphabet) {

}

Straddling_checkerboard

{{out}}

=={{header|Nim}}==

I used the same example as in the Go solution (and, fortunately, got the same result).

const

let crypted = board.encrypt(message)

echo "Crypted: ", crypted

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

say 'Original: ', my $original = 'One night-it was on the twentieth of March, 1888-I was returning';

say 'Encoded: ', my $en = encode($original);

{{out}}

<pre> 0 1 2 3 4 5 6 7 8 9

=={{header|Phix}}==

{{trans|C}}

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

<span style="color: #008080;">function</span> <span style="color: #000000;">read_table</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">cb</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: %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">enc</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: %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">dec</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

{{trans|Java}}

{{works with|PHP 7}}

"H"=>"0", "I"=>"36", "J"=>"37", "K"=>"38", "L"=>"2", "M"=>"4", "."=>"78", "N"=>"39",

"/"=>"79", "O"=>"1", "0"=>"790", "P"=>"70", "1"=>"791", "Q"=>"71", "2"=>"792",

}

<pre>

139539363509369743061399059745399365901344308320791798798798367430685972839363935

=={{header|PicoLisp}}==

(NIL "H" "O" "L" NIL "M" "E" "S" NIL "R" "T")

("3" "A" "B" "C" "D" "F" "G" "I" "J" "K" "N")

(get (cdr @) (inc (format (pop 'L))))

(get (cdar *Straddling) (inc (format C))) ) )

Output:

<pre>: (straddle "One night-it was on the twentieth of March, 1888-I was returning")

=={{header|PureBasic}}==

Static notEscape.s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ."

Protected preDigit_1.s = Str(blank_1), preDigit_2.s = Str(blank_2)

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>Original: One night-it was on the twentieth of March, 1888-I was returning

=={{header|Python}}==

Partially based on the PicoLisp version:

["", "H", "O", "L", "", "M", "E", "S", "", "R", "T"],

["3", "A", "B", "C", "D", "F", "G", "I", "J", "K", "N"],

O = "One night-it was on the twentieth of March, 1888-I was returning"

print "Encoded:", straddle(O)

Output:

<pre>Encoded: 139539363509369743061399059745399365901344308320791798798798367430685972839363935

We store the straddling checkerboard in a structure, so it can be reused or changed for the different examples. The “constructor” transforms the lines of the checkboard into an internal representation.

(struct *straddling (header main original)

(*straddling (list->vector (list* "?" "" header-tail)) main lines))

(define escape (straddling-encode-char #\/ temporal-board))

Now we define the functions to straddle and unstraddle the message.

(or (for/or ([head (in-vector (*straddling-header board))]

[line (in-vector (*straddling-main board))])

(values #f (cons decoded rev-ret))))))])

(unless row ;check that last number was not missing

'''Two examples:'''

(let* ([encoded (straddle message board)]

[decoded (unstraddle encoded board)])

(straddling "ET AON RIS"

"BCDFGHJKLM"

{{out}}

<pre>#<straddling ("HOL MES RT" "ABCDFGIJKN" "PQUVWXYZ./")>

We build the full table during .new, which simplifies .encode and .decode.

has @!flat_board; # 10x3 stored as 30x1

has $!plain2code; # full translation table, invertable

say "Decoded: $de";

}

Output:<pre> 0 1 2 3 4 5 6 7 8 9

:* &nbsp; no hard-coding of the location of the escape character,

:* &nbsp; support the usage of a blank in the 1^st character (the top line of the table).

parse arg msg /*obtain optional message from the C.L.*/

if msg='' then msg= 'One night-it was the twentieth of March, 1888-I was returning'

if pos(x, @.r)\==0 then do; j= j+1; rw=x; x=substr(!, j, 1); end

$= $ || substr(@.rw, x+1, 1) /*add a character to decrypted message.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ruby}}==

{{works with|Ruby|2.0}}

EncodableChars = "A-Z0-9."

SortedChars = " ./" + [*"A".."Z"].join

"#<%s board=%p, row_labels=%p, mapping=%p>" % [self.class, to_s, @row_labels, @mapping]

end

The test suite

class StraddlingCheckerboardTest < Test::Unit::TestCase

def setup

assert_raise(ArgumentError) {StraddlingCheckerboard.new "ET ON RISBCDFGHJKLMPQ/UVWXYZ.!"}

end

output

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/xCHsvaC/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/42qQPkm6TiONpAOC1ByTCg Scastie (remote JVM)].

private val dictonary = Map("H" -> "0", "O" -> "1",

println(enc)

println(decode(enc))

=={{header|Tcl}}==

Structured as a class, the instances of which contain encoding and decoding mappings suitable for use with Tcl's built in string remapping engine. This uses the fact that no sequence of digits in the encoded form that maps to one character is a prefix of the sequence for any other character. (Inspired by the ''description'' of the [[#Raku|Raku]] solution.)<!--not a translation though; I didn't read the Raku code…-->

oo::class create StraddlingCheckerboardCypher {

string map $decmap [regsub -all {[^0-9]} $msg ""]

}

Demonstration code:

{{} E T {} A O N {} R I S}

{2 B C D F G H J K L M}

puts "Input: $input"

puts "Encoded: $encrypted"

Output:

<pre>

=={{header|VBScript}}==

{{trans|PureBasic}}

Function encrypt(ByVal originalText, ByVal alphabet, blank1, blank2)

decoded = decrypt(encoded, cipher, 3, 7)

Buffer=Buffer & "decoded: " & decoded & vbCrlf

{{out}}

<pre>

{{trans|Kotlin}}

{{libheader|Wren-str}}

var board = "ET AON RISBCDFGHJKLMPQ/UVWXYZ."

System.print("Encrypted : %(encrypted)")

System.print("Decrypted : %(decrypted)")

{{out}}

=={{header|zkl}}==

{{trans|D}}

val2key=Dictionary(

"A","30", "B","31", "C","32", "D","33", "E","5", "F","34", "G","35",

fcn encode(txt){ txt.toUpper().pump(String,val2key.find.fp1("")) }

str:=encode(txt);

println("Encoded: ", str);

{{out}}

<pre>