Zar oyunu Mia , iki büyüklükteki setlerin çok önemsiz bir sırasını sunuyor:

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

Genel olarak, bir demet içindeki düzen önemli değildir {x,y}={y,x}, {1,2}her şeyden daha büyüktür, Çiftler çift olmayanlardan daha büyüktür ve bir bağlanma durumunda sayısal değer karar verir.

Şimdi nzar kullanmak istediğinizi varsayalım . Ayrıca, zarların myüzleri var.

Misal:

• {1,5,3,4} < {1,2,6,3} 5431'den beri <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} çünkü her iki sette de her bir çift ve 611> 522

Özetle, {1, ..., n}her şeyden daha büyüktür. Öyleyse p > q, türünün p'si türünün q'sinden daha büyük olsun. Beraberlik durumunda, ikinci (, üçüncü, ...) - en uzun tür kazanır. Son olarak, henüz bir karar alınamazsa, en büyük sayısal değer kazanır. Bir kümenin sayısal değeri, birleştirme kullanarak kümedeki kullanılabilir sayılardan oluşturabileceğiniz en büyük tamsayıdır. Misal:

• {2,5,4,3} 5432 olur
• {4,11,3,4} B443 olur (> 6 yüzlü zarlara izin verilir, B = 11)

Göreviniz, mümkün olan en küçük programı (yani işlev) seçtiğiniz dilde yazmaktır, verilen iki kapsayıcı (liste, dizi, küme, ...), birincisi veya ikincisi kazanır.

Not: İki kabın aynı uzunlukta olduğunu ve yalnızca pozitif tamsayılar içerdiğini, ancak başka bir şeyin olmadığını varsayabilirsiniz. Özellikle sıralanamayabilirler. Dönüş değeri herhangi bir şey olabilir, örneğin {ilk kazanç, beraberlik, ikinci kazanç} için {-1, 0, 1}.

Jöle , 16 bayt

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

Her biri bir ruloyu temsil eden listelerin listesini alır (böylece istenirse ikiden fazla olabilir) ve kazananların listesini döndürür.

Çevrimiçi deneyin! ... alternatif burada yerine en güçlü için zayıf gelen ruloları sıralar bir sürümüdür.

Nasıl?

Ṣ⁼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 bayt

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

Açıklama: İki diziyi parametre olarak alır. gher diziyi bir sayım listesine dönüştürür. Liste daha sonra bir kümeye karşılık gelip gelmediğini görmek için kontrol edilir 1..n. Sayımlar sıralanır ve sıralanan değerler birleştirilir. İki sonuç daha sonra karşılaştırılır. İkinci dizi kazanırsa dönüş değeri pozitif, ilk dizi kazanırsa negatif tamsayıdır, aksi takdirde sahte JavaScript değeri undefineddöndürülür.

PHP 333 Bayt

Ben daha az dices varsa sokak başlangıç ​​olarak en yüksek değeri için yüzler olduğunu varsayalım 1

Biraz daha fazlasını yaparım. Girdi iki değerden fazla olan bir dizidir. Çıktı sıralanan dizidir.

<? $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);

Yıkmak

$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 Bayt)

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

Okunabilir:

  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