Weihnachten steht vor der Tür und zusammen mit ihm wird der jährliche Familiengeheimnis-Weihnachtsmann organisiert. Ich würde gerne versuchen, einen Vorsprung zu erlangen, aber sicherzustellen, dass Paare nicht füreinander kaufen, verursacht immer wieder Probleme, und obwohl dies jahrelang getan wird, gibt es immer noch das Problem, dass Bobes für die meisten Fünfzehn ziemlich blöd ist, Geschenke zu kaufen , Erinwird wahrscheinlich enttäuscht sein, aber er weiß , dass Frankmag Talisker, so dass er für ihn ein gutes Spiel ist. Dies macht keine der vorhandenen einfachen Lösungen für meine Bedürfnisse akzeptabel.

Um mir das Leben zu erleichtern, besteht Ihre Aufgabe darin, eine Funktion (oder die nächstgelegene Alternative in Ihrer Sprache) zu schreiben, die bei Angabe eines Arrays von Arrays (oder der nächstgelegenen Alternative in Ihrer gewählten Sprache) eine Paarung von 'Giftern' an zurückgibt (oder ausgibt) 'fünfzehn' im kürzestmöglichen Code in Bytes, so dass die folgenden Bedingungen erfüllt sind:

• Jeder Name wird mit einem anderen, zufällig ausgewählten Namen aus den Eingabedaten gepaart (Beachten Sie, dass es möglicherweise nicht immer möglich ist, die Ausgabe basierend auf den bereitgestellten Bedingungen zufällig zu sortieren).
• Namen werden mit einer Liste von Flags versehen, die eine Adjazenzmatrix mit konsistenter Reihenfolge darstellen, sodass sich die Spalte nauf dieselbe Person wie die Zeile bezieht n.
• Wenn die Bedingungen nicht erfüllt werden können, geben Sie etwas Falsches in Ihrer Sprache zurück.
• Wenn es mehrere Lösungen gibt, muss Ihr Programm in der Lage sein, alle zu generieren, wenn es mehrmals ausgeführt wird.

Sie können davon ausgehen, dass Ihnen niemals doppelte Namen angezeigt werden, da wir feststellen müssen, welches Familienmitglied welches ist. Möglicherweise werden Ihnen jedoch Daten angezeigt, die Leerzeichen enthalten, Bob Seniorvon denen Sie sich unterscheiden können Bob Junior! Es sollte alle bereitgestellten Testfälle innerhalb einer Stunde für ziemlich große Familien abschließen, z. B. 100 eindeutige Namen in den Quelldaten (siehe Beispieldatensätze unten, Sie müssen in der Lage sein, alle diese innerhalb der zugewiesenen Zeit zu analysieren).

Beispieleingabe:

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"]
]

Abhängig von der Sprache kann die Eingabe in anderen Formaten erfolgen. Details STDIN dazu können beispielsweise wie folgt bereitgestellt werden:

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'

Die Ausgabe kann auch in jedem sinnvollen Format erfolgen, je nachdem, was für Ihre Sprache am einfachsten ist. Akzeptable Formate umfassen ein Array von Arrays (wie oben) oder möglicherweise ein Hash / Object/ assoziatives Array oder auch nur das Drucken der Parings auf STDOUT:

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

Im Zweifelsfall fragen Sie bitte und geben Sie Ihrer Antwort Beispiele für das erforderliche Eingabeformat und das erwartete Ausgabeformat.

Referenz JavaScript-Implementierung .

Größere Datensätze: 100 , 100 , 200 , 200 - viele Lösungen , 200 - nur eine Lösung .

Die Referenzimplementierung schließt alle diese Aufgaben in <4 Sekunden auf meinem Computer ab.

Oben mit diesem Skript generierte Sets .

Javascript ES6, 191

Diese Lösung gibt alle möglichen Paarungen als Liste von Paaren zurück:

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

Beispiellauf:

>> 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" ]