Giáng sinh đang đến rất nhanh và cùng với nó, sắp xếp gia đình bí mật Santa hàng năm. Tôi muốn thử và bắt đầu với điều này, nhưng đảm bảo rằng các cặp vợ chồng không mua cho nhau sẽ gây ra vấn đề và mặc dù đã làm điều này trong nhiều năm, vẫn có vấn đề Bobkhá khó khăn khi mua quà tặng cho hầu hết những người được tặng , Erincó thể sẽ thất vọng, nhưng anh ta biết rằng Frankthích Talisker, vì vậy anh ta là một đối thủ xứng tầm với anh ta. Điều này làm cho không có giải pháp đơn giản nào hiện có chấp nhận được cho nhu cầu của tôi.

Để làm cho cuộc sống của tôi dễ dàng hơn, nhiệm vụ của bạn là viết một hàm (hoặc thay thế gần nhất bằng ngôn ngữ của bạn) mà khi được cung cấp một mảng (hoặc thay thế gần nhất trong ngôn ngữ bạn đã chọn), trả về (hoặc đầu ra) một cặp 'người tặng' cho 'người được tặng' trong mã ngắn nhất có thể tính bằng byte, sao cho đáp ứng các điều kiện sau:

• Mỗi tên được ghép với một tên khác, được chọn ngẫu nhiên, tên từ dữ liệu đầu vào (Lưu ý rằng không phải lúc nào cũng có thể chọn ngẫu nhiên đầu ra dựa trên các điều kiện được cung cấp)
• Các tên sẽ được cung cấp một danh sách các cờ biểu thị một ma trận kề với thứ tự nhất quán, để cột đó nđề cập đến cùng một người là hàng n.
• Nếu các điều kiện không thể được đáp ứng, hãy trả lại một cái gì đó sai lệch trong ngôn ngữ của bạn.
• Nếu có nhiều giải pháp, chương trình của bạn phải có khả năng tạo ra tất cả chúng nếu chạy nhiều lần.

Bạn có thể cho rằng bạn sẽ không bao giờ được trình bày với tên trùng lặp như chúng ta cần để có thể nói mà gia đình thành viên là có, nhưng bạn có thể được trình bày với các dữ liệu trong đó bao gồm không gian để phân biệt Bob Seniortừ Bob Junior! Nó sẽ hoàn thành tất cả các trường hợp thử nghiệm được cung cấp trong vòng một giờ cho các gia đình khá lớn, chẳng hạn như 100 tên duy nhất trong dữ liệu nguồn (vui lòng xem các tập dữ liệu mẫu bên dưới, bạn phải có thể phân tích tất cả các trường hợp này trong thời gian được phân bổ).

Ví dụ đầu vào:

santa([
    ["Alice", 0, 0, 1, 1, 1, 1, 1],
    ["Bob",   0, 0, 0, 0, 0, 1, 0],
    ["Carla", 1, 1, 0, 0, 0, 1, 1],
    ["Dan",   1, 1, 0, 0, 0, 1, 1],
    ["Erin",  1, 1, 0, 0, 0, 1, 1],
    ["Frank", 1, 1, 1, 1, 1, 0, 1],
    ["Gary",  1, 1, 1, 1, 1, 1, 0]
]);
// might return something like:
[
    ["Alice", "Erin"],
    ["Bob", "Frank"],
    ["Carla", "Alice"],
    ["Dan", "Gary"],
    ["Erin", "Bob"],
    ["Frank", "Dan"],
    ["Gary", "Carla"]
]

santa([
    ["Alice", 0, 1, 1, 1, 0, 1],
    ["Bob",   0, 0, 1, 1, 0, 1],
    ["Carla", 0, 1, 0, 1, 0, 1],
    ["Dan",   0, 1, 1, 0, 0, 0],
    ["Erin",  0, 0, 1, 0, 0, 1],
    ["Frank", 1, 1, 1, 1, 1, 0]
]);
false

santa([
    ["Alice", 0, 1, 1],
    ["Bob",   1, 0, 1],
    ["Carla", 1, 1, 0]
]);
[
    ["Alice", "Bob"],
    ["Bob", "Carla"],
    ["Carla", "Alice"]
]

Tùy thuộc vào ngôn ngữ, đầu vào có thể ở các định dạng khác, ví dụ chi tiết về STDIN có thể được cung cấp như:

script <<< 'Alice,0,0,1,1,1,1,1
Bob,0,0,0,0,0,1,0
Carla,1,1,0,0,0,1,1
Dan,1,1,0,0,0,1,1
Erin,1,1,0,0,0,1,1
Frank,1,1,1,1,1,0,1
Gary,1,1,1,1,1,1,0'

Đầu ra cũng có thể được cung cấp ở bất kỳ định dạng hợp lý nào, tùy theo ngôn ngữ của bạn. Các định dạng có thể chấp nhận bao gồm một mảng các mảng (như trên) hoặc có thể là một Objectmảng băm / / kết hợp hoặc thậm chí chỉ in các parings thành STDOUT:

Alice:Dan
Bob:Erin
Carla:Bob
Dan:Alice
Erin:Frank
Frank:Carla

Nếu nghi ngờ, vui lòng hỏi và cung cấp các ví dụ về định dạng đầu vào bắt buộc và định dạng đầu ra dự kiến ​​với câu trả lời của bạn.

Tham khảo triển khai JavaScript .

Bộ dữ liệu lớn hơn: 100 , 100 , 200 , 200 - nhiều giải pháp , 200 - chỉ một giải pháp .

Tham chiếu thực hiện hoàn thành tất cả những điều này trong <4s trên máy của tôi.

Các bộ trên được tạo với tập lệnh này .

Javascript ES6, 191

Giải pháp này trả về tất cả các cặp có thể dưới dạng danh sách các cặp:

f=l=>(h=l=>l.length,n=l.map(i=>i.shift()),o=[],(r=s=>(g=h(s))<h(n)?l[g].map((e,x)=>e&&r([...s,x])):o.push([...s]))([]),o.filter(i=>h([...new Set(i)])==h(n)).map(l=>l.map((t,f)=>[n[f],n[t]])))

Chạy ví dụ:

>> example = f([
    ["Alice", 0, 0, 1, 1, 1, 1, 1],
    ["Bob",   0, 0, 0, 0, 0, 1, 0],
    ["Carla", 1, 1, 0, 0, 0, 1, 1],
    ["Dan",   1, 1, 0, 0, 0, 1, 1],
    ["Erin",  1, 1, 0, 0, 0, 1, 1],
    ["Frank", 1, 1, 1, 1, 1, 0, 1],
    ["Gary",  1, 1, 1, 1, 1, 1, 0]])

<< Array [ Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], 26 more… ]

>> example[0]

<< Array [ "Alice:Carla", "Bob:Frank", "Carla:Alice", "Dan:Bob", "Erin:Gary", "Frank:Dan", "Gary:Erin" ]