Mind boggling card trick: Difference between revisions
→{{header|jq}}
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
| (10 intermediate revisions by 7 users not shown) | |||
Line 492:
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}}==
Line 518 ⟶ 766:
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>
Line 642 ⟶ 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}}==
Line 904 ⟶ 1,357:
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}}==
Line 1,077 ⟶ 1,640:
BBBBBBBB = Black cards in the black pile
true</pre>
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
'''Works with jq, the C implementation of jq'''
'''Works with gojq, the Go implementation of jq'''
Since jq does not include a PRN generator, an external source of entropy such as /dev/urandom is assumed.
A suitable invocation of jq would be along the lines of:
<pre>
< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -nr trick.jq
</pre>
<syntaxhighlight lang="jq">
### Generic utilities
def count(s): reduce s as $x (0; . + 1);
def lpad($len): tostring | ($len - length) as $l | (" " * $l) + .;
### Pseuo-random numbers
# Output: a prn in range(0;$n) where $n is `.`
def prn:
if . == 1 then 0
else . as $n
| ([1, (($n-1)|tostring|length)]|max) as $w
| [limit($w; inputs)] | join("") | tonumber
| if . < $n then . else ($n | prn) end
end;
def sample:
if length == 0 # e.g. null or []
then null
else .[length|prn]
end;
def knuthShuffle:
length as $n
| if $n <= 1 then .
else {i: $n, a: .}
| until(.i == 0;
.i += -1
| (.i + 1 | prn) as $j
| .a[.i] as $t
| .a[.i] = .a[$j]
| .a[$j] = $t)
| .a
end;
### Cards
def R: "R"; # 82 ASCII
def B: "B"; # 66 ASCII
# Create deck, half red, half black and shuffle it.
def deck:
([range(0;26)|R] + [range(0;26)|B]) | knuthShuffle;
# Deal from `deck` into three stacks: {black, red, discard}
def deal:
deck as $deck
| reduce range(0; 51; 2) as $i (.;
if $deck[$i] == B
then .black += [$deck[$i+1]]
else .red += [$deck[$i+1]]
end
| .discard += [$deck[$i]] );
def proceed:
def p: join(" ");
(.red|length) as $lr
| (.black|length) as $lb
| (.discard|length) as $ld
| def displayStacks($discard):
" Red : \($lr|lpad(2)) cards -> \(.red|p)",
" Black : \($lb|lpad(2)) cards -> \(.black|p)",
(select($discard)
| " Discard: \($ld) cards -> \(.discard|p)") ;
# Input: {red, black}
def swap($n):
. + { rp: ([range(0; $lr)] | knuthShuffle[0:$n] ),
bp: ([range(0; $lb)] | knuthShuffle[0:$n]) }
| reduce range(0;$n) as $i (.;
.red[.rp[$i]] as $t
| .red[.rp[$i]] = .black[.bp[$i]]
| .black[.bp[$i]] = $t);
def epilog:
# Check that the number of black cards in the black stack equals
# the number of red cards in the red stack:
count(select(.red[] == R)) as $rcount
| count(select(.black[] == B)) as $bcount
| "\nThe number of red cards in the red stack = \($rcount)",
"The number of black cards in the black stack = \($bcount)",
if $rcount == $bcount
then "So the assertion is correct!"
else "So the assertion is incorrect!"
end;
"After dealing the cards, the stacks are as follows:",
displayStacks(true),
# Swap the same, random, number of cards between the red and black stacks.
( (if $lr < $lb then $lr else $lb end) as $min
| (($min - 1|prn) + 1) as $n
| swap($n)
| "\n\($n) card(s) are to be swapped.",
"The respective zero-based indices of the cards to be swapped are:",
" Red : \(.rp|map(lpad(3))|p)",
" Black : \(.bp|map(lpad(3))|p)",
"\nAfter swapping, the red and black stacks are as follows:",
displayStacks(false),
epilog ) ;
deal | proceed
</syntaxhighlight>
{{output}}
<pre>
After dealing the cards, the stacks are as follows:
Red : 12 cards -> R B R R B B B R R B R B
Black : 14 cards -> R B B R B R R R B R B R B R
Discard: 26 cards -> R R B B B R B R B R R B B B R B R B R B B B R B R R
1 card(s) are to be swapped.
The respective zero-based indices of the cards to be swapped are:
Red : 6
Black : 5
After swapping, the red and black stacks are as follows:
Red : 12 cards -> R B R R B B R R R B R B
Black : 14 cards -> R B B R B B R R B R B R B R
The number of red cards in the red stack = 7
The number of black cards in the black stack = 7
So the assertion is correct!
</pre>
=={{header|Julia}}==
{{trans|Raku}}
<syntaxhighlight lang="julia">
const rbdeck = split(repeat('R', 26) * repeat('B', 26), "")
shuffledeck() = shuffle(rbdeck)
Line 2,031 ⟶ 2,736:
{{trans|Go}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="
import "./fmt" for Fmt
var R = 82 // ASCII 'R'
Line 2,124 ⟶ 2,829:
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>
| |||