The Nonary Game est un jeu fictif joué dans la trilogie de jeux vidéo du même nom. Votre objectif est de savoir combien de joueurs (au mieux) peuvent échapper à un jeu donné, en aussi peu d'octets que possible.

Règles du jeu

• Il y a 9 joueurs, numérotés de 1 à 9.
• Tous les joueurs commencent dans la même pièce.
• Il existe un certain nombre de portes, chacune avec un nombre de 1 à 9. Il peut y avoir des numéros de porte en double ou manquants.
• Les portes sont des connexions à sens unique entre les chambres. Chaque porte ne peut être utilisée qu'une seule fois .
• Seuls les groupes de 3 à 5 joueurs peuvent franchir une porte.
• Un groupe ne peut franchir une porte que si la somme de ses nombres modulo 9 correspond au numéro modulo 9 de la porte.
• Tout joueur qui passe par une porte 9 s'échappe (gagne).

Exemples

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

<représente le point de départ. Tous les joueurs commencent là.

Dans ce cadre, tout le monde peut s'échapper. Il existe différentes façons d'y parvenir, dont l'une est:

• [1, 2, 3, 4, 5] passe par la porte 6 ((1 + 2 + 3 + 4 + 5)% 9 = 6), tandis que [6, 7, 8, 9] passe par la porte 3 ((6 + 7 + 8 + 9)% 9 = 3). Tout le monde se retrouve dans la deuxième salle.
• [1, 2, 3, 7] passent par la porte 4, tandis que [4, 5, 6, 8, 9] passent par la porte 5.
• [1, 2, 3, 4, 8] passez par l'une des 9 portes, [5, 6, 7, 9] passez par l'autre.

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

Cette fois, au plus 4 personnes peuvent s'échapper:

• [1, 3, 5, 8, 9] passez la porte 8.
• [1, 3, 5, 9] passez la porte 9.

D'autres listes de survivants sont possibles, comme [2, 3, 4] ou [1, 4, 6, 7], mais il n'y a aucun moyen pour plus de 4 personnes de s'échapper.

Le défi

Étant donné une carte, affichez le nombre maximum de joueurs pouvant s'échapper.

• Ne vous inquiétez pas, vous n'avez pas besoin d'analyser mes horribles diagrammes! L'entrée est un graphe orienté étiqueté, que vous pouvez représenter dans n'importe quel format pratique (ensemble de bords, matrice d'adjacence ...).
• Si votre représentation nécessite des étiquettes pour les pièces, vous pouvez utiliser n'importe quel ensemble de valeurs cohérent. Cependant, les portes doivent être représentées par les entiers 1 à 9.
• L'entrée aura toujours au moins une porte 9. Les 9 portes mènent toujours à la sortie, tandis que les autres portes ne le font jamais.
• Votre soumission peut être une fonction ou un programme complet.
• Les failles standard sont interdites.

Cas de test

Les entrées sont affichées sous forme de listes de triplets [numéro de porte, d'une pièce à l'autre], 0 étant la pièce de départ et -1 la sortie. Si vous choisissez d'utiliser un autre format, vous devrez les convertir de manière appropriée.

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 octets

Une version plus lente mais nettement plus courte utilisant des masques de bits au lieu de chaînes.

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

Essayez-le en ligne!

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

JavaScript (ES7),  293 272  271 octets

Prend la saisie dans le format décrit dans le défi. Il s'agit d'une recherche par force brute.

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

Essayez-le en ligne! (le premier cas de test expire sur TIO)

Comment?

Le tableau P[]contient une liste de chaînes décrivant les joueurs dans chaque pièce.

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

Pour chaque pièce Xen position r, nous calculons le pouvoir de X:

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

Pour chaque groupe de joueurs plà-bas et pour chaque porte [d,s,t]à l'index j, nous testons si le groupe est incapable de franchir la porte:

                         // 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

Si le groupe peut passer, nous faisons un appel récursif:

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

Nous gardons une trace du nombre maximum de joueurs évadés met finissons par le retourner.

Gelée , 76 octets

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

Essayez-le en ligne!

Un programme complet prenant un seul argument, un graphe orienté utilisant les salles 1, 2, ... et 0 comme sortie. Renvoie un entier qui est le nombre maximum pouvant s'échapper. Explication complète à suivre.

Devrait fonctionner sans le Ṣ€€Qpour une sauvegarde de 4 octets mais lent à se reposer.