Le jeu de dés Mia introduit un ordre très non trivial d'ensembles de taille deux:

{3,1} < {3,2} < {4,1} < {4,2} < {4,3} < {5,1} < {5,4} < {6,1} < {6,5} < {1,1} < {2,2} < {6,6} < {1,2}

En général, l'ordre dans un tuple n'a pas d'importance {x,y}={y,x}, {1,2}est supérieur à toute autre chose, les paires sont supérieures aux non-paires et la valeur numérique décide en cas d'égalité.

Supposons maintenant que vous vouliez utiliser des ndés. De plus, les dés ont des mvisages.

Exemple:

• {1,5,3,4} < {1,2,6,3} depuis 5431 <6321
• {1,2,3,5} < {1,1,5,6} < {1,1,5,5}, {1,1,6,6} < {1,1,1,3} < {2,2,2,3} < {1,1,1,1} < {1,2,3,4}
• {2,2,5} < {1,1,6} puisque les deux ensembles ont chacun une paire et 611> 522

En un mot, {1, ..., n}c'est plus que toute autre chose. Soit p > q, alors p-of-a-kind est supérieur à q-of-a-kind. En cas d'égalité, la deuxième (, troisième, ...) - la plus longue victoire en son genre. Enfin, si aucune décision n'a pu encore être prise, la plus grande valeur numérique l'emporte. La valeur numérique d'un ensemble est le plus grand entier que vous pouvez créer à partir des nombres disponibles dans l'ensemble, en utilisant la concaténation. Exemple:

• {2,5,4,3} devient 5432
• {4,11,3,4} devient B443 (> les dés à 6 faces sont autorisés, B = 11)

Votre tâche consiste à écrire le plus petit programme possible (c'est-à-dire la fonction) dans la langue de votre choix, qui, étant donné deux conteneurs (liste, tableau, ensemble, ...), retourne si le premier ou le second l'emporte.

Remarque: vous pouvez supposer que les deux conteneurs ont la même longueur et ne contiennent que des entiers positifs, mais rien d'autre. Surtout, ils peuvent ne pas être triés. La valeur de retour peut être n'importe quoi, par exemple {-1, 0, 1} pour {premières victoires, égalité, deuxièmes victoires}.

Gelée , 16 octets

ṢŒrUṢṚZ
Ṣ⁼J;ǵÐṀ

Prend une liste de listes dont chacune représente un rouleau (peut donc être plus de deux si vous le souhaitez) et retourne une liste des gagnants.

Essayez-le en ligne! ... alternativement voici une version qui trie les rouleaux du plus faible au plus fort à la place.

Comment?

Ṣ⁼J;ǵÐṀ - Main link: list of list of dice rolls, L
     µÐṀ - filter keep maximal (i.e. sort L by the previous link as a key and keep maximums)
         -                                            e.g. [5,3,1,3]
Ṣ        -     sort roll                                   [1,3,3,5]
  J      -     range(length(roll))                         [1,2,3,4]
 ⁼       -     equal? [1,2,3,...n] beats everything        0
    Ç    -     call last link as a monad with input roll   [[2,1,1],[3,5,1]]
   ;     -     concatenate                                 [0,[2,1,1],[3,5,1]]

ṢŒrUṢṚZ - Link 1, rest of sort key: dice rolls        e.g. [5,3,1,3]
Ṣ       - sort the roll                                    [1,3,3,5]
 Œr     - run length encode                                [[1,1],[3,2],[5,1]]
   U    - upend (reverse each)                             [[1,1],[2,3],[1,5]]
    Ṣ   - sort                                             [[1,1],[1,5],[2,3]]
     Ṛ  - reverse                                          [[2,3],[1,5],[1,1]]
      Z - transpose                                        [[2,1,1],[3,5,1]]
        -     ...this is a list of: 1) the group sizes descending; and
                 2) the face values of each group, descending across equal group sizes

JavaScript (ES6), 162 octets

(a,b,g=a=>a.map(n=>e[n]=e[n]+1||1,e=[1])&&[[...e].every(n=>n==1),...e.filter(i=x=>x).sort(h=(a,b)=>b-a),...a.sort(h)],c=g(a),d=g(b))=>d.map((n,i)=>n-c[i]).find(i)

Explication: prend deux tableaux comme paramètres. gconvertit chaque tableau en une liste de comptes. La liste est ensuite vérifiée pour voir si elle correspond à un ensemble 1..n. Les nombres sont triés et les valeurs triées sont concaténées. Les deux résultats sont ensuite comparés. La valeur de retour est un entier positif si le deuxième tableau gagne et un entier négatif si le premier tableau gagne, sinon la valeur JavaScript falsifiée undefinedest retournée.

PHP 333 octets

Je suppose qu'il y a moins de dés que de faces pour la valeur la plus élevée en tant que rue commençant par 1

J'en fais un peu plus. L'entrée est un tableau avec plus de deux valeurs. La sortie est le tableau trié.

<? $m=$_GET[m];foreach($m as$k=>$v){rsort($v);$m[$k]=$v;}function t($a,$b){if($a==$r=range($x=count($a),1))return 1;elseif($b==$r)return-1;$c=array_pad(array_values(array_count_values($a)),$x,0);$d=array_pad(array_values(array_count_values($b)),$x,0);rsort($c);rsort($d);if($e=$c<=>$d)return$e;return$a<=>$b;}usort($m,t);print_r($m);

Panne

$m=$_GET["m"]; # Array as Input
foreach($m as$k=>$v){
    rsort($v); # reverse sort of an item
    $m[$k]=$v; # replace the sort item
}
function t($a,$b){ #sorting algorithm
    if($a==$r=range($x=count($a),1))return 1; # $a is highest value
    elseif($b==$r)return-1; # $b is highest value
    $c=array_pad(array_values(array_count_values($a)),$x,0); 
# prepare check multiple values for fist value
    $d=array_pad(array_values(array_count_values($b)),$x,0); 
# prepare check multiple values for second value
    rsort($c);
    rsort($d);
    if($e=$c<=>$d)return$e; # compare first and second multiples
    return$a<=>$b; # compare dices
}
usort($m,"t"); # start sort
print_r($m); #print sorted array from low to high

Julia (489 octets)

function a(x,y)l=length;g=collect;s=sort;m=maximum;r=repmat;function b(z)w=sum(r(z,1,m(z)).==r(g(1:m(z))',l(z),1),1);u=zeros(m(w));map(i->if i>0 u[i]+=1;end,w);return u end;function c(x,y)if l(x)>l(y)return-1 elseif l(x)<l(y)return 1 else for i=l(x):-1:1 if x[i]>y[i] return-1 elseif x[i]<y[i] return 1 end end;return 0;end end;x=s(x);y=s(y);if x==y return 0;elseif x==g(1:l(x));return-1 elseif y==g(1:l(y))return 1 else d=c(b(x),b(y));if d==0 return c(x,y);else return d;end end end

Lisible:

  1 function a(ds1, ds2)
  2     function countNOfAKind(ds)
  3         # return array. n-th value is number of occurences of n-of-a-kind.
  4         # e.g. findNOfAKind([1, 1, 1, 2, 2, 3, 3]) == [0, 2, 1]
  5         ps = sum(repmat(ds, 1, maximum(ds)) .== repmat(collect(1:maximum(ds))', length(ds), 1), 1);
  6         ls = zeros(maximum(ps));
  7         map(i -> if i>0 ls[i] += 1 end, ps);
  8         return ls
  9     end
 10 
 11     function cmpLex(ds1, ds2)
 12         # compare ds1, ds2 reverse-lexicographically, i.e. compare last distinct value.
 13         if length(ds1) > length(ds2)
 14             return -1
 15         elseif length(ds1) < length(ds2)
 16             return 1
 17         else
 18             for i = length(ds1):-1:1
 19                 if ds1[i] > ds2[i]
 20                     return -1
 21                 elseif ds1[i] < ds2[i]
 22                     return 1
 23                 end
 24             end
 25             return 0;
 26         end
 27     end
 28     
 29     ds1=sort(ds1);
 30     ds2=sort(ds2);
 31     if ds1 == ds2
 32         return 0;
 33     elseif ds1 == collect(1:length(ds1))
 34         return -1
 35     elseif ds2 == collect(1:length(ds2))
 36         return 1
 37     else
 38         d = cmpLex(countNOfAKind(ds1), countNOfAKind(ds2))
 39         if d == 0
 40             return cmpLex(ds1, ds2);
 41         else
 42             return d;
 43         end
 44     end
 45 end