Non-transitive dice: Difference between revisions

Line 87:

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

<~~lang~~ algol68># iterates through all possible dice #

<syntaxhighlight lang="algol68"># iterates through all possible dice #

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

BEGIN

Line 179:

FI

OD

OD</~~lang~~>

OD</syntaxhighlight>

<pre>3 dice:

Line 193:

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

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

<~~lang~~ fsharp>

// 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]]

Line 200:

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)

n4|>Seq.iter(fun(d1,d2,d3,d4)->printfn "%A<%A; %A<%A; %A<%A; %A>%A" d1 d2 d2 d3 d3 d4 d1 d4)</~~lang~~>

n4|>Seq.iter(fun(d1,d2,d3,d4)->printfn "%A<%A; %A<%A; %A<%A; %A>%A" d1 d2 d2 d3 d3 d4 d1 d4)</syntaxhighlight>

<pre>

Line 216:

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

;Sides numbered 1..6

<~~lang~~ fsharp>

// 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]]

Line 222:

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

</syntaxhighlight>

</lang>

<pre>

Line 230:

</pre>

;Sides numbered 1..7

<~~lang~~ fsharp>

// 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]]

Line 236:

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

</syntaxhighlight>

</lang>

<pre>

Line 245:

=={{header|Factor}}==

<~~lang~~ factor>USING: grouping io kernel math math.combinatorics math.ranges

<syntaxhighlight lang="factor">USING: grouping io kernel math math.combinatorics math.ranges

prettyprint sequences ;

Line 269:

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

4 4 find-non-transitive .</~~lang~~>

4 4 find-non-transitive .</syntaxhighlight>

<pre>

Line 292:

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 399:

fmt.Println(a)

}

}</~~lang~~>

}</syntaxhighlight>

Line 419:

=={{header|Haskell}}==

<~~lang~~ haskell>{-# language LambdaCase #-}

<syntaxhighlight lang="haskell">{-# language LambdaCase #-}

import Data.List

import Control.Monad

Line 445:

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

b <- filter (< a) dice

return (b:a:as)</~~lang~~>

return (b:a:as)</syntaxhighlight>

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

Line 467:

Implementation (rotations of results here are also solutions):

<~~lang~~ J>NB. unique list of all y faced dice

<syntaxhighlight lang="j">NB. unique list of all y faced dice

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

Line 481:

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

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

}}</~~lang~~>

}}</syntaxhighlight>

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.

Line 487:

Task examples:

<~~lang~~ J> 3 cycles 4

<syntaxhighlight lang="j"> 3 cycles 4

1 1 4 4

2 2 2 4

Line 495:

2 2 2 4

2 2 3 3

1 3 3 3</~~lang~~>

1 3 3 3</syntaxhighlight>

=={{header|Java}}==

<~~lang~~ java>import java.util.ArrayList;

<syntaxhighlight lang="java">import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

Line 604:

}

}</~~lang~~>

}</syntaxhighlight>

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

Line 621:

=={{header|Julia}}==

<~~lang~~ julia>import Base.>, Base.<

<syntaxhighlight lang="julia">import Base.>, Base.<

using Memoize, Combinatorics

Line 697:

@time testnontransitivedice(5)

@time testnontransitivedice(6)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

All possible 1..3 3-sided dice

Line 779:

=={{header|Kotlin}}==

<~~lang~~ scala>fun fourFaceCombos(): List<Array<Int>> {

<syntaxhighlight lang="scala">fun fourFaceCombos(): List<Array<Int>> {

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

val found = mutableSetOf<Int>()

Line 880:

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

}

}</~~lang~~>

}</syntaxhighlight>

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

Line 896:

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

<~~lang~~ ~~Mathematica~~>ClearAll[DieFight]

<syntaxhighlight lang="mathematica">ClearAll[DieFight]

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

sets = Tuples[{d1, d2}];

Line 924:

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

Column[Row[{#1, "<", #2, " ; ", #2, "<", #3, " ; ", #3, "<", #4, " ; ", #1, ">", #4}] & @@@ nontransitiveds]</~~lang~~>

Column[Row[{#1, "<", #2, " ; ", #2, "<", #3, " ; ", #3, "<", #4, " ; ", #1, ">", #4}] & @@@ nontransitiveds]</syntaxhighlight>

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

Line 937:

=={{header|MiniZinc}}==

===The model===

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

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

Line 947:

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])];

</syntaxhighlight>

</lang>

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

;3 die values=1..4

Line 1,205:

import algorithm, sequtils, sets, strformat

import itertools

Line 1,337:

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

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

echo "\n ===="</~~lang~~>

echo "\n ===="</syntaxhighlight>

Line 1,393:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

Line 1,542:

}

main();</~~lang~~>

main();</syntaxhighlight>

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

Line 1,558:

=={{header|Phix}}==

with javascript_semantics

requires("0.8.2") -- (added sq_cmp() builtin that returns nested -1/0/+1 compare() results, just like the existing sq_eq() does for equal().)

Line 1,778:

show_dice(dice,find_non_trans(dice,3),0)

printf(1,"%s\n\n",elapsed(time()-t0))

<pre>

Line 1,852:

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

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

t0 = time()

mx = 6

Line 1,866:

show_dice(dice,find_non_trans(dice,3),3)

printf(1,"%s\n\n",elapsed(time()-t0))

<pre>

Line 1,929:

=={{header|Python}}==

Trivial rotations of the same loop are not shown.

<~~lang~~ python>from itertools import combinations_with_replacement as cmbr

<syntaxhighlight lang="python">from itertools import combinations_with_replacement as cmbr

from time import time

Line 1,960:

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

t, t0 = time(), t

print(f'\ttime: {t - t0:.4f} seconds\n')</~~lang~~>

print(f'\ttime: {t - t0:.4f} seconds\n')</syntaxhighlight>

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

Line 1,979:

===Alternative===

<~~lang~~ python>from collections import namedtuple

<syntaxhighlight lang="python">from collections import namedtuple

from itertools import permutations, product

from functools import lru_cache

Line 2,053:

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

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

print('\n ====')</~~lang~~>

print('\n ====')</syntaxhighlight>

Line 2,114:

=={{header|R}}==

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

<~~lang~~ rsplus>findNonTrans <- function()

<syntaxhighlight lang="rsplus">findNonTrans <- function()

{

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

Line 2,149:

}

findNonTrans()</~~lang~~>

findNonTrans()</syntaxhighlight>

Line 2,171:

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

<lang ~~perl6~~># 20201225 Raku programming solution

<syntaxhighlight lang="raku" line># 20201225 Raku programming solution

my @dicepool = ^4 xx 4 ;

Line 2,206:

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

.say for @output;

}</~~lang~~>

}</syntaxhighlight>

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

Line 2,221:

=={{header|Wren}}==

<~~lang~~ ecmascript>import "/sort" for Sort

<syntaxhighlight lang="ecmascript">import "/sort" for Sort

var fourFaceCombs = Fn.new {

Line 2,311:

it = findIntransitive4.call(combs)

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

System.print(it.join("\n"))</~~lang~~>

System.print(it.join("\n"))</syntaxhighlight>