Il Natale si avvicina rapidamente e, insieme ad esso, organizza l'annuale famiglia Secret Santa. Mi piacerebbe provare a ottenere un vantaggio su questo, ma assicurarsi che le coppie non si comprino reciprocamente continua a causare problemi e nonostante ciò per anni c'è ancora il problema che Bobè piuttosto spazzatura nell'acquistare regali per la maggior parte dei giftees , Erinsarà probabilmente deluso, ma sa che gli Frankpiace Talisker, quindi è una buona partita per lui. Ciò rende nessuna delle soluzioni semplici esistenti accettabile per le mie esigenze.

Per semplificarmi la vita, il tuo compito è quello di scrivere una funzione (o l'alternativa più vicina nella tua lingua) che, quando viene fornita una matrice di array (o l'alternativa più vicina nella lingua scelta), restituisce (o genera) un'associazione di "gifter" a 'giftees' nel codice più breve possibile in byte, in modo tale da soddisfare le seguenti condizioni:

• Ogni nome è associato a un altro nome, selezionato casualmente, dai dati di input (si noti che potrebbe non essere sempre possibile randomizzare l'output in base alle condizioni fornite)
• Ai nomi verrà fornito un elenco di flag che rappresentano una matrice di adiacenza con l'ordinamento coerente, in modo che la colonna si nriferisca alla stessa persona della riga n.
• Se le condizioni non possono essere soddisfatte, restituisci qualcosa di falso nella tua lingua.
• Se ci sono più soluzioni, il tuo programma deve essere in grado di generarle tutte se eseguite più volte.

Si può supporre che non sarà mai presentati con nomi duplicati, come abbiamo bisogno di essere in grado di dire quale membro della famiglia è che, ma si può essere presentato con i dati che includono gli spazi per differenziare Bob Seniorda Bob Junior! Dovrebbe completare tutti i casi di test forniti entro un'ora per famiglie piuttosto grandi, come 100 nomi univoci nei dati di origine (vedere i set di dati di esempio di seguito, è necessario essere in grado di analizzarli tutti entro il tempo assegnato).

Esempio di input:

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

A seconda della lingua, l'input può essere in altri formati, ad esempio i dettagli su STDIN potrebbero essere forniti come:

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'

L'output può anche essere fornito in qualsiasi formato ragionevole, a seconda di quale sia la più semplice per la tua lingua. I formati accettabili includono una matrice di matrici (come sopra) o forse una Objectmatrice hash / / associativa o anche solo la stampa dei parings per STDOUT:

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

In caso di dubbi, chiedere e fornire esempi di formato di input richiesto e formato di output previsto con la risposta.

Implementazione JavaScript di riferimento .

Set di dati più grandi: 100 , 100 , 200 , 200 - molte soluzioni , 200 - solo una soluzione .

L'implementazione di riferimento completa tutte queste operazioni in <4s sulla mia macchina.

Set sopra generati con questo script .

Javascript ES6, 191

Questa soluzione restituisce tutti i possibili accoppiamenti come un elenco di un elenco di coppie:

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

Esempio di esecuzione:

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