# solitaire encryption in joy

## stevan apter — 2000-05-28 16:34:23

    i'm nibbling at the edges of coding up the solitaire encryption

    algorithm in joy.  as a guide, i'm using my k implementation, which

    makes heavy use of list operations in place of explicit iteration.

    one of the operations used by the solitaire algorithm is "triple

    cut".  here is how the operation is documented:

        Perform a triple cut. That is, swap the cards above the first joker with the

        cards below the second joker. If the deck used to look like:

            2 4 6 B 5 8 7 1 A 3 9

        then after the triple cut operation it will look like:

            3 9 B 5 8 7 1 A 2 4 6

        "First" and "second" jokers refer to whatever joker is nearest to, and furthest

        from, the top of the deck. Ignore the "A" and "B" designations for this step.

        Remember that the jokers and the cards between them don't move; the other cards

        move around them. This is easy to do in your hands. If there are no cards in one

        of the three sections (either the jokers are adjacent, or one is on top or the

        bottom), just treat that section as empty and move it anyway. If the deck used

        to look like:

            B 5 8 7 1 A 3 9

        then after the triple cut operation it will look like:

            3 9 B 5 8 7 1 A

        A deck that looks like:

            B 5 8 7 1 A

        will remain unchanged by this step.

    and here is my k implementation:

        t:{,/|(0,0 1+{x@<x}x?/:A,B)_ x}

    here is how it works:

        t is a lambda which takes one argument x, the deck.

        the deck is a vector of 54 cards (the standard deck + 2 jokers)

        A and B are the two jokers.

        suppose x is as above, where A = 10 and B = 11:

            x:2 4 6 11 5 8 7 1 10 3 9

        then t does the following:

            x?/:A,B        / find the indices of A and B in x

        8 3

        sort the result:

            {x@<x}8 3

        3 8

        add 0 and 1 to the result:

            0 1+3 8

        3 9

        prepend a 0:

            0,4 9

        0 3 9

        cut the deck into three lists at those positions:

            0 3 9 _ x

        (2 4 6

         11 5 8 7 1 10

         3 9)

        reverse this list:

            | 0 3 9 _ x

        (3 9

         11 5 8 7 1 10

         2 4 6)

        and flatten it:

            ,/|0 3 9 _ x

        3 9 11 5 8 7 1 10 2 4 6

        we are done.

    a joy implementation of triple cut therefore might look like this:

        deck

        deck A find

        deck B find

        upsort

        [0 1] +

        0 swoncat

        cut

        reverse

        flatten

    find, upsort, and cut are easy to implement in joy.  in my k implementation

    this is just:

        find:Two[{y?x}]

        cut:Two[{y _ x}]

        upsort:Two[{x@<x}]