Non-transitive dice: Difference between revisions

 

=={{header|ALGOL 68}}==

PROC iterate = (PROC(INT, []INT)VOID f)VOID:

BEGIN

FI

OD

{{out}}

<pre>3 dice:

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

===The task (4 sided die)===

// Non-transitive dice. Nigel Galloway: August 9th., 2020

let die=[for n0 in [1..4] do for n1 in [n0..4] do for n2 in [n1..4] do for n3 in [n2..4]->[n0;n1;n2;n3]]

let n4=seq{for d1 in die do for d2 in N.[d1] do for d3 in N.[d2] do for d4 in N.[d3] do if List.contains d1 N.[d4] then yield (d1,d2,d3,d4)}

n3|>Seq.iter(fun(d1,d2,d3)->printfn "%A<%A; %A<%A; %A>%A\n" d1 d2 d2 d3 d1 d3)

{{out}}

<pre>

===Extra credit (6 sided die)===

;Sides numbered 1..6

// Non-transitive diceNigel Galloway: August 9th., 2020

let die=[for n0 in [1..6] do for n1 in [n0..6] do for n2 in [n1..6] do for n3 in [n2..6] do for n4 in [n3..6] do for n5 in [n4..6]->[n0;n1;n2;n3;n4;n5]]

let n3=[for d1 in die do for d2 in N.[d1] do for d3 in N.[d2] do if List.contains d1 N.[d3] then yield (d1,d2,d3)]

let d1,d2,d3=List.last n3 in printfn "Solutions found = %d\nLast solution found is %A<%A; %A<%A; %A>%A" (n3.Length) d1 d2 d2 d3 d1 d3

{{out}}

<pre>

</pre>

;Sides numbered 1..7

// Non-transitive diceNigel Galloway: August 9th., 2020

let die=[for n0 in [1..7] do for n1 in [n0..7] do for n2 in [n1..7] do for n3 in [n2..7] do for n4 in [n3..7] do for n5 in [n4..7]->[n0;n1;n2;n3;n4;n5]]

let n3=[for d1 in die do for d2 in N.[d1] do for d3 in N.[d2] do if List.contains d1 N.[d3] then yield (d1,d2,d3)]

let d1,d2,d3=List.last n3 in printfn "Solutions found = %d\nLast solution found is %A<%A; %A<%A; %A>%A" (n3.Length) d1 d2 d2 d3 d1 d3

{{out}}

<pre>

 

=={{header|Factor}}==

prettyprint sequences ;

 

 

"All ordered lists of 4 non-transitive dice with 4 sides:" print

{{out}}

<pre>

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Println(a)

}

 

{{out}}

=={{header|Haskell}}==

 

import Data.List

import Control.Monad

(a:as) <- go (n-1)

b <- filter (< a) dice

 

<pre>*Main> mapM_ print $ nonTrans (dices 4) 3

 

Implementation (rotations of results here are also solutions):

udice=: {{ 1+~./:~"1 (#: ,@i.)y#y }}

 

r=. ; extend^:(x-1)&.> i.#ud

ud{~ ~.((i.<./)|.])"1 r #~ lt{~({:,&.>{.)|:r

 

Here, <tt>extend</tt> takes a list of die sequences and appends each possibility of a new die where the new die is not less than the last die in the sequence. So, <tt>r</tt> is all such lists of length x. We discard the cases where the last element of the list is not less than the first, rotate each dice index list into canonical order, discard duplicates, and then use these indices to select the associated dice.

Task examples:

 

1 1 4 4

2 2 2 4

2 2 2 4

2 2 3 3

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.HashSet;

import java.util.List;

}

}

{{out}}

<pre>Number of eligible 4-faced dice: 35

=={{header|Julia}}==

{{trans|Python}}

using Memoize, Combinatorics

@time testnontransitivedice(5)

@time testnontransitivedice(6)

<pre>

All possible 1..3 3-sided dice

=={{header|Kotlin}}==

{{trans|Go}}

val res = mutableListOf<Array<Int>>()

val found = mutableSetOf<Int>()

println(a.joinToString(", ", "[", "]") { it.joinToString(", ", "[", "]") })

}

{{out}}

<pre>Number of eligible 4-faced dice: 35

 

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

DieFight[d1_List, d2_List] := Module[{sets},

sets = Tuples[{d1, d2}];

 

nontransitiveds = Map[ds[[#]] &, ssis, {2}];

{{out}}

<pre>{1,1,4,4}<{2,2,2,4} ; {2,2,2,4}<{1,3,3,3} ; {1,1,4,4}>{1,3,3,3}

=={{header|MiniZinc}}==

===The model===

%Non transitive dice. Nigel Galloway, September 14th., 2020

int: die; int: faces; set of int: values;

constraint pN(g[die,1..faces],g[1,1..faces]);

output[join(" ",[show(g[n,1..faces])++"<"++show(g[n+1,1..faces]) | n in 1..die-1])," "++show(g[die,1..faces])++">"++show(g[1,1..faces])];

===The task(4 sided die)===

;3 die values=1..4

{{trans|Python}}

{{libheader|itertools}}

import itertools

 

 

func cmp(die1, die2: Die): int =

var tot: array[3, int]

for d in product(die1.faces, die2.faces):

 

func verboseCmp(die1, die2: Die): string =

var win1, win2 = 0

for (d1, d2) in product(die1.faces, die2.faces):

echo &"\n More verbose comparison of last non-transitive result:"

echo " ", verboseDiceCmp(nonTrans[^1])

 

{{out}}

=={{header|Perl}}==

{{trans|Go}}

use warnings;

 

}

 

{{out}}

<pre>Number of eligible 4-faced dice: 35

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (added sq_cmp() builtin that returns nested -1/0/+1 compare() results, just like the existing sq_eq() does for equal().)</span>

<span style="color: #000000;">show_dice</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dice</span><span style="color: #0000FF;">,</span><span style="color: #000000;">find_non_trans</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dice</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">),</span><span style="color: #000000;">0</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;">"%s\n\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

With the recent optimisations I can just about stretch to power(924,3), but I think I was right to skip power(924,4) above, it would probably take over two and a half ''days''.<br>

I have also estimated that power(3003,3) (ie 1..9 on the sides) would probably take around 4 hours (assuming such attempts didn't run out of memory).

<span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>

<span style="color: #000000;">mx</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">6</span>

<span style="color: #000000;">show_dice</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dice</span><span style="color: #0000FF;">,</span><span style="color: #000000;">find_non_trans</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dice</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">),</span><span style="color: #000000;">3</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;">"%s\n\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

=={{header|Python}}==

Trivial rotations of the same loop are not shown.

from time import time

print(f'\t{i + 1}*{loop_len} solutions, e.g. {" > ".join(x)} > [loop]')

t, t0 = time(), t

{{out}}

<pre>4-sided, markings 1234, loop length 3:

 

===Alternative===

from itertools import permutations, product

from functools import lru_cache

print('\n More verbose comparison of last non_transitive result:')

print(' ', verbose_dice_cmp(non_trans[-1]))

 

{{out}}

=={{header|R}}==

It would not be difficult to adapt this code to meet the stretch goal, but readability would suffer.

{

diceSet <- unique(t(apply(expand.grid(1:4, 1:4, 1:4, 1:4), 1, sort))) #By construction, each row is a unique dice.

}

}

 

{{out}}

Thanks to Thundergnat for the nice "less-is-more" tweaks now the 4 dice portion takes around 10 (down from 17 ) minutes to run ..

{{trans|Go}}

 

my @dicepool = ^4 xx 4 ;

say +@output, " ordered lists of $_ non-transitive dice found, namely:";

.say for @output;

{{out}}

<pre>Number of eligible 4-faced dice : 35

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

var fourFaceCombs = Fn.new {

it = findIntransitive4.call(combs)

System.print("\n%(it.count) ordered lists of 4 non-transitive dice found, namely:")

 

{{out}}