Mind boggling card trick: Difference between revisions

Show output on this page.

<br><br>

 

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

 

=={{header|Julia}}==

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

</pre>

 

 

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

True // the result is TRUE

</pre>

 

=={{header|Perl}}==

Trying several non-random deck orderings, in addition to a shuffled one. Predictably, the trick always works.

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

Number of black cards in black stack: 4

Number of red cards in red stack: 4</pre>

 

=={{header|zkl}}==

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

blkStk,redStk := stacks;

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

 

{{out}}

<pre>