เกมลูกเต๋าMiaเปิดตัวชุดสองขนาดที่ไม่สำคัญ:

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

โดยทั่วไปการสั่งซื้อภายในขอบเขตของไม่สำคัญ{x,y}={y,x}, {1,2}มีค่ามากกว่าสิ่งอื่นใดคู่มากกว่าคู่บุหรี่และค่าตัวเลขตัดสินใจในกรณีที่มีการผูก

ตอนนี้สมมติว่าคุณต้องการใช้nลูกเต๋า นอกจากนี้ลูกเต๋ายังมีmใบหน้า

ตัวอย่าง:

• {1,5,3,4} < {1,2,6,3} ตั้งแต่ 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} เนื่องจากทั้งสองชุดมีแต่ละคู่และ 611> 522

สั้น{1, ..., n}กว่าสิ่งอื่นใด อนุญาตp > q, p-of-a-kind นั้นยิ่งใหญ่กว่า q-of-a-kind ในกรณีที่เสมอกันตัวที่สอง (, สาม, ... ) - ชนะได้ยาวนานที่สุด ในที่สุดหากยังไม่มีการตัดสินใจค่าตัวเลขที่ยิ่งใหญ่ที่สุดจะเป็นผู้ชนะ ค่าตัวเลขของชุดเป็นจำนวนเต็มที่มากที่สุดที่คุณสามารถสร้างจากตัวเลขที่มีอยู่ในชุดโดยใช้การต่อข้อมูล ตัวอย่าง:

• {2,5,4,3} กลายเป็น 5432
• {4,11,3,4} กลายเป็น B443 (> อนุญาตให้ใช้ลูกเต๋า 6 หน้า, B = 11)

งานของคุณคือการเขียนโปรแกรมที่เล็กที่สุดที่เป็นไปได้ (เช่นฟังก์ชั่น) ในภาษาที่คุณเลือกซึ่งให้สองคอนเทนเนอร์ (list, array, set, ... ) ส่งคืนว่าตัวแรกหรือตัวที่สองชนะ

หมายเหตุ: คุณสามารถสันนิษฐานได้ว่าสองคอนเทนเนอร์มีความยาวเท่ากันและมีจำนวนเต็มบวกเท่านั้น แต่ไม่มีอะไรอื่น โดยเฉพาะพวกเขาอาจจะไม่เรียง ค่าส่งคืนอาจเป็นอะไรก็ได้เช่น {-1, 0, 1} สำหรับ {first win, tie, second wins}

เยลลี่ขนาด 16 ไบต์

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

ใช้รายการของแต่ละรายการซึ่งแสดงถึงม้วน (ดังนั้นอาจมีมากกว่าสองรายการหากต้องการ) และส่งกลับรายการของผู้ชนะ

ลองออนไลน์! ... หรือที่นี่เป็นรุ่นที่เรียงม้วนจากจุดอ่อนที่สุดไปหาจุดแข็งที่สุดแทน

อย่างไร?

Ṣ⁼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 ไบต์

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

คำอธิบาย: ใช้สองอาร์เรย์เป็นพารามิเตอร์ gแปลงแต่ละอาร์เรย์ให้เป็นรายการการนับ รายการจะถูกตรวจสอบเพื่อดูว่าสอดคล้องกับชุด1..nหรือไม่ จำนวนจะถูกเรียงลำดับและค่าที่เรียงจะถูกต่อกัน จากนั้นเปรียบเทียบผลลัพธ์ทั้งสอง ค่าส่งคืนเป็นจำนวนเต็มบวกหากอาร์เรย์ที่สองชนะและจำนวนเต็มลบหากอาร์เรย์แรกชนะมิฉะนั้นค่า JavaScript ที่ผิดพลาดundefinedจะถูกส่งคืน

PHP 333 ไบต์

ฉันคิดว่ามีสี่เหลี่ยมลูกเต๋าน้อยลงจากนั้นหันไปหาค่าสูงสุดเมื่อถนนเริ่มต้นด้วย 1

ฉันทำเพิ่มอีกนิด อินพุตเป็นอาร์เรย์ที่มีค่ามากกว่าสองค่า เอาต์พุตเป็นอาร์เรย์ที่เรียงลำดับ

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

ทำให้พังถล่ม

$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

จูเลีย (489 ไบต์)

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

อ่านได้:

  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