The Nonary Game è un gioco immaginario giocato nella trilogia di videogiochi con lo stesso nome. Il tuo obiettivo è scoprire quanti giocatori (nella migliore delle ipotesi) possono sfuggire a un determinato gioco, nel minor numero di byte possibile di codice.

Le regole del gioco

• Ci sono 9 giocatori, numerati da 1 a 9.
• Tutti i giocatori iniziano nella stessa stanza.
• Ci sono un numero qualsiasi di porte, ognuna con un numero da 1 a 9. Potrebbero esserci numeri di porta duplicati o mancanti.
• Le porte sono connessioni unidirezionali tra le stanze. Ogni porta può essere utilizzata una sola volta .
• Solo gruppi da 3 a 5 giocatori possono varcare una porta.
• Un gruppo può attraversare una porta solo se la somma dei loro numeri modulo 9 corrisponde al numero della porta modulo 9.
• Ogni giocatore che passa attraverso una porta 9 fugge (vince).

Esempi

┌───┬───┬───┐
│   6   4   9
│ < │   |   |
│   3   5   9
└───┴───┴───┘ 

<rappresenta il punto di partenza. Tutti i giocatori iniziano lì.

In questa impostazione, tutti possono scappare. Esistono vari modi per raggiungere questo obiettivo, uno dei quali è:

• [1, 2, 3, 4, 5] attraversano la porta 6 ((1 + 2 + 3 + 4 + 5)% 9 = 6), mentre [6, 7, 8, 9] attraversano la porta 3 ((6 + 7 + 8 + 9)% 9 = 3). Tutti si incontrano nella seconda stanza.
• [1, 2, 3, 7] attraversano la porta 4, mentre [4, 5, 6, 8, 9] attraversano la porta 5.
• [1, 2, 3, 4, 8] attraversano una delle 9 porte, [5, 6, 7, 9] attraversano l'altra.

┌───┬───┐
│   │   |
│ < 8   9
│   │   |
└───┴───┘ 

Questa volta, al massimo 4 persone possono scappare:

• [1, 3, 5, 8, 9] attraversano la porta 8.
• [1, 3, 5, 9] attraversa la porta 9.

Sono possibili altri elenchi di sopravvissuti, come [2, 3, 4] o [1, 4, 6, 7], ma non c'è modo per più di 4 persone di fuggire.

La sfida

Data una mappa, genera il numero massimo di giocatori che possono scappare.

• Non ti preoccupare, non è necessario analizzare i miei terribili diagrammi! L'input è un grafico diretto etichettato, che è possibile rappresentare in qualsiasi formato conveniente (edge ​​set, matrice di adiacenza ...).
• Se la tua rappresentazione richiede etichette per le stanze, puoi utilizzare qualsiasi set coerente di valori. Tuttavia, le porte devono essere rappresentate dagli interi da 1 a 9.
• L'ingresso avrà sempre almeno una 9 porte. Tutte e 9 le porte portano sempre all'uscita, mentre le altre porte non lo fanno mai.
• Il tuo invio può essere una funzione o un programma completo.
• Le scappatoie standard sono vietate.

Casi test

Gli ingressi sono mostrati come elenchi di terzine [numero porta, da stanza a stanza], con 0 come stanza iniziale e -1 come uscita. Se scegli di utilizzare un altro formato, dovrai convertirli in modo appropriato.

Input                                                                      Output
[[6, 0, 1], [3, 0, 1], [4, 1, 2], [5, 1, 2], [9, 2, -1], [9, 2, -1]]       9
[[8, 0, 1], [9, 1, -1]]                                                    4
[[9, 0, -1]]                                                               5
[[2, 0, 1], [1, 1, 2], [9, 2, -1]]                                         0
[[2, 0, 1], [3, 1, 2], [9, 2, -1]]                                         3
[[1, 0, 1], [9, 1, -1], [1, 0, 2], [9, 2, -1]]                             4
[[2, 0, 1], [3, 0, 1], [5, 1, 2], [4, 0, 2], [9, 2, -1], [9, 2, -1]]       8
[[3, 0, 1], [4, 0, 1], [5, 0, 1], [9, 1, -1], [7, 1, 2], [9, 2, -1]]       7
[[1, 0, 1], [2, 0, 1], [4, 0, 1], [9, 1, -1], [8, 1, 2], [9, 2, -1]]       6
[[6, 0, 1], [7, 0, 1], [9, 1, -1], [9, 1, -1]]                             7

JavaScript (ES6), 219 byte

Una versione più lenta ma significativamente più corta che utilizza maschere di bit anziché stringhe.

f=(D,P=[511],e=m=0)=>P.map((X,r)=>[...Array(-~X)].map((_,p)=>D.map(([d,s,t],j)=>(N=(g=(n,k)=>n&&n%2+g(n>>1,++k,x+=n%2*k))(p&=X,x=0))<3|N>5|r-s|x%9^d%9||f(D.filter(_=>j--),A=[...P],e+!~t*N,A[r]^=p,A[t]^=p))),m=m>e?m:e)|m

Provalo online!

$X$$(X \operatorname{AND} p)$$0\le p\le X$

JavaScript (ES7),  293 272  271 byte

Riceve input nel formato descritto nella sfida. Questa è una ricerca della forza bruta.

f=(D,P=[17**6+'8'],e=m=0)=>P.map((X,r)=>X&&[...X].reduce((a,x)=>[...a,...a.map(y=>y+x)],['']).map(p=>D.map(([d,s,t],j)=>p<99|p[5]|r-s|eval([...p].join`+`)%9^d%9||f(D.filter(_=>j--),A=[...P],e+!~t*p.length,A[r]=X.replace(eval(`/[${p}]/g`),''),A[t]=[A[t]]+p))),m=m>e?m:e)|m

Provalo online! (il primo caso di test scade sul TIO)

Come?

L'array P[]contiene un elenco di stringhe che descrivono i giocatori in ogni stanza.

P=['241375698']$17^6=24137569$$0$

Per ogni stanza Xin posizione r, calcoliamo il powerset di X:

[...X].reduce((a, x) => [...a, ...a.map(y => y + x)], [''])

Per ogni gruppo di giocatori ppresenti e per ciascuna porta [d,s,t]all'indice j, verifichiamo se il gruppo non è in grado di attraversare la porta:

                         // we can't pass if:
p < 99 |                 // there are less than 3 players
p[5] |                   // or there are more than 5 players
r - s |                  // or the source room s is not equal to the current room
eval([...p].join`+`) % 9 // or the sum of the players modulo 9
^ d % 9                  // does not match the ID of the door modulo 9

Se il gruppo può passare, facciamo una chiamata ricorsiva:

f(                       //
  D.filter(_ => j--),    // remove the door that has just been used from D[]
  A = [...P],            // use a copy A[] of P[]
  e + !~t * p.length,    // if t = -1, add the length of p to e (number of escaped guys)
  A[r] = X.replace(      // remove the players from the source room A[r]
    eval(`/[${p}]/g`),   //
    ''                   //
  ),                     //
  A[t] = [A[t]] + p      // and append them to the target room A[t]
)                        //

Teniamo traccia del numero massimo di giocatori fuggiti me alla fine lo restituiamo.

Gelatina , 76 byte

2ịịœc3r5¤ẎS,%9EʋƇ1ị${ḟ@;ƭⱮ€Ḋị¥ż€Ḋ{ṛṪ}¦ƒ€
ç@€Ẏ;ḷṢ€€Q
“”WẋḊ€FṀƊ9RW¤;Wçƒ@⁸ẈṪ$€Ṁ

Provalo online!

Un programma completo che accetta un singolo argomento, un grafico diretto che utilizza le stanze 1, 2, ... e 0 come uscita. Restituisce un numero intero che è il numero massimo che può sfuggire. Spiegazione completa da seguire.

Dovrebbe funzionare senza il Ṣ€€Qper un salvataggio di 4 byte ma lento per riposare.