Card shuffles: Difference between revisions

If we generate a deck by

deck ← ⊂[1](52⍴'A23456789TJQK'),[0.5](13⍴'S'),(13⍴'H'),(13⍴'D'),(13⍴'C')

Then a generated deck looks like

AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC

Sorting a deck merely requires generating 52 unique random nunmbers from 1 to 52.

deck[52?52]

JD 8C TH 8D KH QH 6S AH 4D JS 5S AD 6H 3H 3D 5C 9C 7C 7S 4C JC 3S KD 9H 3C 4H 2D TD KS TS 7D JH 9D 8H 6D 7H 2H 4S QC AC KC 9S AS QS TC 2C 8S 5D 2S 6C 5H QD

=={{header|C}}==

{{trans|Modula-2}}

#include <stdlib.h>

#include <string.h>

return 0;

{{out}}

<pre>Riffle shuffle

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

{{trans|Java}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

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

#include <time.h>

#include <algorithm>

return 0;

}

{{out}}

<pre>

=={{header|D}}==

{{trans|Java}}

import std.random;

import std.range;

list.randomShuffle();

writeln(list);

{{out}}

<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

=={{header|Go}}==

{{trans|Kotlin}}

import (

})

fmt.Println(deck)

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private static final Random rand = new Random()

println(list)

}

{{out}}

<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

{{eff note|J|({~ ?~@#)}}

overhand=: (\: [: +/\ %@%:@# > # ?@# 0:)@]^:[

NB. Gilbert–Shannon–Reeds model

The probability of a cut occurring between each pair of cards in this overhand shuffle is proportional to the reciprocal of the square root of the number of cards in the deck.

Here are some examples of the underlying selection mechanism in action for a deck of 10 cards:

0 0 0 0 0 0 0 0 1 1

([: +/\ %@%:@# > # ?@# 0:) i.10

0 1 1 2 3 3 3 3 4 5

([: +/\ %@%:@# > # ?@# 0:) i.10

The final step of a cut is to sort the deck in descending order based on the numbers we compute this way.

Task examples:

0 1 2 3 4 5 6 7 8 13 14 9 15 16 17 10 18 11 12 19

10 riffle i.20

17 18 19 13 14 15 16 4 5 6 7 8 9 10 11 12 0 1 2 3

10 overhand i.20

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.Collections;

import java.util.LinkedList;

System.out.println(list + "\n");

}

{{out}}

<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

{{works with|Julia|0.6}}

len = length(list)

# pre-allocate the left and right part for efficiency

v = collect(1:20)

println("# Default shuffle:\n", v)

{{out}}

=={{header|Kotlin}}==

import java.util.Random

shuffle(deck) // shuffles deck in place

println(deck)

Sample output:

=={{header|Lua}}==

function newDeck ()

local cards, suits = {}, {"C", "D", "H", "S"}

deck2 = overhand(deck2)

print("Sorted deck after one overhand shuffle:")

{{out}}

<pre>Sorted deck after one riffle shuffle:

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM RandomNumbers IMPORT Random;

ReadChar;

=={{header|Nim}}==

{{trans|Kotlin}}

proc riffle(deck: seq[int]; iterations: Positive): seq[int] =

echo "\nStandard library shuffle with one iteration:"

deck.shuffle() # Shuffles deck in place.

{{out}}

=={{header|PARI/GP}}==

Riffle shuffle:

{

my(n=#v,k,t,deck=vector(n),left,right);

vecextract(v, deck);

}

Overhand shuffle:

{

my(u=[],t,n=2*#v\5);

u;

}

Usage:

{{out}}

<pre>%1 = [1, 2, 3, 21, 4, 22, 23, 5, 24, 25, 26, 6, 27, 28, 29, 30, 7, 31, 32, 33, 34, 35, 36, 8, 37, 38, 39, 40, 9, 10, 11, 12, 41, 42, 43, 13, 44, 45, 14, 46, 47, 48, 15, 16, 17, 49, 50, 18, 51, 19, 20, 52]

=={{header|Perl}}==

Follows the Raku implementation for the overhand shuffle, but uses classic one-liner for riffle.

our @cards; local *cards = shift;

my(@splits,@shuffle);

@cards = 1..20;

riffle(\@cards) for 1..10;

{{out}}

<pre>9 11 5 2 4 14 1 3 8 6 15 13 16 12 19 20 7 18 10 17

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">riffle</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>

<span style="color: #000000;">show_deck</span><span style="color: #0000FF;">(</span><span style="color: #000000;">overhand</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">DECKSIZE</span><span style="color: #0000FF;">)))</span>

<span style="color: #000000;">show_deck</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">DECKSIZE</span><span style="color: #0000FF;">)))</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(de riffle (Lst)

(println 'riffle (riffle (range 1 19)) )

(println 'overhand (overhand (range 1 19)) )

{{out}}

<pre>

=={{header|Python}}==

{{trans|D}}

def riffleShuffle(va, flips):

random.shuffle(nums)

print nums

{{out}}

<pre>Riffle shuffle

Racket has a built in <code>shuffle</code> function. Frankly, I'd go with that in your own code!

;; ---------------------------------------------------------------------------------------------------

;; Types and shuffle builder

(printf "wash piles: ~.a~%" (wash-pile-shuffle unshuffled-pack 1))

;; Or there is always the built-in shuffle:

{{out}}

(formerly Perl 6)

use v6;

say (^20).pick(*);

=={{header|REXX}}==

Six-handed 500 has additional cards of: &nbsp; <big> ♣11 &nbsp; ♣12 &nbsp; &nbsp; &nbsp; &nbsp; ♠11 &nbsp; ♠12 &nbsp; &nbsp; &nbsp; ♦11 &nbsp; ♦12 &nbsp; ♦13 &nbsp; &nbsp; &nbsp; ♦11 &nbsp; ♦12 &nbsp; ♦13 </big>

call create; call show 'new deck' /*build and display a new card deck. */

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

show: _=@.1; do j=2 for #-1; _=_ @.j; end /*j*/; L = length(_)

{{out|output}}

<pre style="font-size:125%">

Two methods to solve the requirements, and a third one as bonus.

def riffle deck

left, right = deck.partition{rand(10).odd?}

p overhand(deck)

p bonus(deck)

=={{header|Scala}}==

{{trans|Java}}

import scala.util.Random

println()

}

{{out}}

<pre>List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

=={{header|Tcl}}==

proc riffle deck {

set length [llength $deck]

puts [riffle [list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52]]

puts [overhand [list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52]]

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Text

End Sub

{{out}}

<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

=={{header|Wren}}==

{{trans|Kotlin}}

var r = Random.new()

System.print("\nStandard library shuffle with 1 iteration:")

r.shuffle(deck) // shuffles deck in place

{{out}}

=={{header|zkl}}==

A much better shuffle is List's shuffle method.

len,N:=deck.len(),len/2;

newDeck:=N.pump(List,'wrap(n){ return(Void.Write,deck[n],deck[N+n]) });

len,N,piles:=deck.len(),(0.2*len).toInt(),(len.toFloat()/N).ceil().toInt();

piles.pump(List,'wrap(n){ deck[n*N,N] }).reverse().flatten()

overHand([1..19].walk()).println();

{{out}}

<pre>