Thử thách này được chuyển thể từ Olympic Tin học Anh .

Trò chơi súc sắc

Hai người chơi đang chơi một trò chơi súc sắc trong đó mỗi người chơi một cặp súc sắc và tổng tiền thắng cao nhất. Các cặp xúc xắc có cùng số cạnh, nhưng không phải có cùng giá trị ở mỗi bên. Do đó, trò chơi là công bằng nếu cho cả hai cặp xúc xắc, tất cả các khoản tiền có thể có thể được thực hiện với xác suất như nhau.

Ví dụ: nếu Người chơi 1 có xúc xắc sau:

{1,2,3,4,5,6} {1,2,3,4,5,6}

Sau đó, họ có thể tạo ra các khoản tiền sau:

    1  2  3  4  5  6
 +------------------
1|  2  3  4  5  6  7 
2|  3  4  5  6  7  8
3|  4  5  6  7  8  9
4|  5  6  7  8  9  10
5|  6  7  8  9  10 11
6|  7  8  9  10 11 12

Nếu người chơi 2 có:

{1,2,2,3,3,4} {1,3,4,5,6,8}

Họ có thể sản xuất:

    1  2  2  3  3  4
 +------------------
1|  2  3  3  4  4  5 
3|  4  5  5  6  6  7
4|  5  6  6  7  7  8
5|  6  7  7  8  8  9
6|  7  8  8  9  9  10
8|  9  10 10 11 11 12

Trò chơi này công bằng vì tối thiểu cho cả hai là 2, tối đa là 12 và mỗi tổng xảy ra cùng một số lần, ví dụ 7 có thể được thực hiện 6 cách với mỗi cặp.

Thử thách

Viết chương trình / hàm lấy hai con xúc xắc làm đầu vào và tùy ý một số nguyên biểu thị số cạnh của mỗi con xúc xắc, và in / trả về một cặp súc sắc khác nhau có thể được sử dụng để chơi một trò chơi công bằng với hai con xúc xắc đầu vào, hoặc bất kỳ giá trị falsey nếu không có giải pháp khác với đầu vào.

Thông số kỹ thuật

• Số cạnh của cả hai con xúc xắc phải giống nhau và bằng số cạnh của cặp xúc xắc đầu vào. Số này sẽ luôn là một số nguyên lớn hơn hoặc bằng 1.

• Hai con xúc xắc được trả về có thể giống nhau, nhưng cặp không được giống với cặp đầu vào.

• Các cặp thứ tự khác nhau không khác nhau; {1,2,3} {4,5,6} giống với {4,5,6} {1,2,3}.

• Chương trình của bạn không cần tạo ra kết quả nhanh chóng, miễn là cuối cùng nó sẽ tạo ra đầu ra chính xác.

• Các giá trị trên cặp xúc xắc đầu vào sẽ luôn là các số nguyên nằm trong khoảng từ 1 đến 9, nhưng các giá trị được trả về có thể là bất kỳ số nguyên 1.

• Nếu có nhiều hơn một giải pháp có thể, chỉ cần trả lại một giải pháp.

• Đầu vào / đầu ra có thể ở bất kỳ định dạng hợp lý.

Các trường hợp thử nghiệm

6
1 2 2 3 3 4
8 6 5 4 3 1

1 2 3 4 5 6
1 2 3 4 5 6

4
1 1 1 1
1 4 5 8

1 1 4 4
1 1 5 5

3
1 3 5
2 4 6

False

8                    
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8

Any of the following:

1 2 2 3 3 4 4 5       |    1 2 2 3 5 6 6 7   |    1 2 3 3 4 4 5 6
1 3 5 5 7 7 9 11      |    1 3 3 5 5 7 7 9   |    1 2 5 5 6 6 9 10

Thạch , 34 byte

+þµFṢ
ç©ṀRœċL}Œċµç/⁼®µÐf
,Ṣ€,Ṛ$ḟ@ç

Trả về một danh sách tất cả các cặp xúc xắc có thể theo thứ tự xúc xắc và mặt * (không bao gồm bất kỳ cặp xúc xắc nào giống như cặp đầu vào).

Hãy thử trực tuyến!

Đây là một bác sĩ vũ phu và không hiệu quả (quá chậm để thậm chí chạy trường hợp thử nghiệm 6 mặt tại TIO).

+þµFṢ - Link 1, sorted sums: dieA, dieB
 þ    - outer product with
+     -     addition (make a table of the sums, a list of lists)
  µ   - monadic chain separation
   F  - flatten into one list
    Ṣ - sort

ç©ṀRœċL}Œċµç/⁼®µÐf - Link 2, all possible fair dice pairs (including input): dieA, dieB
ç                  - call the last link (1) as a dyad
 ©                 - save the result to the register for later use too
  Ṁ                - maximum (the largest sum)
   R               - range [1,2,...,maxSum]
       }           - use right argument (dice B) to turn the monad into a dyad:
      L            -     length
    œċ             - all combinations with replacement (i.e. all dice with faces between 1 and maxSum inclusive [overkill, but golfier than less])
        Œċ         - all pairs of these dice
          µ        - monadic chain separation
               µÐf - filter keep:
            /      -     reduce with:
           ç       -         last link (1) as a dyad (the sorted sums of the current pair)
              ®    -     retrieve register value (the sorted sums of the input pair)
             ⁼     -     equal?

,Ṣ€,Ṛ$ḟ@ç - Main link: dieA, dieB
,         - pair - [dieA, dieB]
 Ṣ€       - sort €ach - [dieASorted, dieBSorted]
     $    - last two links as a monad:
    Ṛ     -     reverse - [dieBSorted, dieASorted]
   ,      -     pair - [[dieASorted, dieBSorted], [dieBSorted, dieASorted]]
        ç - call the last link (2) as a dyad (with dieA, dieB)
       @  - reversed @rguments:
      ḟ   -     filter out - removes any results that are equivalent to the input pair.

* tức là nếu [[1,1,4,4],[1,1,5,5]]có một khả năng (như trong một trong các ví dụ) sẽ không có [[1,1,5,5],[1,1,4,4]hoặc [[1,4,1,4],[1,1,5,5]], v.v.

C ++ 14, 130 byte

Như lambda không tên giả định Mlà như thế std::vector<std::vector<int>>. Công bằng là 0, bất cứ điều gì khác là không công bằng.

#include<map>
[](auto&M){auto g=[](auto&v){std::map<int,int>m;for(int x:v)for(int y:v)m[x+y]++;return m;};return g(M[0])-g(M[1]);}

Ung dung:

#include<map>

auto f=
[](auto&M){
 auto g=[](auto&v){
  std::map<int,int>m;
  for(int x:v)
   for(int y:v)
    m[x+y]++;
  return m;
 };
 return g(M[0])==g(M[1]);
}
;

Python, 228 byte

from itertools import*;s,C=lambda x,y:sorted(sum([[i+j for j in y]for i in x],[])),combinations_with_replacement;f=lambda k,l,m:([[*a]for a in C([*C([*range(1,s(l,m)[-1])],k)],2)if(s(l,m)==s(*a))*~-([*a]in[[l,m],[m,l]])]+[0])[0]

Đây là từ một thời gian dài trước đây; Bây giờ tôi có thể chơi golf tốt hơn một chút.