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}}==

use framework "Foundation"

use framework "GameplayKit" -- For randomising functions.

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

end 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♦️

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♥️

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

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

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

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

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

=={{header|Lua}}==

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

-- demo:

math.randomseed(os.time())

{{out}}

<pre>1. DECK : RBBBRBRBRBBBBRRRRBRBBBRRBRRBRRBRBBRRBBRRBBRRRBBRBRBR

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

<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: #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>

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

=={{header|Quackery}}==

[ stack ] is red-card ( --> s )

[ stack ] is black-card ( --> s )

else [ say "false." ] cr cr ] is task ( --> )

{{out}}

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

import "/fmt" for Fmt

} else {

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

{{out}}

=={{header|zkl}}==

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

blkStk,redStk := stacks;

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

{{out}}

<pre>