Trò chơi súc sắc Mia giới thiệu một thứ tự rất nhỏ của các bộ cỡ hai:

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

Nói chung, thứ tự trong một tuple không quan trọng {x,y}={y,x}, {1,2}lớn hơn bất cứ thứ gì khác, Các cặp lớn hơn các cặp không và giá trị số quyết định trong trường hợp hòa.

Bây giờ giả sử bạn muốn sử dụng nxúc xắc. Ngoài ra, các con xúc xắc có mkhuôn mặt.

Thí dụ:

• {1,5,3,4} < {1,2,6,3} kể từ 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} vì cả hai bộ đều có một cặp và 611> 522

Tóm lại, {1, ..., n}lớn hơn bất cứ điều gì khác. Hãy để p > qp-of-a-kind lớn hơn q-of-a-kind. Trong trường hợp hòa, thứ hai (, thứ ba, ...) - chiến thắng dài nhất có một không hai. Cuối cùng, nếu chưa có quyết định nào được đưa ra, giá trị số lớn nhất sẽ thắng. Giá trị số của một tập hợp là số nguyên lớn nhất bạn có thể xây dựng từ các số có sẵn trong tập hợp, sử dụng phép nối. Thí dụ:

• {2,5,4,3} trở thành 5432
• {4,11,3,4} trở thành B443 (> xúc xắc 6 mặt được phép, B = 11)

Nhiệm vụ của bạn là viết chương trình nhỏ nhất có thể (nghĩa là hàm) bằng ngôn ngữ bạn chọn, đưa ra hai thùng chứa (danh sách, mảng, tập hợp, ...) trả về dù cái thứ nhất hay cái thứ hai thắng.

Lưu ý: bạn có thể giả sử rằng hai container có cùng độ dài và chỉ chứa các số nguyên dương, nhưng không có gì khác. Đặc biệt chúng có thể không được sắp xếp. Giá trị trả về có thể là bất cứ thứ gì, ví dụ {-1, 0, 1} cho {thắng đầu tiên, hòa, thắng thứ hai}.

Thạch , 16 byte

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

Đưa ra một danh sách các danh sách mà mỗi danh sách đại diện cho một cuộn (vì vậy có thể nhiều hơn hai nếu muốn) và trả về một danh sách (các) người chiến thắng.

Hãy thử trực tuyến! Thay vào đó, đây là một phiên bản sắp xếp các cuộn từ yếu nhất đến mạnh nhất thay thế.

Làm sao?

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

Giải thích: Lấy hai mảng làm tham số. gchuyển đổi từng mảng thành một danh sách đếm. Danh sách sau đó được kiểm tra để xem liệu nó có tương ứng với một tập hợp không 1..n. Tổng số được sắp xếp và các giá trị được sắp xếp được nối. Hai kết quả sau đó được so sánh. Giá trị trả về là số nguyên dương nếu mảng thứ hai thắng và số nguyên âm nếu mảng thứ nhất thắng, nếu không, giá trị JavaScript giả undefinedđược trả về.

PHP 333 byte

Tôi giả sử rằng có ít súc sắc hơn sau đó phải đối mặt với giá trị cao nhất khi đường bắt đầu bằng 1

Tôi làm thêm một chút. Đầu vào là một mảng có nhiều hơn hai giá trị. Đầu ra là mảng được sắp xếp.

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

Phá vỡ

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

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

Có thể đọc được

  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