Game dadu Mia memperkenalkan urutan set yang sangat non-sepele ukuran dua:

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

Secara umum, urutan dalam tupel tidak masalah {x,y}={y,x}, {1,2}lebih besar dari yang lain, Pasangan lebih besar dari non-pasangan dan nilai numerik memutuskan dalam kasus dasi.

Sekarang anggaplah Anda ingin menggunakan ndadu. Juga, dadu memiliki mwajah.

Contoh:

• {1,5,3,4} < {1,2,6,3} sejak 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} karena kedua set memiliki masing-masing satu pasangan dan 611> 522

Singkatnya, {1, ..., n}lebih besar dari yang lainnya. Biarkan p > q, maka p-of-a-kind lebih besar dari q-of-a-kind. Dalam hal seri, yang kedua (, ketiga, ...) - kemenangan jenis terpanjang. Akhirnya, jika belum ada keputusan yang dibuat, nilai numerik terbesar akan menang. Nilai numerik suatu himpunan adalah bilangan bulat terbesar yang dapat Anda bangun dari angka yang tersedia di himpunan, menggunakan gabungan. Contoh:

• {2,5,4,3} menjadi 5432
• {4,11,3,4} menjadi B443 (> dadu bermuka 6 diperbolehkan, B = 11)

Tugas Anda adalah untuk menulis program sekecil mungkin (yaitu fungsi) dalam bahasa pilihan Anda, yang, diberikan dua wadah (daftar, array, set, ...) mengembalikan apakah yang pertama atau yang kedua menang.

Catatan: Anda dapat mengasumsikan bahwa kedua wadah memiliki panjang yang sama dan hanya berisi bilangan bulat positif, tetapi tidak ada yang lain. Terutama mereka mungkin tidak diurutkan. Nilai pengembalian bisa berupa apa saja, misalnya {-1, 0, 1} untuk {kemenangan pertama, seri, kemenangan kedua}.

Jelly , 16 byte

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

Mengambil daftar daftar yang masing-masing mewakili roll (jadi bisa lebih dari dua jika diinginkan) dan mengembalikan daftar pemenang.

Cobalah online! ... alternatifnya di sini adalah versi yang mengurutkan gulungan dari yang paling lemah ke yang paling kuat.

Bagaimana?

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

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

Penjelasan: Mengambil dua array sebagai parameter. gmengubah setiap array menjadi daftar jumlah. Daftar ini kemudian diperiksa untuk melihat apakah itu sesuai dengan suatu set 1..n. Hitungan diurutkan dan nilai yang diurutkan disatukan. Kedua hasil tersebut kemudian dibandingkan. Nilai kembali adalah bilangan bulat positif jika array kedua menang dan integer negatif jika array pertama menang, jika tidak nilai JavaScript palsu undefineddikembalikan.

PHP 333 Bytes

Saya berasumsi bahwa ada lebih sedikit dadu maka wajah untuk nilai tertinggi sebagai jalan dimulai dengan 1

Saya menghasilkan sedikit lebih banyak. Input adalah array dengan lebih dari dua nilai. Output adalah array yang diurutkan.

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

Kerusakan

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

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

Dapat dibaca:

  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