Mind boggling card trick: Difference between revisions
Added Easylang
(Added Easylang) |
|||
| (45 intermediate revisions by 26 users not shown) | |||
Line 1:
[[Category:Puzzles]]
{{
Matt Parker of the "Stand Up Maths channel" has a [https://www.youtube.com/watch?v=aNpGxZ_1KXU <u>YouTube video</u>] of a card trick that creates a semblance of order from chaos.
Line 32:
Show output on this page.
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">//import random
V n = 52
V Black = ‘Black’
V Red = ‘Red’
V blacks = [Black] * (n I/ 2)
V reds = [Red] * (n I/ 2)
V pack = blacks [+] reds
random:shuffle(&pack)
[String] black_stack, red_stack, discard
L !pack.empty
V top = pack.pop()
I top == Black
black_stack.append(pack.pop())
E
red_stack.append(pack.pop())
discard.append(top)
print(‘(Discards: ’(discard.map(d -> d[0]).join(‘ ’))" )\n")
V max_swaps = min(black_stack.len, red_stack.len)
V swap_count = random:(0 .. max_swaps)
print(‘Swapping ’swap_count)
F random_partition(stack, count)
V stack_copy = copy(stack)
random:shuffle(&stack_copy)
R (stack_copy[count ..], stack_copy[0 .< count])
(black_stack, V black_swap) = random_partition(black_stack, swap_count)
(red_stack, V red_swap) = random_partition(red_stack, swap_count)
black_stack [+]= red_swap
red_stack [+]= black_swap
I black_stack.count(Black) == red_stack.count(Red)
print(‘Yeha! The mathematicians assertion is correct.’)
E
print(‘Whoops - The mathematicians (or my card manipulations) are flakey’)</syntaxhighlight>
{{out}}
<pre>
(Discards: B R B B R B R R R B R R R R B R B B R R B B R B B R )
Swapping 10
Yeha! The mathematicians assertion is correct.
</pre>
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">use AppleScript version "2.5" -- OS X 10.11 (El Capitan) or later
use framework "Foundation"
use framework "GameplayKit" -- For randomising functions.
on cardTrick()
(* Create a pack of "cards" and shuffle it. *)
set suits to {"♥️", "♣️", "♦️", "♠️"}
set cards to {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"}
set deck to {}
repeat with s from 1 to (count suits)
set suit to item s of suits
repeat with c from 1 to (count cards)
set end of deck to item c of cards & suit
end repeat
end repeat
set deck to (current application's class "GKRandomSource"'s new()'s arrayByShufflingObjectsInArray:(deck)) as list
(* Perform the black pile/red pile/discard stuff. *)
set {blackPile, redPile, discardPile} to {{}, {}, {}}
repeat with c from 1 to (count deck) by 2
set topCard to item c of deck
if (character -1 of topCard is in "♣️♠️") then
set end of blackPile to item (c + 1) of deck
else
set end of redPile to item (c + 1) of deck
end if
set end of discardPile to topCard
end repeat
-- When equal numbers of two possibilities are randomly paired, the number of pairs whose members are
-- both one of the possibilities is the same as the number whose members are both the other. The cards
-- in the red and black piles have effectively been paired with cards of the eponymous colours, so
-- the number of reds in the red pile is already the same as the number of blacks in the black.
(* Take a random number of random cards from one pile and swap them with an equal number from the other,
religiously following the "red bunch"/"black bunch" ritual instead of simply swapping pairs of cards. *)
-- Where swapped cards are the same colour, this will make no difference at all. Where the colours
-- are different, both piles will either gain or lose a card of their relevant colour, maintaining
-- the defining balance either way.
set {redBunch, blackBunch} to {{}, {}}
set {redPileCount, blackPileCount} to {(count redPile), (count blackPile)}
set maxX to blackPileCount
if (redPileCount < maxX) then set maxX to redPileCount
set X to (current application's class "GKRandomDistribution"'s distributionForDieWithSideCount:(maxX))'s nextInt()
set RNG to current application's class "GKShuffledDistribution"'s distributionForDieWithSideCount:(redPileCount)
repeat X times
set r to RNG's nextInt()
set end of redBunch to item r of redPile
set item r of redPile to missing value
end repeat
set RNG to current application's class "GKShuffledDistribution"'s distributionForDieWithSideCount:(blackPileCount)
repeat X times
set b to RNG's nextInt()
set end of blackBunch to item b of blackPile
set item b of blackPile to missing value
end repeat
set blackPile to (blackPile's text) & redBunch
set redPile to (redPile's text) & blackBunch
(* Count and compare the number of blacks in the black pile and the number of reds in the red. *)
set blacksInBlackPile to 0
repeat with card in blackPile
if (character -1 of card is in "♣️♠️") then set blacksInBlackPile to blacksInBlackPile + 1
end repeat
set redsInRedPile to 0
repeat with card in redPile
if (character -1 of card is in "♥️♦️") then set redsInRedPile to redsInRedPile + 1
end repeat
return {truth:(blacksInBlackPile = redsInRedPile), reds:redPile, blacks:blackPile, discards:discardPile}
end cardTrick
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
on task()
set output to {}
repeat with i from 1 to 5
set {truth:truth, reds:reds, blacks:blacks, discards:discards} to cardTrick()
set end of output to "Test " & i & ": Assertion is " & truth
set end of output to "Red pile: " & join(reds, ", ")
set end of output to "Black pile: " & join(blacks, ", ")
set end of output to "Discards: " & join(items 1 thru 13 of discards, ", ")
set end of output to " " & (join(items 14 thru 26 of discards, ", ") & linefeed)
end repeat
return text 1 thru -2 of join(output, linefeed)
end task
return task()</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">"Test 1: Assertion is true
Red pile: 3♦️, 2♦️, 9♣️, 6♣️, 3♥️, 9♥️, A♠️, 3♠️, 2♥️, Q♠️, 7♥️, K♥️
Black pile: Q♥️, J♣️, 7♦️, 4♦️, 8♦️, 5♥️, K♣️, 10♠️, 10♣️, 7♣️, 2♣️, 9♦️, 5♣️, 6♦️
Discards: 9♠️, Q♦️, 3♣️, 6♠️, 8♠️, 8♥️, Q♣️, 4♠️, J♠️, K♦️, 7♠️, A♦️, 5♦️
10♥️, J♦️, A♥️, 4♥️, 6♥️, J♥️, K♠️, 5♠️, 10♦️, 4♣️, 2♠️, 8♣️, A♣️
Test 2: Assertion is true
Red pile: 7♣️, Q♠️, 2♦️, K♣️, J♠️, A♠️, J♣️, 5♣️, 6♥️, 7♦️, 5♥️, 9♥️, 8♠️, 3♠️, 6♣️, 4♠️
Black pile: K♠️, J♦️, 4♣️, 10♠️, 4♥️, 3♥️, 6♠️, 4♦️, 10♣️, 9♦️
Discards: 8♦️, J♥️, A♣️, 10♥️, 8♣️, 9♠️, A♦️, 2♣️, K♥️, Q♣️, A♥️, 5♦️, 9♣️
K♦️, 3♣️, 2♠️, 7♠️, 5♠️, 2♥️, 6♦️, 10♦️, 3♦️, Q♦️, 8♥️, 7♥️, Q♥️
Test 3: Assertion is true
Red pile: 4♥️, 2♠️, Q♦️, 9♣️, 4♣️, 7♥️, A♣️, 6♠️, 3♥️, 8♣️, A♦️, 2♣️, 6♥️, 5♦️
Black pile: K♦️, 2♦️, 5♠️, 10♠️, J♠️, 9♦️, 4♦️, 4♠️, Q♣️, 6♣️, 3♣️, 10♦️
Discards: J♦️, 9♥️, K♠️, 10♥️, 5♥️, 10♣️, K♣️, 8♠️, 8♥️, A♠️, 7♣️, 7♦️, 8♦️
Q♠️, 9♠️, 6♦️, 3♠️, 2♥️, J♣️, A♥️, K♥️, Q♥️, 5♣️, 7♠️, 3♦️, J♥️
Test 4: Assertion is true
Red pile: 6♠️, A♣️, 8♥️, 4♣️, 5♥️, J♠️, 9♠️, 7♥️, 7♣️, 4♦️, A♠️, A♥️, 8♠️, 6♦️, 5♣️, Q♣️, 6♥️, K♠️
Black pile: 5♦️, 4♠️, 2♣️, 6♣️, 10♣️, 8♣️, Q♠️, 10♠️
Discards: J♥️, A♦️, 7♠️, 9♥️, K♦️, 10♥️, Q♦️, 10♦️, 8♦️, 3♥️, 3♠️, 2♦️, J♣️
9♦️, J♦️, 9♣️, 2♠️, 3♦️, 2♥️, 7♦️, Q♥️, 3♣️, K♥️, K♣️, 5♠️, 4♥️
Test 5: Assertion is true
Red pile: 2♣️, 9♠️, 5♦️, 4♥️, K♥️, 5♥️, 8♦️, 2♠️, 3♦️, 10♥️, 10♦️
Black pile: 2♦️, 2♥️, 8♣️, 9♣️, 7♥️, 3♣️, Q♠️, 10♠️, 8♥️, 10♣️, K♣️, 5♠️, 4♦️, 3♥️, 6♥️
Discards: 7♦️, J♥️, 7♣️, 4♠️, 6♦️, 4♣️, 7♠️, Q♥️, J♠️, Q♦️, 6♠️, J♣️, A♥️
9♦️, K♦️, J♦️, 3♠️, 5♣️, Q♣️, A♣️, K♠️, 8♠️, 9♥️, A♠️, 6♣️, A♦️"</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">;==========================================================
; create cards
cards := [], suits := ["♠","♥","♦","♣"], num := 0
for i, v in StrSplit("A,2,3,4,5,6,7,8,9,10,J,Q,K",",")
for i, suit in suits
cards[++num] := v suit
;==========================================================
; create gui
w := 40
Gui, font, S10
Gui, font, S10 CRed
Gui, add, text, w100 , Face Up Red
loop, 26
Gui, add, button, % "x+0 w" w " vFR" A_Index
Gui, add, text, xs w100 , Face Down
loop, 26
Gui, add, button, % "x+0 w" w " vHR" A_Index
Gui, font, S10 CBlack
Gui, add, text, xs w100 , Face Up Black
loop, 26
Gui, add, button, % "x+0 w" w " vFB" A_Index
Gui, add, text, xs w100 , Face Down
loop, 26
Gui, add, button, % "x+0 w" w " vHB" A_Index
Gui, add, button, xs gShuffle , Shuffle
Gui, add, button, x+1 Disabled vDeal gDeal , Deal
Gui, add, button, x+1 Disabled vMove gMove, Move
Gui, add, button, x+1 Disabled vShowAll gShowAll , Show All
Gui, add, button, x+1 Disabled vPeak gPeak, Peak
Gui, add, StatusBar
Gui, show
SB_SetParts(200,200)
SB_SetText("0 Face Down Red Cards", 1)
SB_SetText("0 Face Down Black Cards", 2)
return
;==========================================================
Shuffle:
list := "", shuffled := []
Loop, 52
list .= A_Index ","
list := Trim(list, ",")
Sort, list, Random D,
loop, parse, list, `,
shuffled[A_Index] := cards[A_LoopField]
loop, 26{
GuiControl,, % "FR" A_Index
GuiControl,, % "FB" A_Index
GuiControl,, % "HR" A_Index
GuiControl,, % "HB" A_Index
}
GuiControl, Enable, Deal
GuiControl, Disable, Move
GuiControl, Disable, ShowAll
GuiControl, Enable, Peak
return
;==========================================================
peak:
list := ""
for i, v in shuffled
list .= i ": " v (mod(i,2)?"`t":"`n")
ToolTip , % list, 1000, 0
return
;==========================================================
Deal:
Color := "",
GuiControl, Disable, Deal
FaceRed:= [], FaceBlack := [], HiddenRed := [], HiddenBlack := [], toggle := 0
for i, card in shuffled
if toggle:=!toggle {
if InStr(card, "♥") || InStr(card, "♦") {
Color := "Red"
faceRed.push(card)
GuiControl,, % "FR" faceRed.Count(), % card
}
else if InStr(card, "♠") || InStr(card, "♣") {
Color := "Black"
faceBlack.push(card)
GuiControl,, % "FB" faceBlack.Count(), % card
}
}
else{
Hidden%Color%.push(card)
GuiControl,, % (color="red"?"HR":"HB") Hidden%Color%.Count(), % "?"
Sleep, 50
}
GuiControl, Enable, Move
GuiControl, Enable, ShowAll
return
;==========================================================
Move:
tempR := [], tempB := []
Random, rndcount, 1, % HiddenRed.Count() < HiddenBlack.Count() ? HiddenRed.Count() : HiddenBlack.Count()
loop, % rndcount{
Random, rnd, 1, % HiddenRed.Count()
Random, rnd, 1, % HiddenBlack.Count()
tempR.push(HiddenRed.RemoveAt(rnd))
tempB.push(HiddenBlack.RemoveAt(rnd))
}
list := ""
for i, v in tempR
list .= v "`t" tempB[i] "`n"
MsgBox % "swapping " rndcount " cards between face down Red and face down Black`n" (ShowAll?"Red`tBlack`n" list:"")
for i, v in tempR
HiddenBlack.Push(v)
for i, v in tempB
HiddenRed.push(v)
if ShowAll
gosub, ShowAll
return
;==========================================================
ShowAll:
ShowAll := true, countR := countB := 0
loop, 26{
GuiControl,, % "HR" A_Index
GuiControl,, % "HB" A_Index
}
for i, card in HiddenRed
GuiControl,, % "HR" i, % (card~= "[♥♦]"?"[":"") card (card~= "[♥♦]"?"]":"")
, countR := (card~= "[♥♦]") ? countR+1 : countR
for i, card in HiddenBlack
GuiControl,, % "HB" i, % (card~= "[♠♣]"?"[":"") card (card~= "[♠♣]"?"]":"")
, countB := (card~= "[♠♣]") ? countB+1 : countB
SB_SetText(countR " Face Down Red Cards", 1)
SB_SetText(countB " Face Down Black Cards", 2)
return
;==========================================================</syntaxhighlight>
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define SIM_N 5 /* Run 5 simulations */
#define PRINT_DISCARDED 1 /* Whether or not to print the discard pile */
#define min(x,y) ((x<y)?(x):(y))
typedef uint8_t card_t;
/* Return a random number from an uniform distribution (0..n-1) */
unsigned int rand_n(unsigned int n) {
unsigned int out, mask = 1;
/* Find how many bits to mask off */
while (mask < n) mask = mask<<1 | 1;
/* Generate random number */
do {
out = rand() & mask;
} while (out >= n);
return out;
}
/* Return a random card (0..51) from an uniform distribution */
card_t rand_card() {
return rand_n(52);
}
/* Print a card */
void print_card(card_t card) {
static char *suits = "HCDS"; /* hearts, clubs, diamonds and spades */
static char *cards[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
printf(" %s%c", cards[card>>2], suits[card&3]);
}
/* Shuffle a pack */
void shuffle(card_t *pack) {
int card;
card_t temp, randpos;
for (card=0; card<52; card++) {
randpos = rand_card();
temp = pack[card];
pack[card] = pack[randpos];
pack[randpos] = temp;
}
}
/* Do the card trick, return whether cards match */
int trick() {
card_t pack[52];
card_t blacks[52/4], reds[52/4];
card_t top, x, card;
int blackn=0, redn=0, blacksw=0, redsw=0, result;
/* Create and shuffle a pack */
for (card=0; card<52; card++) pack[card] = card;
shuffle(pack);
/* Deal cards */
#if PRINT_DISCARDED
printf("Discarded:"); /* Print the discard pile */
#endif
for (card=0; card<52; card += 2) {
top = pack[card]; /* Take card */
if (top & 1) { /* Add next card to black or red pile */
blacks[blackn++] = pack[card+1];
} else {
reds[redn++] = pack[card+1];
}
#if PRINT_DISCARDED
print_card(top); /* Show which card is discarded */
#endif
}
#if PRINT_DISCARDED
printf("\n");
#endif
/* Swap an amount of cards */
x = rand_n(min(blackn, redn));
for (card=0; card<x; card++) {
/* Pick a random card from the black and red pile to swap */
blacksw = rand_n(blackn);
redsw = rand_n(redn);
/* Swap them */
top = blacks[blacksw];
blacks[blacksw] = reds[redsw];
reds[redsw] = top;
}
/* Verify the assertion */
result = 0;
for (card=0; card<blackn; card++)
result += (blacks[card] & 1) == 1;
for (card=0; card<redn; card++)
result -= (reds[card] & 1) == 0;
result = !result;
printf("The number of black cards in the 'black' pile"
" %s the number of red cards in the 'red' pile.\n",
result? "equals" : "does not equal");
return result;
}
int main() {
unsigned int seed, i, successes = 0;
FILE *r;
/* Seed the RNG with bytes from from /dev/urandom */
if ((r = fopen("/dev/urandom", "r")) == NULL) {
fprintf(stderr, "cannot open /dev/urandom\n");
return 255;
}
if (fread(&seed, sizeof(unsigned int), 1, r) != 1) {
fprintf(stderr, "failed to read from /dev/urandom\n");
return 255;
}
fclose(r);
srand(seed);
/* Do simulations. */
for (i=1; i<=SIM_N; i++) {
printf("Simulation %d\n", i);
successes += trick();
printf("\n");
}
printf("Result: %d successes out of %d simulations\n",
successes, SIM_N);
return 0;
}</syntaxhighlight>
{{out}}
<pre>Simulation 1
Discarded: 10D 9S 7S KD 4S JS 6H 2D 2S 7H JH 5S AD AC 7D 5C 7C KH QD 4D 5H 2C 2H QS AH 3H
The number of black cards in the 'black' pile equals the number of red cards in the 'red' pile.
Simulation 2
Discarded: AC 10D QC 4H 2D AD 8D 10C 9D 2C QS 3S JC KS 6S AS 2S 6C 6D 6H 3D 8C 2H QH 7D 5D
The number of black cards in the 'black' pile equals the number of red cards in the 'red' pile.
Simulation 3
Discarded: 5D 2C JC 5C 5H 10D KD 4H KC 4S 8C 9S 6H 4D 2H 9H QS 10C 2S 3C AC 7H QD 7D JD 6S
The number of black cards in the 'black' pile equals the number of red cards in the 'red' pile.
Simulation 4
Discarded: 6S 4C KS AD 4S QS 9C 7D JD AC KH 10S KD QD 3S 5C QH 9D 2H 5S QC KC 7C 3D 9S AH
The number of black cards in the 'black' pile equals the number of red cards in the 'red' pile.
Simulation 5
Discarded: AD KH AC 8C 3C 5S KD QS 4C 2H 10C 2C JC 8D 6D JS 7C 4H 6H 6C 3S QC 6S KS 8H 7H
The number of black cards in the 'black' pile equals the number of red cards in the 'red' pile.
Result: 5 successes out of 5 simulations</pre>
=={{header|C#}}==
{{trans|Java}}
<syntaxhighlight lang="C#">
using System;
using System.Collections.Generic;
using System.Linq;
public class MindBogglingCardTrick
{
public static void Main(string[] args)
{
List<char> cards = new List<char>();
cards.AddRange(Enumerable.Repeat('R', 26));
cards.AddRange(Enumerable.Repeat('B', 26));
Shuffle(cards);
List<char> redPile = new List<char>();
List<char> blackPile = new List<char>();
List<char> discardPile = new List<char>();
for (int i = 0; i < 52; i += 2)
{
if (cards[i] == 'R')
{
redPile.Add(cards[i + 1]);
}
else
{
blackPile.Add(cards[i + 1]);
}
discardPile.Add(cards[i]);
}
Console.WriteLine("A sample run.\n");
Console.WriteLine("After dealing the cards the state of the piles is:");
Console.WriteLine($" Red : {redPile.Count} cards -> {string.Join(",", redPile)}");
Console.WriteLine($" Black : {blackPile.Count} cards -> {string.Join(",", blackPile)}");
Console.WriteLine($" Discard: {discardPile.Count} cards -> {string.Join(",", discardPile)}");
Random random = new Random();
int minimumSize = Math.Min(redPile.Count, blackPile.Count);
int choice = random.Next(1, minimumSize + 1);
List<int> redIndexes = Enumerable.Range(0, redPile.Count).ToList();
List<int> blackIndexes = Enumerable.Range(0, blackPile.Count).ToList();
Shuffle(redIndexes);
Shuffle(blackIndexes);
List<int> redChosenIndexes = redIndexes.Take(choice).ToList();
List<int> blackChosenIndexes = blackIndexes.Take(choice).ToList();
Console.WriteLine($"\nNumber of cards are to be swapped: {choice}");
Console.WriteLine("The respective zero-based indices of the cards to be swapped are:");
Console.WriteLine($" Red : {string.Join(", ", redChosenIndexes)}");
Console.WriteLine($" Black: {string.Join(", ", blackChosenIndexes)}");
for (int i = 0; i < choice; i++)
{
char temp = redPile[redChosenIndexes[i]];
redPile[redChosenIndexes[i]] = blackPile[blackChosenIndexes[i]];
blackPile[blackChosenIndexes[i]] = temp;
}
Console.WriteLine($"\nAfter swapping cards the state of the red and black piles is:");
Console.WriteLine($" Red : {string.Join(", ", redPile)}");
Console.WriteLine($" Black: {string.Join(", ", blackPile)}");
int redCount = redPile.Count(ch => ch == 'R');
int blackCount = blackPile.Count(ch => ch == 'B');
Console.WriteLine($"\nThe number of red cards in the red pile: {redCount}");
Console.WriteLine($"The number of black cards in the black pile: {blackCount}");
if (redCount == blackCount)
{
Console.WriteLine("So the assertion is correct.");
}
else
{
Console.WriteLine("So the assertion is incorrect.");
}
}
private static void Shuffle<T>(List<T> list)
{
Random rng = new Random();
int n = list.Count;
while (n > 1)
{
n--;
int k = rng.Next(n + 1);
T value = list[k];
list[k] = list[n];
list[n] = value;
}
}
}
</syntaxhighlight>
{{out}}
<pre>
A sample run.
After dealing the cards the state of the piles is:
Red : 13 cards -> B,R,R,R,R,B,R,R,R,B,R,R,B
Black : 13 cards -> R,R,B,B,R,B,R,B,B,B,B,B,B
Discard: 26 cards -> R,R,B,R,B,R,R,B,R,B,R,R,B,B,R,B,R,B,B,B,B,B,R,B,R,R
Number of cards are to be swapped: 3
The respective zero-based indices of the cards to be swapped are:
Red : 9, 8, 1
Black: 1, 11, 5
After swapping cards the state of the red and black piles is:
Red : B, B, R, R, R, B, R, R, B, R, R, R, B
Black: R, B, B, B, R, R, R, B, B, B, B, R, B
The number of red cards in the red pile: 8
The number of black cards in the black pile: 8
So the assertion is correct.
</pre>
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <algorithm>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <random>
#include <vector>
template <typename T>
void print_vector(const std::vector<T>& list) {
std::cout << "[";
for ( uint64_t i = 0; i < list.size() - 1; ++i ) {
std::cout << list[i] << " ";
}
std::cout << list.back() << "]" << std::endl;
}
int main() {
std::vector<char> cards;
for ( int32_t i = 0; i < 26; ++i ) {
cards.emplace_back('R');
cards.emplace_back('B');
}
std::random_device rand;
std::mt19937 mersenne_twister(rand());
std::shuffle(cards.begin(), cards.end(), mersenne_twister);
std::vector<char> red_pile;
std::vector<char> black_pile;
std::vector<char> discard_pile;
for ( int32_t i = 0; i < 52; i += 2 ) {
if ( cards[i] == 'R' ) {
red_pile.emplace_back(cards[i + 1]);
} else {
black_pile.emplace_back(cards[i + 1]);
}
discard_pile.emplace_back(cards[i]);
}
std::cout << "A sample run." << "\n" << std::endl;
std::cout << "After dealing the cards the state of the piles is:" << std::endl;
std::cout << " Red : " << std::setw(2) << red_pile.size() << " cards -> "; print_vector<char>(red_pile);
std::cout << " Black : " << std::setw(2) << black_pile.size() << " cards -> "; print_vector<char>(black_pile);
std::cout << " Discard: " << std::setw(2) << discard_pile.size()
<< " cards -> "; print_vector<char>(discard_pile);
const int32_t minimum_size = std::min(red_pile.size(), black_pile.size());
std::uniform_int_distribution<int> uniform_random{ 1, minimum_size };
const int32_t choice = uniform_random(mersenne_twister);
std::vector<int32_t> red_indexes(red_pile.size());
std::iota(red_indexes.begin(), red_indexes.end(), 0);
std::vector<int32_t> black_indexes(black_pile.size());
std::iota(black_indexes.begin(), black_indexes.end(), 0);
std::shuffle(red_indexes.begin(), red_indexes.end(), mersenne_twister);
std::shuffle(black_indexes.begin(), black_indexes.end(), mersenne_twister);
std::vector<int32_t> red_chosen_indexes(red_indexes.begin(), red_indexes.begin() + choice);
std::vector<int32_t> black_chosen_indexes(black_indexes.begin(), black_indexes.begin() + choice);
std::cout << "\n" << "Number of cards are to be swapped: " << choice << std::endl;
std::cout << "The respective zero-based indices of the cards to be swapped are:" << std::endl;
std::cout << " Red : "; print_vector<int32_t>(red_chosen_indexes);
std::cout << " Black: "; print_vector<int32_t>(black_chosen_indexes);
for ( int32_t i = 0; i < choice; ++i ) {
const char temp = red_pile[red_chosen_indexes[i]];
red_pile[red_chosen_indexes[i]] = black_pile[black_chosen_indexes[i]];
black_pile[black_chosen_indexes[i]] = temp;
}
std::cout << "\n" << "After swapping cards the state of the red and black piles is:" << std::endl;
std::cout << " Red : "; print_vector<char>(red_pile);
std::cout << " Black: "; print_vector<char>(black_pile);
int32_t red_count = 0;
for ( const char& ch : red_pile ) {
if ( ch == 'R' ) {
red_count++;
}
}
int32_t black_count = 0;
for ( const char& ch : black_pile ) {
if ( ch == 'B' ) {
black_count++;
}
}
std::cout << "\n" << "The number of red cards in the red pile: " << red_count << std::endl;
std::cout << "The number of black cards in the black pile: " << black_count << std::endl;
if ( red_count == black_count ) {
std::cout << "So the assertion is correct." << std::endl;
} else {
std::cout << "So the assertion is incorrect." << std::endl;
}
}
</syntaxhighlight>
{{ out }}
<pre>
A sample run.
After dealing the cards the state of the piles is:
Red : 11 cards -> [R R B R R B R B B B R]
Black : 15 cards -> [B R B B R B R R R B B R R R R]
Discard: 26 cards -> [B B R B B B B R R B R R R R B B B R B R B B R B R B]
Number of cards are to be swapped: 11
The respective zero-based indices of the cards to be swapped are:
Red : [6 7 10 2 8 4 1 3 0 5 9]
Black: [2 9 11 12 0 7 3 6 8 14 10]
After swapping cards the state of the red and black piles is:
Red : [R B R R R R B B B B R]
Black: [B R R R R B R R R B B R B R B]
The number of red cards in the red pile: 6
The number of black cards in the black pile: 6
So the assertion is correct.
</pre>
=={{header|Crystal}}==
{{trans|Ruby}}
<syntaxhighlight lang="ruby">deck = ([:black, :red] * 26 ).shuffle
black_pile, red_pile, discard = [] of Symbol, [] of Symbol, [] of Symbol
until deck.empty?
discard << deck.pop
discard.last == :black ? black_pile << deck.pop : red_pile << deck.pop
end
x = rand( [black_pile.size, red_pile.size].min )
red_bunch = (0...x).map { red_pile.delete_at( rand( red_pile.size )) }
black_bunch = (0...x).map { black_pile.delete_at( rand( black_pile.size )) }
black_pile += red_bunch
red_pile += black_bunch
puts "The magician predicts there will be #{black_pile.count( :black )} red cards in the other pile.
Drumroll...
There were #{red_pile.count( :red )}!"</syntaxhighlight>
{{out}}
<pre>The magician predicts there will be 7 red cards in the other pile.
Drumroll...
There were 7!
</pre>
=={{header|EasyLang}}==
{{trans|Wren}}
<syntaxhighlight>
proc shuffle . a[] .
for i = len a[] downto 2
r = randint i
swap a[r] a[i]
.
.
func$ a2str a[] .
for v in a[]
r$ &= strchar v & " "
.
return r$
.
R = strcode "R"
B = strcode "B"
for i to 26
pack[] &= R
pack[] &= B
.
shuffle pack[]
#
for i = 1 step 2 to 51
if pack[i] = B
black[] &= pack[i + 1]
else
red[] &= pack[i + 1]
.
discard[] &= pack[i]
.
print "After dealing the cards the state of the stacks is:"
print " Red : " & a2str red[]
print " Black : " & a2str black[]
print " Discard: " & a2str discard[]
for i to len red[]
rp[] &= i
.
for i to len black[]
bp[] &= i
.
shuffle rp[]
shuffle bp[]
n = randint lower len red[] len black[]
len rp[] n
len bp[] n
#
for i to n
h = red[rp[i]]
red[rp[i]] = black[bp[i]]
black[bp[i]] = h
.
print ""
print "After swapping " & n & " cards the state of the stacks is:"
print " Red : " & a2str red[]
print " Black : " & a2str black[]
#
for c in red[]
red += if c = R
.
for c in black[]
black += if c = B
.
print ""
print "The number of red cards in the red stack = " & red
print "The number of black cards in the black stack = " & black
if red = black
print "So the asssertion is correct!"
.
</syntaxhighlight>
{{out}}
<pre>
After dealing the cards the state of the stacks is:
Red : B B B R B B B R R R R R R B
Black : B B B R R B R B B R R B
Discard: R B R B B R B R R B B R R R R R R R R B B B B B R B
After swapping 7 cards the state of the stacks is:
Red : R R B R R B B R B R B R R B
Black : B B R B R B B B R B R B
The number of red cards in the red stack = 8
The number of black cards in the black stack = 8
So the asssertion is correct!
</pre>
=={{header|F_Sharp|F#}}==
<
//Be boggled? Nigel Galloway: September 19th., 2018
let N=System.Random()
let fN=List.unfold(function |(0,0)->None |(n,g)->let ng=N.Next (n+g) in Some (if ng>=n then
let fG n=let (n,n')::(g,g')::_=List.countBy(fun (n::g::_)->if n=g then n else g) n in sprintf "%d %s cards and %d %s cards" n' n g' g
printf "A well shuffled deck -> "; List.iter (printf "%s ") fN; printfn ""
fN |> List.chunkBySize 2 |> List.groupBy
</syntaxhighlight>
{{out}}
<pre>
A well shuffled deck -> Black Black
The Black pile contains
The Red pile contains
</pre>
=={{header|Factor}}==
<
generalizations io kernel math math.ranges random sequences
sequences.extras ;
Line 102 ⟶ 923:
test-assertion ; ! step 4
MAIN: main</
A run:
{{out}}
Line 155 ⟶ 976:
B in black: 5
</pre>
=={{header|FreeBASIC}}==
{{trans|XPL0}}
<syntaxhighlight lang="vbnet">Randomize Timer
Dim Shared As String Deck(52), BlackPile(52), RedPile(52), DiscardPile(52)
Dim Shared As Integer BlP, ReP, DiP
Sub Show
Dim As Integer i
Print "Black pile: ";
For i = 0 To BlP-1
Print BlackPile(i);
Next i
Print !"\nRed pile: ";
For i = 0 To ReP-1
Print RedPile(i);
Next i
Print !"\nDiscard pile: ";
For i = 0 To DiP-1
Print DiscardPile(i);
Next i
Print
End Sub
Dim As String BlackBunch(52), RedBunch(52)
Dim As Integer i, j, m, x, y, BB, RB, BC, RC
Dim As Integer ub = Ubound(Deck)
For i = 0 To (ub/2)-1
Deck(i) = "r"
Deck(i+26) = "b"
Next i
For i = 0 To ub-1
y = Int(Rnd * 51) + 1
Swap Deck(y), Deck(i)
Next i
BlP = 0
ReP = 0
DiP = 0
For i = 0 To ub-1
If Deck(i) = "b" Then
BlackPile(BlP) = Deck(i+1)
BlP += 1
Else
RedPile(ReP) = Deck(i+1)
ReP += 1
End If
DiscardPile(DiP) = Deck(i)
DiP += 1
i += 1
Next i
Show
m = BlP
If ReP < m Then m = ReP
x = Int(Rnd * m) + 1
Print "Swap "; x; " cards between the red and black piles."
RB = 0
BB = 0
For i = 0 To x-1
Do
y = Int(Rnd * ReP)
Loop Until RedPile(y) <> "0"
RedBunch(RB) = RedPile(y)
RB += 1
RedPile(y) = "0"
Next i
For i = 0 To x-1
Do
y = Int(Rnd * BlP)
Loop Until BlackPile(y) <> "0"
BlackBunch(BB) = BlackPile(y)
BB += 1
BlackPile(y) = "0"
Next i
RB = 0
For i = 0 To x-1
j = 0
While BlackPile(j) <> "0"
j += 1
Wend
BlackPile(j) = RedBunch(RB)
RB += 1
Next i
BB = 0
For i = 0 To x-1
j = 0
While RedPile(j) <> "0"
j += 1
Wend
RedPile(j) = BlackBunch(BB)
BB += 1
Next i
Show
BC = 0
For i = 0 To BlP-1
If BlackPile(i) = "b" Then BC += 1
Next i
RC = 0
For i = 0 To ReP-1
If RedPile(i) = "r" Then RC += 1
Next i
Print "The number of black cards in the black pile is "; BC
Print "The number of red cards in the red pile is "; RC
Print Using "The mathematician's assertion is &correct."; Iif(BC <>RC, "not ", "")
Sleep</syntaxhighlight>
{{out}}
<pre>Black pile: rbrbrrrrbrrrrb
Red pile: bbbbrrbrbbbr
Discard pile: bbrrbrrbbrbrrrrbrbbrbbrbbb
Swap 11 cards between the red and black piles.
Black pile: rbbrbrbbbbrbrb
Red pile: rrrrrrbbrrbr
Discard pile: bbrrbrrbbrbrrrrbrbbrbbrbbb
The number of black cards in the black pile is 9
The number of red cards in the red pile is 9
The mathematician's assertion is correct.</pre>
=={{header|Go}}==
<
import (
Line 234 ⟶ 1,174:
fmt.Println("So the asssertion is incorrect!")
}
}</
{{out}}
Line 282 ⟶ 1,222:
=={{header|Haskell}}==
<
import Data.List (partition)
import Data.Monoid ((<>))
main :: IO [Int]
main = do
-- DEALT
ns <- knuthShuffle [1 .. 52]
let (rs_, bs_, discards) = threeStacks (rb <$> ns)
-- SWAPPED
nSwap <- randomRIO (1, min (length rs_) (length bs_))
let (rs, bs) = exchange nSwap rs_ bs_
-- CHECKED
let rrs = filter ('R' ==) rs
Line 311 ⟶ 1,251:
]
return ns
-- RED vs BLACK ----------------------------------------
rb :: Int -> Char
Line 317 ⟶ 1,257:
| even n = 'R'
| otherwise = 'B'
-- THREE STACKS ----------------------------------------
threeStacks :: String -> (String, String, String)
Line 327 ⟶ 1,267:
| 'R' == x = go (y : rs, bs, x : ds) xs
| otherwise = go (rs, y : bs, x : ds) xs
exchange :: Int -> [a] -> [a] -> ([a], [a])
exchange n xs ys =
let [xs_, ys_] = splitAt n <$> [xs, ys]
in (fst ys_ <> snd xs_, fst xs_ <> snd ys_)
-- SHUFFLE -----------------------------------------------
-- (See Knuth Shuffle task)
knuthShuffle :: [a] -> IO [a]
knuthShuffle xs = (foldr swapElems xs . zip [1 ..]) <$> randoms (length xs)
randoms :: Int -> IO [Int]
randoms x =
swapElems :: (Int, Int) -> [a] -> [a]
swapElems (i, j) xs
| i == j = xs
| otherwise = replaceAt j (xs !! i) $ replaceAt i (xs !! j) xs
replaceAt :: Int -> a -> [a] -> [a]
replaceAt i c l =
let (a, b) = splitAt i l
in a ++ c : drop 1 b</
{{Out}}
<pre>Discarded: RRRRRBBBBBRBBBRBBRBRRBRRRB
Line 358 ⟶ 1,298:
BBBBBB = Black cards in the black pile
True</pre>
=={{header|J}}==
The trick verb returns 0 if the magician's proposition fails, otherwise 1.
<syntaxhighlight lang="j">
NB. A failed assertion looks like this
assert 0
|assertion failure: assert
| assert 0
</syntaxhighlight>
We find that in three runs the trick works.
<syntaxhighlight lang="j">
shuffle =: {~ ?~@:#
f =: (,&.> {:)~
g =: ({.@],(f {:))`((f {.),{:@])@.({.@[)
trick =: 3 :0
DECK =: shuffle 2 | i. 52
'B R' =: shuffle L:_1 > g&.>/(_2 <\ DECK) , < 2 # a:
NB. although I swap the first N cards of each pile,
NB. the piles were shuffled following placement
N =: ? R <.&# B
echo 'prior to swap of ',(":N),' cards'
echo 'black pile ',B{'rB'
echo 'red pile ',R{'rB'
BR =: N {. B
RB =: N {. R
B =: RB , N }. B
R =: BR , N }. R
echo 'after swap'
echo 'black pile ',B{'rB'
echo 'red pile ',R{'rB'
B (-:&(+/) -.) R
)
assert trick''
prior to swap of 10 cards
black pile rBrrrrrBBrrrBrr
red pile BBrBrBBrBBr
after swap
black pile BBrBrBBrBBrrBrr
red pile rBrrrrrBBrr
assert trick''
prior to swap of 6 cards
black pile rBBBBrBBr
red pile rrBBBBrBrBBBBrrBB
after swap
black pile rrBBBBBBr
red pile rBBBBrrBrBBBBrrBB
assert trick''
prior to swap of 3 cards
black pile rBrBrrrBBrr
red pile BrrBrBBrBBBBBBB
after swap
black pile BrrBrrrBBrr
red pile rBrBrBBrBBBBBBB
</syntaxhighlight>
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public final class MindBogglingCardTrick {
public static void main(String[] aArgs) {
List<Character> cards = new ArrayList<Character>(52);
cards.addAll(Collections.nCopies(26, 'R'));
cards.addAll(Collections.nCopies(26, 'B'));
Collections.shuffle(cards);
List<Character> redPile = new ArrayList<Character>();
List<Character> blackPile = new ArrayList<Character>();
List<Character> discardPile = new ArrayList<Character>();
for ( int i = 0; i < 52; i += 2 ) {
if ( cards.get(i) == 'R' ) {
redPile.add(cards.get(i + 1));
} else {
blackPile.add(cards.get(i + 1));
}
discardPile.add(cards.get(i));
}
System.out.println("A sample run." + System.lineSeparator());
System.out.println("After dealing the cards the state of the piles is:");
System.out.println(String.format(" Red : %2d cards -> %s", redPile.size(), redPile));
System.out.println(String.format(" Black : %2d cards -> %s", blackPile.size(), blackPile));
System.out.println(String.format(" Discard: %2d cards -> %s", discardPile.size(), discardPile));
ThreadLocalRandom random = ThreadLocalRandom.current();
final int minimumSize = Math.min(redPile.size(), blackPile.size());
final int choice = random.nextInt(1, minimumSize + 1);
List<Integer> redIndexes = IntStream.range(0, redPile.size()).boxed().collect(Collectors.toList());
List<Integer> blackIndexes = IntStream.range(0, blackPile.size()).boxed().collect(Collectors.toList());
Collections.shuffle(redIndexes);
Collections.shuffle(blackIndexes);
List<Integer> redChosenIndexes = redIndexes.subList(0, choice);
List<Integer> blackChosenIndexes = blackIndexes.subList(0, choice);
System.out.println(System.lineSeparator() + "Number of cards are to be swapped: " + choice);
System.out.println("The respective zero-based indices of the cards to be swapped are:");
System.out.println(" Red : " + redChosenIndexes);
System.out.println(" Black: " + blackChosenIndexes);
for ( int i = 0; i < choice; i++ ) {
final char temp = redPile.get(redChosenIndexes.get(i));
redPile.set(redChosenIndexes.get(i), blackPile.get(blackChosenIndexes.get(i)));
blackPile.set(blackChosenIndexes.get(i), temp);
}
System.out.println(System.lineSeparator() + "After swapping cards the state of the red and black piles is:");
System.out.println(" Red : " + redPile);
System.out.println(" Black: " + blackPile);
int redCount = 0;
for ( char ch : redPile ) {
if ( ch == 'R' ) {
redCount += 1;
}
}
int blackCount = 0;
for ( char ch : blackPile ) {
if ( ch == 'B' ) {
blackCount += 1;
}
}
System.out.println(System.lineSeparator() + "The number of red cards in the red pile: " + redCount);
System.out.println("The number of black cards in the black pile: " + blackCount);
if ( redCount == blackCount ) {
System.out.println("So the assertion is correct.");
} else {
System.out.println("So the assertion is incorrect.");
}
}
}
</syntaxhighlight>
{{ out }}
<pre>
A sample run.
After dealing the cards the state of the piles is:
Red : 11 cards -> [B, R, R, R, B, B, R, R, B, R, B]
Black : 15 cards -> [R, R, R, R, R, R, B, R, R, B, B, R, B, B, B]
Discard: 26 cards -> [R, B, B, B, R, B, R, R, R, B, B, B, B, B, R, B, B, B, R, R, R, R, R, B, B, B]
Number of cards are to be swapped: 6
The respective zero-based indices of the cards to be swapped are:
Red : [4, 5, 6, 9, 0, 2]
Black: [1, 4, 10, 7, 3, 0]
After swapping cards the state of the red and black piles is:
Red : [R, R, R, R, R, R, B, R, B, R, B]
Black: [R, B, R, B, B, R, B, R, R, B, R, R, B, B, B]
The number of red cards in the red pile: 8
The number of black cards in the black pile: 8
So the assertion is correct.
</pre>
=={{header|Javascript}}==
{{trans|Haskell}}
<
'use strict';
Line 522 ⟶ 1,631:
// MAIN ---
return main();
})();</
{{Out}}
<pre>Discarded: BRBRBRRRRBBBRBBBRBBBBBRRBR
Line 531 ⟶ 1,640:
BBBBBBBB = Black cards in the black pile
true</pre>
=={{header|Julia}}==
{{trans|Raku}}
<syntaxhighlight lang="julia">using Random
const rbdeck = split(repeat('R', 26) * repeat('B', 26), "")
shuffledeck() = shuffle(rbdeck)
function deal!(deck, dpile, bpile, rpile)
while !isempty(deck)
if (topcard = pop!(deck)) == "R"
push!(rpile, pop!(deck))
else
push!(bpile, pop!(deck))
end
push!(dpile, topcard)
end
end
function swap!(rpile, bpile, nswapping)
rpick = sort(randperm(length(rpile))[1:nswapping])
bpick = sort(randperm(length(bpile))[1:nswapping])
rrm = rpile[rpick]; brm = bpile[bpick]
deleteat!(rpile, rpick); deleteat!(bpile, bpick)
append!(rpile, brm); append!(bpile, rrm)
end
function mindbogglingcardtrick(verbose=true)
prif(cond, txt) = (if(cond) println(txt) end)
deck = shuffledeck()
prif(verbose, "Shuffled deck is: $deck")
dpile, rpile, bpile = [], [], []
deal!(deck, dpile, bpile, rpile)
prif(verbose, "Before swap:")
prif(verbose, "Discard pile: $dpile")
prif(verbose, "Red card pile: $rpile")
prif(verbose, "Black card pile: $bpile")
amount = rand(1:min(length(rpile), length(bpile)))
prif(verbose, "Swapping a random number of cards: $amount will be swapped.")
swap!(rpile, bpile, amount)
prif(verbose, "Red pile after swaps: $rpile")
prif(verbose, "Black pile after swaps: $bpile")
println("There are $(sum(map(x->x=="B", bpile))) black cards in the black card pile:")
println("there are $(sum(map(x->x=="R", rpile))) red cards in the red card pile.")
prif(verbose, "")
end
mindbogglingcardtrick()
for _ in 1:10
mindbogglingcardtrick(false)
end
</syntaxhighlight>{{output}}<pre>
Shuffled deck is: SubString{String}["B", "B", "R", "B", "B", "R", "B", "R", "B", "R", "B", "B", "B", "R", "B", "R", "R", "B", "R", "R",
"R", "R", "R", "R", "B", "R", "B", "B", "B", "R", "R", "B", "B", "R", "B", "B", "R", "R", "B", "R", "R", "R", "R", "B", "B", "R", "B",
"B", "B", "B", "R", "R"]
Before swap:
Discard pile: Any["R", "B", "B", "R", "B", "R", "R", "R", "B", "R", "B", "R", "B", "R", "R", "R", "R", "B", "R", "R", "B", "R", "R",
"R", "B", "B"]
Red card pile: Any["R", "B", "R", "B", "R", "B", "B", "B", "R", "R", "R", "B", "B", "B", "B", "B"]
Black card pile: Any["B", "B", "R", "B", "R", "B", "R", "B", "R", "B"]
Swapping a random number of cards: 8 will be swapped.
Red pile after swaps: Any["R", "B", "B", "B", "R", "B", "B", "B", "R", "B", "R", "B", "R", "B", "R", "B"]
Black pile after swaps: Any["B", "B", "R", "R", "B", "B", "R", "R", "B", "B"]
There are 6 black cards in the black card pile:
there are 6 red cards in the red card pile.
There are 5 black cards in the black card pile:
there are 5 red cards in the red card pile.
There are 6 black cards in the black card pile:
there are 6 red cards in the red card pile.
There are 7 black cards in the black card pile:
there are 7 red cards in the red card pile.
There are 8 black cards in the black card pile:
there are 8 red cards in the red card pile.
There are 7 black cards in the black card pile:
there are 7 red cards in the red card pile.
There are 5 black cards in the black card pile:
there are 5 red cards in the red card pile.
There are 6 black cards in the black card pile:
there are 6 red cards in the red card pile.
There are 8 black cards in the black card pile:
there are 8 red cards in the red card pile.
There are 6 black cards in the black card pile:
there are 6 red cards in the red card pile.
There are 8 black cards in the black card pile:
there are 8 red cards in the red card pile.
</pre>
=={{header|Kotlin}}==
{{trans|Go}}
<
import java.util.Random
Line 595 ⟶ 1,796:
println("So the asssertion is incorrect!")
}
}</
{{output}}
Line 642 ⟶ 1,843:
</pre>
=={{header|Lua}}==
<syntaxhighlight lang="lua">-- support:
function T(t) return setmetatable(t, {__index=table}) end
table.range = function(t,n) local s=T{} for i=1,n do s[i]=i end return s end
table.map = function(t,f) local s=T{} for i=1,#t do s[i]=f(t[i]) end return s end
table.filter = function(t,f) local s=T{} for i=1,#t do if f(t[i]) then s[#s+1]=t[i] end end return s end
table.clone = function(t) local s=T{} for k,v in ipairs(t) do s[k]=v end return s end
table.head = function(t,n) local s=T{} n=n>#t and #t or n for i = 1,n do s[i]=t[i] end return s end
table.tail = function(t,n) local s=T{} n=n>#t and #t or n for i = 1,n do s[i]=t[#t-n+i] end return s end
table.append = function(t,v) local s=t:clone() for i=1,#v do s[#s+1]=v[i] end return s end
table.shuffle = function(t) for i=#t,2,-1 do local j=math.random(i) t[i],t[j]=t[j],t[i] end return t end -- inplace!
-- task:
function cardtrick()
-- 1.
local deck = T{}:range(52):map(function(v) return v%2==0 and "B" or "R" end):shuffle()
print("1. DECK : " .. deck:concat())
-- 2. (which guarantees the outcome)
local bpile, rpile, discs = T{}, T{}, T{}
local xpile = {B=bpile, R=rpile}
while #deck>0 do
local card, next = deck:remove(), deck:remove()
xpile[card]:insert(next)
discs:insert(card)
end
print("2. BLACK PILE: " .. bpile:concat())
print("2. RED PILE : " .. rpile:concat())
print("2. DISCARDS : " .. discs:concat())
-- 3. (which cannot change the outcome)
local x = math.random(0, math.min(#bpile, #rpile))
local btake, rtake = T{}, T{}
for i = 1, x do
btake:insert((bpile:remove(math.random(#bpile))))
rtake:insert((rpile:remove(math.random(#rpile))))
end
print("3. SWAPPING X: " .. x)
print("3. BLACK SWAP: keep:" .. bpile:concat() .. " take:" .. btake:concat())
print("3. RED SWAP : keep:" .. rpile:concat() .. " take:" .. rtake:concat())
bpile, rpile = bpile:append(rtake), rpile:append(btake)
print("3. BLACK PILE: " .. bpile:concat())
print("3. RED PILE : " .. rpile:concat())
-- 4. ("proving" that which was guaranteed earlier)
local binb, rinr = bpile:filter(function(v) return v=="B" end), rpile:filter(function(v) return v=="R" end)
print("4. BLACK PILE: contains " .. #binb .. " B's")
print("4. RED PILE : contains " .. #rinr .. " R's")
print(#binb==#rinr and "VERIFIED" or "NOT VERIFIED")
print()
end
-- demo:
math.randomseed(os.time())
for i = 1,3 do cardtrick() end</syntaxhighlight>
{{out}}
<pre>1. DECK : RBBBRBRBRBBBBRRRRBRBBBRRBRRBRRBRBBRRBBRRBBRRRBBRBRBR
2. BLACK PILE: RBBBRBRRBRRRBR
2. RED PILE : BBBRRRBRBRRB
2. DISCARDS : RRRBRBRBRBRRBRRBBBRRBBBBBB
3. SWAPPING X: 3
3. BLACK SWAP: keep:RBBRBRRRRBR take:BBR
3. RED SWAP : keep:BBRRBRBRR take:RBB
3. BLACK PILE: RBBRBRRRRBRRBB
3. RED PILE : BBRRBRBRRBBR
4. BLACK PILE: contains 6 B's
4. RED PILE : contains 6 R's
VERIFIED
1. DECK : BRBBRRRRRBRBBRRBRRRRRBRBRBBBBBBRRRRBBRBBRBBRRBBBRBBR
2. BLACK PILE: RBRRBRBBRRRRRRB
2. RED PILE : BBBRBRRBRRB
2. DISCARDS : RBBBRBBRBRRBBBBBRRBRBBRRBR
3. SWAPPING X: 1
3. BLACK SWAP: keep:RRRBRBBRRRRRRB take:B
3. RED SWAP : keep:BBBRBRBRRB take:R
3. BLACK PILE: RRRBRBBRRRRRRBR
3. RED PILE : BBBRBRBRRBB
4. BLACK PILE: contains 4 B's
4. RED PILE : contains 4 R's
VERIFIED
1. DECK : BBRRRBBBBRBBRBBBRBRRRRRRBBRRRBRRBRRRRBRBBBRBBBBRBRBR
2. BLACK PILE: BRBRRRBRBRBBRB
2. RED PILE : BBBRBRRRRRBR
2. DISCARDS : RRRBBBBBRRRBRBRRRBBBBRBBRB
3. SWAPPING X: 5
3. BLACK SWAP: keep:BBRBRBBRB take:RBRRR
3. RED SWAP : keep:BRBRRBR take:BRRBR
3. BLACK PILE: BBRBRBBRBBRRBR
3. RED PILE : BRBRRBRRBRRR
4. BLACK PILE: contains 8 B's
4. RED PILE : contains 8 R's
VERIFIED</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">s = RandomSample@Flatten[{Table[0, 26], Table[1, 26]}]
g = Take[s, {1, -1, 2}]
d = Take[s, {2, -1, 2}]
a = b = {};
Table[If[g[[i]] == 1, AppendTo[a, d[[i]]], AppendTo[b, d[[i]]]], {i,
Length@g}];
a
b
dice = RandomInteger[{1, 6}]
ra = Sort@RandomSample[Range@Length@a, dice]
a = {Delete[a, List /@ ra], a[[ra]]}
rb = Sort@RandomSample[Range@Length@b, dice]
b = {Delete[b, List /@ rb], b[[rb]]}
finala = Join[a[[1]], b[[2]]]
finalb = Join[b[[1]], a[[2]]]
Count[finala, 1] == Count[finalb, 0]</syntaxhighlight>
{{output}}
<pre>
{0,1,0,1,0,1,0,0,0,1,0,0,0,1,1,0,0,0,1,1,1,1,0,1,0,0,1,1,1,0,0,0,0,1,0,1,0,0,1,0,1,1,1,1,1,0,1,1,1,0,0,1} //shuffled deck
{0,0,0,0,0,0,0,1,0,1,1,0,0,1,1,0,0,0,0,1,1,1,1,1,1,0} // those are the key-cards
{1,1,1,0,1,0,1,0,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,1,0,1} //those are the cards that will form the 2 piles based on keys
{0,1,1,1,0,0,1,1,0,1,0} //this is pile A
{1,1,1,0,1,0,1,0,1,0,0,1,1,0,1} // this is pile B
4 //we throw a dice
{2,7,10,11} // we remove this 4 cards from pile A
{{0,1,1,0,0,1,0},{1,1,1,0}} // this is pile A split
{3,8,10,11} // we remove 4 cards from different positions of pile B
{{1,1,0,1,0,1,1,1,1,0,1},{1,0,0,0}} //here is pile B split
{0,1,1,0,0,1,0,1,0,0,0} //this is final A pile
{1,1,0,1,0,1,1,1,1,0,1,1,1,1,0} //this is final B pile
True // the result is TRUE
</pre>
=={{header|Nim}}==
{{trans|Kotlin}}
<syntaxhighlight lang="nim">import random, sequtils, strformat, strutils
type Color {.pure.} = enum Red = "R", Black = "B"
proc `$`(s: seq[Color]): string = s.join(" ")
# Create pack, half red, half black and shuffle it.
var pack = newSeq[Color](52)
for i in 0..51: pack[i] = Color(i < 26)
pack.shuffle()
# Deal from pack into 3 stacks.
var red, black, others: seq[Color]
for i in countup(0, 51, 2):
case pack[i]
of Red: red.add pack[i + 1]
of Black: black.add pack[i + 1]
others.add pack[i]
echo "After dealing the cards the state of the stacks is:"
echo &" Red: {red.len:>2} cards -> {red}"
echo &" Black: {black.len:>2} cards -> {black}"
echo &" Discard: {others.len:>2} cards -> {others}"
# Swap the same, random, number of cards between the red and black stacks.
let m = min(red.len, black.len)
let n = rand(1..m)
var rp = toSeq(0..red.high)
rp.shuffle()
rp.setLen(n)
var bp = toSeq(0..black.high)
bp.shuffle()
bp.setLen(n)
echo &"\n{n} card(s) are to be swapped.\n"
echo "The respective zero-based indices of the cards(s) to be swapped are:"
echo " Red : ", rp.join(" ")
echo " Black : ", bp.join(" ")
for i in 0..<n:
swap red[rp[i]], black[bp[i]]
echo "\nAfter swapping, the state of the red and black stacks is:"
echo " Red : ", red
echo " Black : ", black
# Check that the number of black cards in the black stack equals
# the number of red cards in the red stack.
let rcount = red.count(Red)
let bcount = black.count(Black)
echo ""
echo "The number of red cards in the red stack is ", rcount
echo "The number of black cards in the black stack is ", bcount
if rcount == bcount:
echo "So the asssertion is correct."
else:
echo "So the asssertion is incorrect."</syntaxhighlight>
{{out}}
<pre>After dealing the cards the state of the stacks is:
Red: 14 cards -> B B B B R R B B R B R R R B
Black: 12 cards -> R R R B R B B R B B R B
Discard: 26 cards -> B B R R R R B B B R R R R R B B B R R B R B R B B R
6 card(s) are to be swapped.
The respective zero-based indices of the cards(s) to be swapped are:
Red : 6 9 10 5 13 3
Black : 7 4 5 8 2 11
After swapping, the state of the red and black stacks is:
Red : B B B B R B R B R R B R R R
Black : R R B B B R B B R B R B
The number of red cards in the red stack is 7
The number of black cards in the black stack is 7
So the asssertion is correct.</pre>
=={{header|Perl}}==
Trying several non-random deck orderings, in addition to a shuffled one. Predictably, the trick always works.
{{trans|
<
my(@deck) = @_;
my $result .= sprintf "%-28s @deck\n", 'Starting deck:';
Line 689 ⟶ 2,093:
print trick(@deck);
@deck = sort { -1 + 2*int(rand 2) } @deck; # poor man's shuffle
print trick(@deck);</
{{out}}
<pre>Starting deck: R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B R B
Line 719 ⟶ 2,123:
Red in Red, Black in Black: 7 = 7</pre>
=={{header|
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">52</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">pack</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'r'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)&</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'b'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">black</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">red</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">discard</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pack</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">top</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">pack</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span>
<span style="color: #000000;">next</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">pack</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">top</span><span style="color: #0000FF;">==</span><span style="color: #008000;">'b'</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">black</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">next</span>
<span style="color: #008080;">else</span>
<span style="color: #000000;">red</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">next</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">discard</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">top</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">black</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">black</span><span style="color: #0000FF;">);</span> <span style="color: #000000;">red</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">red</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (optional)
--printf(1,"Discards : %s\n",{discard})</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;">"Reds : %s\nBlacks : %s\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">red</span><span style="color: #0000FF;">,</span><span style="color: #000000;">black</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">lb</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">black</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">lr</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">red</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">ns</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">min</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lb</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lr</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;">"Swap %d cards:\n\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ns</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">b1ns</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">black</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">ns</span><span style="color: #0000FF;">],</span>
<span style="color: #000000;">r1ns</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">red</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">ns</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">black</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">ns</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">r1ns</span>
<span style="color: #000000;">red</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">ns</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">b1ns</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;">"Reds : %s\nBlacks : %s\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">red</span><span style="color: #0000FF;">,</span><span style="color: #000000;">black</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">nb</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_eq</span><span style="color: #0000FF;">(</span><span style="color: #000000;">black</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'b'</span><span style="color: #0000FF;">)),</span>
<span style="color: #000000;">nr</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_eq</span><span style="color: #0000FF;">(</span><span style="color: #000000;">red</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'r'</span><span style="color: #0000FF;">))</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">correct</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nr</span><span style="color: #0000FF;">==</span><span style="color: #000000;">nb</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"correct"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"**INCORRECT**"</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;">"%d r in red, %d b in black - assertion %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">nr</span><span style="color: #0000FF;">,</span><span style="color: #000000;">nb</span><span style="color: #0000FF;">,</span><span style="color: #000000;">correct</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Reds : brrbrrrrbrbr
Blacks : brrrbbbrbbbbrr
Swap 5 cards:
Reds : brrrbrrrbrbr
Blacks : brrbrbbrbbbbrr
8 r in red, 8 b in black - assertion correct
</pre>
=={{header|Python}}==
The code is layed out to follow the task decription, leading to some deviations from the PEP8 ''guidelines''
<
## 1. Cards
Line 830 ⟶ 2,223:
print('Yeha! The mathematicians assertion is correct.')
else:
print('Whoops - The mathematicians (or my card manipulations) are flakey')</
A run.
Line 845 ⟶ 2,238:
Swapping 2
Yeha! The mathematicians assertion is correct.</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ stack ] is discards ( --> s )
[ stack ] is red-card ( --> s )
[ stack ] is black-card ( --> s )
[ dup take rot join swap put ] is to-pile ( n s --> )
[ $ "" discards put
$ "" red-card put
$ "" black-card put
char R 26 of
char B 26 of join shuffle
26 times
[ behead tuck discards to-pile
behead rot char R =
iff red-card else black-card
to-pile ]
drop
discards take witheach
[ emit sp ] cr
red-card take shuffle
black-card take shuffle
over size over size min random
say "Swapping " dup echo
say " cards." cr
dup dip [ split rot ] split
dip join rot join
0 swap witheach
[ char R = + ]
0 rot witheach
[ char B = + ]
say "The assertion is "
= iff [ say "true." ]
else [ say "false." ] cr cr ] is task ( --> )
5 times task</syntaxhighlight>
{{out}}
<pre>B R R R B B R B B B R R B R R B B B R B B R B R R B
Swapping 2 cards.
The assertion is true.
B R B R B B B B R B B B R R R R B B R R B R B B B B
Swapping 4 cards.
The assertion is true.
B B R R R B R B B R B R R B R B R B B B R B R R B R
Swapping 3 cards.
The assertion is true.
B B B R R R R R B R B B R B R B B R R R R R R R B B
Swapping 8 cards.
The assertion is true.
B R B B B R R R R R B R B B R R B B B R R R R R B R
Swapping 5 cards.
The assertion is true.</pre>
=={{header|R}}==
<syntaxhighlight lang="r">
magictrick<-function(){
deck=c(rep("B",26),rep("R",26))
deck=sample(deck,52)
blackpile=character(0)
redpile=character(0)
discardpile=character(0)
while(length(deck)>0){
if(deck[1]=="B"){
blackpile=c(blackpile,deck[2])
deck=deck[-2]
}else{
redpile=c(redpile,deck[2])
deck=deck[-2]
}
discardpile=c(discardpile,deck[1])
deck=deck[-1]
}
cat("After the deal the state of the piles is:","\n",
"Black pile:",blackpile,"\n","Red pile:",redpile,"\n",
"Discard pile:",discardpile,"\n","\n")
X=sample(1:min(length(redpile),length(blackpile)),1)
if(X==1){s=" is"}else{s="s are"}
cat(X," card",s," being swapped.","\n","\n",sep="")
redindex=sample(1:length(redpile),X)
blackindex=sample(1:length(blackpile),X)
redbunch=redpile[redindex]
redpile=redpile[-redindex]
blackbunch=blackpile[blackindex]
blackpile=blackpile[-blackindex]
redpile=c(redpile,blackbunch)
blackpile=c(blackpile,redbunch)
cat("After the swap the state of the piles is:","\n",
"Black pile:",blackpile,"\n","Red pile:",redpile,"\n","\n")
cat("There are ", length(which(blackpile=="B")), " black cards in the black pile.","\n",
"There are ", length(which(redpile=="R")), " red cards in the red pile.","\n",sep="")
if(length(which(blackpile=="B"))==length(which(redpile=="R"))){
cat("The assertion is true!")
}
}
</syntaxhighlight>
{{Out}}
<pre>
After the deal the state of the piles is:
Black pile: B B R R B R B R R B B
Red pile: R B B B B B R B R R R B R B B
Discard pile: R R R R B R R R B R R B R B R R B R B R B B B R B B
10 cards are being swapped.
After the swap the state of the piles is:
Black pile: R B B B B R R R R B R
Red pile: B B R B B B R B B B B R B R R
There are 5 black cards in the black pile.
There are 5 red cards in the red pile.
The assertion is true!
</pre>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2018.08}}
<syntaxhighlight lang="raku" line># Generate a shuffled deck
my @deck = shuffle;
put 'Shuffled deck: ', @deck;
my (@discard, @red, @black);
# Deal cards following task description
deal(@deck, @discard, @red, @black);
put 'Discard pile: ', @discard;
put '"Red" pile: ', @red;
put '"Black" pile: ', @black;
# swap the same random number of random
# cards between the red and black piles
my $amount = ^(+@red min +@black) .roll;
put 'Number of cards to swap: ', $amount;
swap(@red, @black, $amount);
put 'Red pile after swaps: ', @red;
put 'Black pile after swaps: ', @black;
say 'Number of Red cards in the Red pile: ', +@red.grep('R');
say 'Number of Black cards in the Black pile: ', +@black.grep('B');
sub shuffle { (flat 'R' xx 26, 'B' xx 26).pick: * }
sub deal (@deck, @d, @r, @b) {
while @deck.elems {
my $top = @deck.shift;
if $top eq 'R' {
@r.push: @deck.shift;
}
else {
@b.push: @deck.shift;
}
@d.push: $top;
}
}
sub swap (@r, @b, $a) {
my @ri = ^@r .pick($a);
my @bi = ^@b .pick($a);
my @rs = @r[@ri];
my @bs = @b[@bi];
@r[@ri] = @bs;
@b[@bi] = @rs;
}</syntaxhighlight>
{{out|Sample output}}
<pre>Shuffled deck: B B B R B R R R B B R R R B R B R B R R R B R B B R R B B R R B R B R R R R B R R B B B B B B R R B B B
Discard pile: B B B R B R R R R R R R B R B R R R R B R B B B R B
"Red" pile: R R B B B R B B B B B R R B B
"Black" pile: B R R B R R R B B R B
Number of cards to swap: 6
Red pile after swaps: R R B B R R R R B B B R B B B
Black pile after swaps: B R B R R B B B B R B
Number of Red cards in the Red pile: 7
Number of Black cards in the Black pile: 7</pre>
=={{header|REXX}}==
Line 867 ⟶ 2,442:
Extra coding was added to keep ''singularities'' (opposite of a plural) to keep the English gooder (''sic''), as well as
<br>adding commas to larger numbers.
<
parse arg trials # shuffs seed . /*obtain optional arguments from the CL*/
if trials=='' | trials=="," then trials= 1000 /*Not specified? Then use the default.*/
Line 916 ⟶ 2,491:
/*"blacks" " " " */ Bc= Bc word(B, B?); B= delword(B, B?, 1) /* " " */
end /*?($)*/
R=R Bc; B=B Rc; return /*add swapped cards to piles.*/</
{{out|output|text= when using the default inputs:}}
<pre>
Correctness of the mathematician's assertion: 100% (out of 10,000 trials) using a deck of 52 cards, and doing 13 shuffles.
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">deck = ([:black, :red] * 26 ).shuffle
black_pile, red_pile, discard = [], [], []
until deck.empty? do
discard << deck.pop
discard.last == :black ? black_pile << deck.pop : red_pile << deck.pop
end
x = rand( [black_pile.size, red_pile.size].min )
red_bunch = x.times.map{ red_pile.delete_at( rand( red_pile.size )) }
black_bunch = x.times.map{ black_pile.delete_at( rand( black_pile.size )) }
black_pile += red_bunch
red_pile += black_bunch
puts "The magician predicts there will be #{black_pile.count( :black )} red cards in the other pile.
Drumroll...
There were #{red_pile.count( :red )}!"
</syntaxhighlight>
{{out}}
<pre>The magician predicts there will be 5 red cards in the other pile.
Drumroll...
There were 5!
</pre>
=={{header|Rust}}==
{{libheader|rand}}
<
use rand::Rng;
use std::iter::repeat;
Line 983 ⟶ 2,585:
println!("Number of black cards in black stack: {}", num_black);
println!("Number of red cards in red stack: {}", num_red);
}</
{{out}}
Line 990 ⟶ 2,592:
Number of black cards in black stack: 4
Number of red cards in red stack: 4</pre>
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "random" for Random
import "./fmt" for Fmt
var R = 82 // ASCII 'R'
var B = 66 // ASCII 'B'
// Create pack, half red, half black and shuffle it.
var pack = [0] * 52
for (i in 0..25) {
pack[i] = R
pack[26+i] = B
}
var rand = Random.new()
rand.shuffle(pack)
// Deal from pack into 3 stacks.
var red = []
var black = []
var discard = []
var i = 0
while (i < 51) {
if (pack[i] == B) {
black.add(pack[i+1])
} else {
red.add(pack[i+1])
}
discard.add(pack[i])
i = i + 2
}
var lr = red.count
var lb = black.count
var ld = discard.count
System.print("After dealing the cards the state of the stacks is:")
Fmt.print(" Red : $2d cards -> $c", lr, red)
Fmt.print(" Black : $2d cards -> $c", lb, black)
Fmt.print(" Discard: $2d cards -> $c", ld, discard)
// Swap the same, random, number of cards between the red and black stacks.
var min = (lr < lb) ? lr : lb
var n = rand.int(1, min + 1)
var rp = [0] * lr
var bp = [0] * lb
for (i in 0...lr) rp[i] = i
for (i in 0...lb) bp[i] = i
rand.shuffle(rp)
rand.shuffle(bp)
rp = rp[0...n]
bp = bp[0...n]
System.print("\n%(n) card(s) are to be swapped.\n")
System.print("The respective zero-based indices of the cards(s) to be swapped are:")
Fmt.print(" Red : $2d", rp)
Fmt.print(" Black : $2d", bp)
for (i in 0...n) {
var t = red[rp[i]]
red[rp[i]] = black[bp[i]]
black[bp[i]] = t
}
System.print("\nAfter swapping, the state of the red and black stacks is:")
Fmt.print(" Red : $c", red)
Fmt.print(" Black : $c", black)
// Check that the number of black cards in the black stack equals
// the number of red cards in the red stack.
var rcount = red.count { |c| c == R }
var bcount = black.count { |c| c == B }
System.print("\nThe number of red cards in the red stack = %(rcount)")
System.print("The number of black cards in the black stack = %(bcount)")
if (rcount == bcount) {
System.print("So the asssertion is correct!")
} else {
System.print("So the asssertion is incorrect!")
}</syntaxhighlight>
{{out}}
<pre>
After dealing the cards the state of the stacks is:
Red : 12 cards -> B R R B R R R R R R R B
Black : 14 cards -> B R B B B R B B R R B B R B
Discard: 26 cards -> R R R B B B B R B R R R R B R B B B R B B B B R R B
11 card(s) are to be swapped.
The respective zero-based indices of the cards(s) to be swapped are:
Red : 0 11 6 8 3 9 1 7 10 5 2
Black : 2 3 0 4 5 10 12 6 13 8 11
After swapping, the state of the red and black stacks is:
Red : B R B R R R B B B B B B
Black : R R B B R B R B R R R R R R
The number of red cards in the red stack = 4
The number of black cards in the black stack = 4
So the asssertion is correct!
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">include xpllib; \for Print
char Deck(52), BlackPile(52), RedPile(52), DiscardPile(52),
BlackBunch(52), RedBunch(52);
int I, J, T, M, X, Y, BP, RP, DP, BB, RB, BC, RC;
proc Show;
[Print("Black pile: ");
for I:= 0 to BP-1 do ChOut(0, BlackPile(I));
Print("\nRed pile: ");
for I:= 0 to RP-1 do ChOut(0, RedPile(I));
Print("\nDiscard pile: ");
for I:= 0 to DP-1 do ChOut(0, DiscardPile(I));
Print("\n");
];
[for I:= 0 to 26-1 do
[Deck(I):= ^r; Deck(I+26):= ^b];
for I:= 0 to 52-1 do
[Y:= Ran(52); \0..51
T:= Deck(I); Deck(I):= Deck(Y); Deck(Y):= T;
];
BP:= 0; RP:= 0; DP:= 0;
for I:= 0 to 52-1 do
[if Deck(I) = ^b then
[BlackPile(BP):= Deck(I+1); BP:= BP+1]
else
[RedPile (RP):= Deck(I+1); RP:= RP+1];
DiscardPile(DP):= Deck(I); DP:= DP+1;
I:= I+1;
];
Show;
M:= BP;
if RP < M then M:= RP;
X:= Ran(M) + 1;
Print("Swap %d cards between the red and black piles.\n", X);
RB:= 0; BB:= 0;
for I:= 0 to X-1 do
[repeat Y:= Ran(RP); until RedPile(Y) # 0;
RedBunch(RB):= RedPile(Y); RB:= RB+1; RedPile(Y):= 0;
];
for I:= 0 to X-1 do
[repeat Y:= Ran(BP); until BlackPile(Y) # 0;
BlackBunch(BB):= BlackPile(Y); BB:= BB+1; BlackPile(Y):= 0;
];
RB:= 0;
for I:= 0 to X-1 do
[J:= 0;
while BlackPile(J) # 0 do J:= J+1;
BlackPile(J):= RedBunch(RB); RB:= RB+1;
];
BB:= 0;
for I:= 0 to X-1 do
[J:= 0;
while RedPile(J) # 0 do J:= J+1;
RedPile(J):= BlackBunch(BB); BB:= BB+1;
];
Show;
BC:= 0;
for I:= 0 to BP-1 do
if BlackPile(I) = ^b then BC:= BC+1;
RC:= 0;
for I:= 0 to RP-1 do
if RedPile(I) = ^r then RC:= RC+1;
Print("The number of black cards in the black pile is %d.\n", BC);
Print("The number of red cards in the red pile is %d.\n", RC);
Print("The mathematician's assertion is%s correct.\n",
if BC#RC then " not" else "");
]</syntaxhighlight>
{{out}}
<pre>
Black pile: rrrrrbbbrbbbr
Red pile: brrrbbbrrrbbb
Discard pile: brrrrrbbbbrbrrbrbbrbbrbrbr
Swap 11 cards between the red and black piles.
Black pile: bbrrbbbbrbrbr
Red pile: brbrrrrrbrbbr
Discard pile: brrrrrbbbbrbrrbrbbrbbrbrbr
The number of black cards in the black pile is 8.
The number of red cards in the red pile is 8.
The mathematician's assertion is correct.
</pre>
=={{header|zkl}}==
<
stacks:=T(List(),List()); // black stack [0], red stack [1]
blkStk,redStk := stacks;
Line 1,009 ⟶ 2,793:
else println("Boo, different stack lenghts");
fcn redBlack(cards){ cards.pump(String,fcn(c){ c and "R " or "B " }) }</
{{out}}
<pre>
| |||