Mind boggling card trick: Difference between revisions

{{trans|Python}}

 

V n = 52

V Black = ‘Black’

print(‘Yeha! The mathematicians assertion is correct.’)

E

 

{{out}}

 

=={{header|AppleScript}}==

set suits to {"♥️", "♣️", "♦️", "♠️"}

set cards to {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"}

end repeat

end repeat

set {blackPile, redPile, discardPile} to {{}, {}, {}}

repeat with c from 1 to (count deck) by 2

set end of discardPile to topCard

end repeat

set {redBunch, blackBunch} to {{}, {}}

repeat X times

end repeat

set blackPile to (blackPile's text) & redBunch

set redPile to (redPile's text) & blackBunch

set blacksInBlackPile to 0

repeat with card in blackPile

return {truth:(blacksInBlackPile = redsInRedPile), reds:redPile, blacks:blackPile, discards:discardPile}

end cardTrick

 

on join(lst, delim)

on task()

set output to {}

set {truth:truth, reds:reds, blacks:blacks, discards:discards} to cardTrick()

set end of output to "Test " & i & ": Assertion is " & truth

return text 1 thru -2 of join(output, linefeed)

end task

 

{{output}}

 

Test 2: Assertion is true

 

Test 3: Assertion is true

 

Test 4: Assertion is true

 

Test 5: Assertion is true

 

=={{header|AutoHotkey}}==

; create cards

cards := [], suits := ["♠","♥","♦","♣"], num := 0

SB_SetText(countB " Face Down Black Cards", 2)

return

 

=={{header|C}}==

#include <stdlib.h>

#include <stdint.h>

return 0;

 

{{out}}

 

Result: 5 successes out of 5 simulations</pre>

 

=={{header|Crystal}}==

{{trans|Ruby}}

black_pile, red_pile, discard = [] of Symbol, [] of Symbol, [] of Symbol

 

puts "The magician predicts there will be #{black_pile.count( :black )} red cards in the other pile.

Drumroll...

{{out}}

<pre>The magician predicts there will be 7 red cards in the other pile.

Drumroll...

There were 7!

</pre>

 

=={{header|F_Sharp|F#}}==

//Be boggled? Nigel Galloway: September 19th., 2018

let N=System.Random()

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'))

{{out}}

<pre>

 

=={{header|Factor}}==

generalizations io kernel math math.ranges random sequences

sequences.extras ;

test-assertion ; ! step 4

 

A run:

{{out}}

B in black: 5

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println("So the asssertion is incorrect!")

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (partition)

import Data.Monoid ((<>))

replaceAt i c l =

let (a, b) = splitAt i l

{{Out}}

<pre>Discarded: RRRRRBBBBBRBBBRBBRBRRBRRRB

=={{header|J}}==

The trick verb returns 0 if the magician's proposition fails, otherwise 1.

NB. A failed assertion looks like this

assert 0

|assertion failure: assert

| assert 0

We find that in three runs the trick works.

shuffle =: {~ ?~@:#

f =: (,&.> {:)~

black pile BrrBrrrBBrr

red pile rBrBrBBrBBBBBBB

 

=={{header|Javascript}}==

{{trans|Haskell}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Discarded: BRBRBRRRRBBBRBBBRBBBBBRRBR

BBBBBBBB = Black cards in the black pile

true</pre>

 

=={{header|Julia}}==

{{trans|Raku}}

shuffledeck() = shuffle(rbdeck)

 

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",

=={{header|Kotlin}}==

{{trans|Go}}

 

import java.util.Random

println("So the asssertion is incorrect!")

}

 

{{output}}

So the asssertion is correct!

</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

g = Take[s, {1, -1, 2}]

d = Take[s, {2, -1, 2}]

finala = Join[a[[1]], b[[2]]]

finalb = Join[b[[1]], a[[2]]]

 

{{output}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

type Color {.pure.} = enum Red = "R", Black = "B"

echo "So the asssertion is correct."

else:

 

{{out}}

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:';

print trick(@deck);

@deck = sort { -1 + 2*int(rand 2) } @deck; # poor man's shuffle

{{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

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|Python}}==

The code is layed out to follow the task decription, leading to some deviations from the PEP8 ''guidelines''

 

## 1. Cards

print('Yeha! The mathematicians assertion is correct.')

else:

 

A run.

Swapping 2

Yeha! The mathematicians assertion is correct.</pre>

 

=={{header|R}}==

magictrick<-function(){

deck=c(rep("B",26),rep("R",26))

}

}

{{Out}}

<pre>

{{works with|Rakudo|2018.08}}

 

my @deck = shuffle;

put 'Shuffled deck: ', @deck;

@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

Extra coding was added to keep ''singularities'' &nbsp; (opposite of a plural) &nbsp; to keep the English gooder (''sic''), &nbsp; 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.*/

/*"blacks" " " " */ Bc= Bc word(B, B?); B= delword(B, B?, 1) /* " " */

end /*?($)*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ruby}}==

black_pile, red_pile, discard = [], [], []

 

Drumroll...

There were #{red_pile.count( :red )}!"

{{out}}

<pre>The magician predicts there will be 5 red cards in the other pile.

=={{header|Rust}}==

{{libheader|rand}}

use rand::Rng;

use std::iter::repeat;

println!("Number of black cards in black stack: {}", num_black);

println!("Number of red cards in red stack: {}", num_red);

 

{{out}}

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var R = 82 // ASCII 'R'

} else {

System.print("So the asssertion is incorrect!")

 

{{out}}

The number of black cards in the black stack = 4

So the asssertion is correct!

</pre>

 

=={{header|zkl}}==

stacks:=T(List(),List()); // black stack [0], red stack [1]

blkStk,redStk := stacks;

else println("Boo, different stack lenghts");

 

{{out}}

<pre>