Comments on: Rail-Fence Cipher

By: Jan Van lent

Jan Van lent — Mon, 06 Jul 2009 23:08:49 +0000

Common Lisp solution at http://paste.lisp.org/display/83135.

By: Programming Praxis – Double Transposition Cipher « Bonsai Code

Programming Praxis – Double Transposition Cipher « Bonsai Code — Sat, 30 May 2009 15:49:22 +0000

[...] up we have zipSort, which I also used in the Rail-Fence Cipher [...]

By: programmingpraxis

programmingpraxis — Fri, 22 May 2009 04:50:11 +0000

Posted on behalf of Matthias Felleisen: "I have finally found some time to write up my version of the story which only starts with the post here as a way to explain the idea in a first-semester FP course -- with design principles. In contrast to the Haskell solution, mine is linear. If a linear purely FP solution exists, I'd like to know."

By: Luis Sergio Oliveira

Luis Sergio Oliveira — Sun, 17 May 2009 17:03:31 +0000

Hi,

my solution in Common Lisp, including some tests is here: http://lisp.pastebin.com/f27e23d44.

Notice that I haven’t followed the algorithm proposed in your solution which is indeed very interesting…

Thanks for the problem,

Luis

By: FalconNL

FalconNL — Thu, 02 Apr 2009 09:40:24 +0000

Updated version that I believe should run in O(n log n) for both rail and derail (rail was O(n^2) in the previous version): [sourcecode lang='css'] import Data.List import GHC.Exts main = do print $ rail 4 "PROGRAMMING PRAXIS" print . derail 4 $ rail 4 "PROGRAMMING PRAXIS" rail :: Int -> [a] -> [a] rail n = zipSort (cycle $ [1..n] ++ [n-1,n-2..2]) derail :: Ord a => Int -> [a] -> [a] derail n s = zipSort (rail n $ zipWith const [0..] s) s zipSort :: Ord a => [a] -> [b] -> [b] zipSort ks = map snd . sortWith fst . zip ks [/sourcecode]

By: matthias

matthias — Wed, 01 Apr 2009 15:37:18 +0000

Oops, fence is a two-liner in PLT Scheme, too:

(define (fence s n)
(define is (shared ((x (append (range 1 n) (range (- n 1) 2) x))) x))
(map first (sort2 (for/list ((c s) (i (in-list is))) (list c i)))))

By: matthias

matthias — Wed, 01 Apr 2009 14:31:10 +0000

FalconNL, your design turns the solution into
“Fortran”, using indexes into lists (of chars)
where a generative-recursion design (for freshmen)
exposes the waves as they come about.

Then again, you demonstrate how temporary
laziness in ‘waves’ is a useful tool. Let me show
you how temporary, invisible assignments accomplish the exact same purpose.

;; [Listof X] Nat -> [Listof X]
;; 1 5 9
;; 1 2 3 4 5 6 7 8 9 10 11 ==> 2 4 6 8 10 ==> 1 5 9 2 4 6 8 10 3 7 11
;; 3 7 11

(check-expect (fence ‘(1 2 3 4 5 6) 3) ‘(1 5 2 4 6 3))
(check-expect (fence ‘(1 2 3 4 5 6 7 8 9 10 11) 3) ‘(1 5 9 2 4 6 8 10 3 7 11))

(define (fence s n)
(define is (shared ((x (append (range 1 n) (range (- n 1) 2) x))) x))
(define wv (for/list ((c s)) (begin0 (list c (car is)) (set! is (cdr is)))))
(map first (sort2 wv)))

By: FalconNL

FalconNL — Tue, 31 Mar 2009 15:06:37 +0000

In Haskell: [sourcecode lang='css'] import Data.List main = do print $ rail 4 "PROGRAMMING PRAXIS" print . derail 4 $ rail 4 "PROGRAMMING PRAXIS" rail :: Int -> String -> String rail n s = map (s !!) $ waves n s derail :: Int -> String -> String derail n s = map snd . sort $ zip (waves n s) s waves :: Int -> String -> [Int] waves n = map snd . sort . zip (cycle $ [1..n] ++ [n-1,n-2..2]) . zipWith const [0..] [/sourcecode]