Mind boggling card trick: Difference between revisions
Added Easylang
m (→{{header|Phix}}: added syntax colouring, made p2js compatible) |
(Added Easylang) |
||
| (14 intermediate revisions by 9 users not shown) | |||
Line 36:
{{trans|Python}}
<
V n = 52
V Black = ‘Black’
Line 73:
print(‘Yeha! The mathematicians assertion is correct.’)
E
print(‘Whoops - The mathematicians (or my card manipulations) are flakey’)</
{{out}}
Line 84:
=={{header|AppleScript}}==
<
use framework "Foundation"
use framework "GameplayKit" -- For randomising functions.
Line 175:
return text 1 thru -2 of join(output, linefeed)
end task
return task()</
{{output}}
<
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♦️
Line 206:
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♦️"</
=={{header|AutoHotkey}}==
<
; create cards
cards := [], suits := ["♠","♥","♦","♣"], num := 0
Line 334:
SB_SetText(countB " Face Down Black Cards", 2)
return
;==========================================================</
=={{header|C}}==
<
#include <stdlib.h>
#include <stdint.h>
Line 467:
return 0;
}</
{{out}}
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}}==
{{trans|Ruby}}
<
black_pile, red_pile, discard = [] of Symbol, [] of Symbol, [] of Symbol
Line 513 ⟶ 761:
puts "The magician predicts there will be #{black_pile.count( :black )} red cards in the other pile.
Drumroll...
There were #{red_pile.count( :red )}!"</
{{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()
Line 528 ⟶ 862:
printf "A well shuffled deck -> "; List.iter (printf "%s ") fN; printfn ""
fN |> List.chunkBySize 2 |> List.groupBy List.head |> List.iter(fun(n,n')->printfn "The %s pile contains %s" n (fG n'))
</syntaxhighlight>
{{out}}
<pre>
Line 537 ⟶ 871:
=={{header|Factor}}==
<
generalizations io kernel math math.ranges random sequences
sequences.extras ;
Line 589 ⟶ 923:
test-assertion ; ! step 4
MAIN: main</
A run:
{{out}}
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}}==
<
import (
Line 721 ⟶ 1,174:
fmt.Println("So the asssertion is incorrect!")
}
}</
{{out}}
Line 769 ⟶ 1,222:
=={{header|Haskell}}==
<
import Data.List (partition)
import Data.Monoid ((<>))
Line 836 ⟶ 1,289:
replaceAt i c l =
let (a, b) = splitAt i l
in a ++ c : drop 1 b</
{{Out}}
<pre>Discarded: RRRRRBBBBBRBBBRBBRBRRBRRRB
Line 848 ⟶ 1,301:
=={{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
</
We find that in three runs the trick works.
<syntaxhighlight lang="j">
shuffle =: {~ ?~@:#
f =: (,&.> {:)~
Line 903 ⟶ 1,356:
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 1,068 ⟶ 1,631:
// MAIN ---
return main();
})();</
{{Out}}
<pre>Discarded: BRBRBRRRRBBBRBBBRBBBBBRRBR
Line 1,080 ⟶ 1,643:
=={{header|Julia}}==
{{trans|Raku}}
<syntaxhighlight lang="julia">using Random
const rbdeck = split(repeat('R', 26) * repeat('B', 26), "")
shuffledeck() = shuffle(rbdeck)
Line 1,131 ⟶ 1,696:
mindbogglingcardtrick(false)
end
</
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",
Line 1,170 ⟶ 1,735:
=={{header|Kotlin}}==
{{trans|Go}}
<
import java.util.Random
Line 1,231 ⟶ 1,796:
println("So the asssertion is incorrect!")
}
}</
{{output}}
Line 1,277 ⟶ 1,842:
So the asssertion is correct!
</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}}==
<
g = Take[s, {1, -1, 2}]
d = Take[s, {2, -1, 2}]
Line 1,294 ⟶ 1,951:
finala = Join[a[[1]], b[[2]]]
finalb = Join[b[[1]], a[[2]]]
Count[finala, 1] == Count[finalb, 0]</
{{output}}
Line 1,316 ⟶ 1,973:
=={{header|Nim}}==
{{trans|Kotlin}}
<
type Color {.pure.} = enum Red = "R", Black = "B"
Line 1,368 ⟶ 2,025:
echo "So the asssertion is correct."
else:
echo "So the asssertion is incorrect."</
{{out}}
Line 1,393 ⟶ 2,050:
Trying several non-random deck orderings, in addition to a shuffled one. Predictably, the trick always works.
{{trans|Raku}}
<
my(@deck) = @_;
my $result .= sprintf "%-28s @deck\n", 'Starting deck:';
Line 1,436 ⟶ 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 1,467 ⟶ 2,124:
=={{header|Phix}}==
<!--<
<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>
Line 1,502 ⟶ 2,159:
<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>
<!--</
{{out}}
<pre>
Line 1,518 ⟶ 2,175:
=={{header|Python}}==
The code is layed out to follow the task decription, leading to some deviations from the PEP8 ''guidelines''
<
## 1. Cards
Line 1,566 ⟶ 2,223:
print('Yeha! The mathematicians assertion is correct.')
else:
print('Whoops - The mathematicians (or my card manipulations) are flakey')</
A run.
Line 1,581 ⟶ 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))
Line 1,623 ⟶ 2,340:
}
}
</syntaxhighlight>
{{Out}}
<pre>
Line 1,646 ⟶ 2,363:
{{works with|Rakudo|2018.08}}
<syntaxhighlight lang="raku"
my @deck = shuffle;
put 'Shuffled deck: ', @deck;
Line 1,692 ⟶ 2,409:
@r[@ri] = @bs;
@b[@bi] = @rs;
}</
{{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
Line 1,725 ⟶ 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 1,774 ⟶ 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>
Line 1,781 ⟶ 2,498:
=={{header|Ruby}}==
<
black_pile, red_pile, discard = [], [], []
Line 1,800 ⟶ 2,517:
Drumroll...
There were #{red_pile.count( :red )}!"
</syntaxhighlight>
{{out}}
<pre>The magician predicts there will be 5 red cards in the other pile.
Line 1,809 ⟶ 2,526:
=={{header|Rust}}==
{{libheader|rand}}
<
use rand::Rng;
use std::iter::repeat;
Line 1,868 ⟶ 2,585:
println!("Number of black cards in black stack: {}", num_black);
println!("Number of red cards in red stack: {}", num_red);
}</
{{out}}
Line 1,879 ⟶ 2,596:
{{trans|Go}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
var R = 82 // ASCII 'R'
Line 1,950 ⟶ 2,667:
} else {
System.print("So the asssertion is incorrect!")
}</
{{out}}
Line 1,972 ⟶ 2,689:
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,992 ⟶ 2,793:
else println("Boo, different stack lenghts");
fcn redBlack(cards){ cards.pump(String,fcn(c){ c and "R " or "B " }) }</
{{out}}
<pre>
| |||