Pesanan Set Mia

9

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

pasbi
sumber
1
Yang mana kemenangan dari {1,1,6}, {2,2,5}? Apakah Anda membandingkan nilai numerik p-of-a-kind terbesar atau dadu apa pun?
Martin Ender
1
Biarkan saya memeriksa apakah pemahaman saya tentang pemesanan benar: Pertama, {1, ..., n} adalah yang tertinggi. Untuk setiap daftar, ambil nilai paling umum, dan dari nilai yang sama-sama umum ambil nilai terbesar. Jika satu daftar memiliki lebih dari itu, ia menang. Jika sama-sama umum, mana yang menang lebih besar. Jika sama dalam kesamaan dan nilai, hapus semua dari setiap daftar dan bandingkan lagi.
xnor
@ Martin: Pertanyaan Luar Biasa. Saya kira tidak ada keputusan "kanonik" tentang itu, dan karena program julia saya mengatakan {1,1,6} menang atas {2,2,5}, maka hanya itu.
pasbi
@ xnor: Ya, pertimbangkan komentar Martin dan jawaban saya.
pasbi
@ oVooVo Oh ya, itu masuk akal mengingat contoh Anda di mana Anda cukup mengurutkannya berdasarkan nilai numerik setelah mengurutkan digit dari terbesar ke terkecil.
Martin Ender

Jawaban:

2

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
Jonathan Allan
sumber
@ oVooVo Saat mencoba bermain golf ini lebih saya perhatikan 1,1,2dan 1,2,2dianggap sama, tetapi spek saat ini tidak membedakan mereka juga.
Jonathan Allan
@ oVooVo setelah pemeriksaan lebih lanjut contohnya ada di {1,1,5,6} < {1,1,5,5}mana 6 > 5. Bisakah Anda mengklarifikasi?
Jonathan Allan
@ oVooVo Mungkin seharusnya seperti ini - saya telah mengganti "seleksi maksimal",, ÐṀdengan semacam Þ,, untuk tujuan pengujian - menggunakan item dari contoh itu mengurutkan mereka ke dalam urutan yang sama. Urutan yang digunakan adalah: pertama dengan jika "top-dog", kemudian dengan jumlah wajah yang sama turun dan akhirnya dengan wajah unik turun.
Jonathan Allan
{1,1,5,5} memiliki dua "2-of-a-kind": (1,1) dan (5,5). {1,1,5,6} hanya memiliki satu "2-of-a-kind". Karenanya {1,1,5,5} menang. Nilai tidak masalah di sini. Demikian pula, {1,1,2,2}> {4,5,6,6}.
pasbi
{1,2,2}> {1,1,2}. Karena keduanya memiliki satu 2-of-a-kind, numeric tie-breaking berlaku. {1,2,2} => 221 dan {1,1,2} => 211. Jelas 221 lebih besar dari 211. Saya akan menjelaskan ini dalam spesifikasi.
pasbi
2

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.

Neil
sumber
Program Anda mengatakan {1,1,6} <{2,2,5}, yang salah.
pasbi
@ oVooVo Maaf, saya pasti salah paham aturannya (saya pikir Anda memutuskan ikatan berdasarkan nilai numerik yang paling lama).
Neil
0

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
Jörg Hülsermann
sumber
0

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
pasbi
sumber
Mengapa Anda membandingkan panjang? Instruksi mengatakan "kedua wadah memiliki panjang yang sama". Apakah saya melewatkan sesuatu?
DavidC
Saya menghapus perbandingan panjang di baris 31. Itu tidak perlu tetapi tidak ada salahnya juga. Dibutuhkan perbandingan pada baris 15, karena cmpLex tidak hanya digunakan pada baris 40 untuk membandingkan input mentah, tetapi juga pada baris 38 untuk membandingkan hasil countNOfAKind. Namun fungsi itu dapat menghasilkan output berukuran berbeda untuk input berukuran sama: countNOfAKind ([3,2]) = [2] (karena ada dua angka kesepian (3 dan 2)), countNOfAKind ([2,2]) = [0, 1] (karena tidak ada nomor kesepian dan satu pasang.
pasbi