Keep Talking and Nobody Explodes est un jeu multijoueur local où un joueur a le contrôle d'une "bombe" virtuelle, et doit être guidé par un autre joueur, "l'expert", qui a accès à un manuel de désamorçage de bombe. L'un des modules à désarmer dans le jeu est le module clavier, c'est ce que nous allons traiter dans ce défi.

La tâche

L'entrée commencera par une seule ligne de caractères ASCII imprimables à l'exception de l'espace (0x21 à 0x7E). Ils représentent les boutons du clavier visibles pour vous.

Les quelques lignes suivantes représenteront des "clés" - une seule ligne contiendra tous les caractères de la première ligne, pas nécessairement dans l'ordre. Votre tâche consiste à sortir les caractères du clavier, dans l'ordre de la ligne de touches correspondante.

Par exemple, si l'entrée était

5~Fy
HrD7K!#}
Ui%^fHnF
)Tf;y~I5
~Fi(&5gy
,'Xd#5fZ

puis les touches du clavier sont 5, ~, Fet y. Seule la 4ème ligne de touche ~Fi(&5gycontient tous ces caractères, nous sortons donc les caractères du clavier dans l'ordre dans lequel ils apparaissent, c'est-à-dire ~F5y.

Règles et clarifications

• L'entrée doit être une seule chaîne multiligne, avec les touches du clavier et les lignes de touches sur des lignes distinctes.
• Il y aura exactement une ligne de touches contenant tous les caractères du clavier.
• Chaque ligne, c'est-à-dire la ligne initiale du clavier et les lignes de touches suivantes, n'aura pas de caractères en double.
• Contrairement au jeu, vous ne pouvez rien supposer du nombre de caractères du clavier, de la longueur de chaque ligne de touche ou du nombre de lignes de touche. Cependant, toutes les lignes clés sont garanties pour avoir la même longueur.
• La sortie peut contenir une seule nouvelle ligne de fin facultative. De même, vous pouvez supposer dans les deux cas un retour à la ligne facultatif dans l'entrée, mais veuillez spécifier dans votre réponse si vous avez besoin de l'hypothèse.
• Bien que cela semble déjà être une pratique courante , je dirai explicitement: terminer avec une erreur est correct pour ce défi, tant que la sortie STDOUT est correcte (si c'est la forme de sortie que vous avez choisie). Espérons que cela facilitera la gestion des entrées.

Cas de test

7
4?j01C3"ch
KP.OG>QB)[
z#)Kn"I2&.
]#,D|sBFy5
Qzj*+~7DLP

Sortie: 7 . Seule la dernière ligne contient un 7.

0b~
Ob+hy{M|?;>=dtszPAR5
*8rCfsw|3O9.7Yv^x>Hq
$ip.V@n}|La:TbIt^AOF
jZ[Ec4s0|%b*$id',~J6
z*#b}-x$Ua&!O2;['T+?
NVj_X8rlhxfnS\.z}];c
bykscf.w^dnWj+}-*2g_
VP`AJH|&j5Yqmw/"9IMc

Sortie : 0b~. La 4ème ligne clé contient déjà les caractères dans le bon ordre.

MTuz
bIAr>1ZUK`s9c[tyO]~W
oMGIi/H&V"BeNLua%El=
j*uYbplT:~);BM|_mPZt
Q}z5TC@=6pgr<[&uJnM%
YOA(F~_nH6T{%B7[\u#5
y&t"8zQn{wo5[Idu4g:?
[0tZG"-fm!]/|nqk,_2h
dA&C.+(byo6{7,?I}D@w

Sortie : zTuM. La ligne clé est la 4ème, bien que la 3ème ligne clé soit un échec serré.

o@nj<G1
f]?-<I6h2vS*%l=:}c8>LK5rMdyeon,;sE[@m(73
ibhp+2Hq6yKzIf_Zo}EO3-[*0/e&Fvd]wQU=|%`C
;}>d'cg~CPtQG&%L\)MUl419bkTZ7@]:[*H"RyYj
L^<:zXJ#kj$EFlwN%B`Dd,Cs?]xRZ*K9-uQ.@&f+
i1v'7:90R-l}FMxj`,DTWK+(n32Z4Vs[p@%*eS!d
B|^Ti/ZG$}ufL9*wE[AVt]P7CrX-)2JpD<sYxd6O
ex.$4#KarS^j+'_!B"]H[\83:(DCXUgI*Lct?qAR
^GXQoy*KW&v}n']Em~\N9)fxP(qC=7#4sRdcD6%5
;inr[&$1j_!F~@pzo#blv]}<'|fRds6OW%tEg"G2
e;0T#gfo^+!:xHDN&4V=In?AwhEv$2Fd~ZLz_\81

Sortie : n1j@o<G. La ligne clé est l'avant-dernière ligne.

Notation

C'est du code-golf , donc le code dans le moins d'octets gagne.

CJam, 13 12 octets

qN/(f&{,}$W=

Testez-le ici.

Explication

q     e# Read all input.
N/    e# Split into lines.
(     e# Pull off the keypad buttons.
f&    e# Take the set intersection of each key line with the keypad, preserving the order
      e# order in the key line.
{,}$  e# Sort the results by length.
W=    e# Pick the last (longest) one.

Pyth, 10

@zhf!-zT.z

Essayez-le en ligne

Explication

@zhf!-zT.z         ##  z = first line of input, .z = list of rest of lines
   f    .z         ##  Filter .z as T based on
    !-zT           ##  Whether removing all the letters from z that appear in T leaves an
                   ##  Empty string or not (keep the ones that give empty strings)
  h                ##  Take the first such line (necessary indexing, shouldn't ever matter)
@z                 ##  @ is setwise intersection. Pyth implements this by iterating over
                   ##  each element of the second argument and keeping values that appear
                   ##  in the first argument, which gives the intended result

Pyth, 9 octets

eolN@Lz.z

Manifestation

@Lz.z: Filtre toutes les lignes de l'intersection avec la première ligne.

olN: Trier par longueur

e: Prenez le plus longtemps.

Haskell, 49 octets

g(!)(a:b)=[c|d<-b,all(!d)a,c<-d,c!a]
g elem.lines

La première ligne définit une fonction d'aide g, la fonction sans nom sur la deuxième ligne est ma réponse.

Explication

L'algorithme est le plus évident: divisez l'entrée en lignes, trouvez la ligne qui contient tous les caractères de la première ligne et filtrez tous les autres caractères de cette ligne.

g(!)(a:b)=                            -- g gets a binary function ! and list of strings a:b
          [c|                         -- and returns the string of characters c where
             d<-b,all(!d)a,           -- d is drawn from b and x!d holds for all x in a,
                           c<-d,c!a]  -- and c is drawn from d and c!a holds.
g elem.lines                          -- The input is split into lines and fed to g elem;
                                      -- then x!d means x `elem` d in the above.

Prolog, 204 190 octets

Cela aurait pu être un beau défi pour Prolog s'il n'y avait pas eu les exigences combinées de l'entrée multiligne et des caractères non échappés 'et "dans l'entrée. Un gros morceau du code (p et r) existe pour lire un fichier en tant que caractère codes qui était ce que je devais faire pour prendre une entrée non échappée sur plusieurs lignes.

Si seulement "existait comme un caractère non échappé, je pourrais lire l'entrée comme une chaîne.
Si seulement" existait comme un caractère non échappé, je pourrais lire l'entrée comme un atome.
Si l'entrée n'était pas multiligne, disons séparée par un espace à la place, je pourrais la lire comme une seule ligne pour les codes.

r(I,[H|T]):-read_line_to_codes(I,H),H\=end_of_file,r(I,T).
r(_,[]).
q(_,[]).
q(E,[H|T]):-subset(E,H),intersection(H,E,X),writef("%s",[X]);q(E,T).
p:-open("t",read,I),r(I,[H|T]),q(H,T),!.

Comment ça fonctionne

1. Ouvre le fichier t (qui contient toutes les entrées) à lire
2. Lire toutes les lignes sous forme de codes de caractères et les placer dans une liste de listes (1 liste par ligne)
3. Récursive sur les listes de queue et vérifie si la liste d'en-tête existe en tant que sous-ensemble de cette liste
4. Intersecte la liste correspondante avec la tête pour obtenir les caractères recherchés dans le bon ordre
5. Solution d'impression

Comment exécuter le
programme est exécuté avec la commande:
p.
Le fichier nommé t contenant l'entrée doit se trouver dans le même répertoire.

Edit: enregistré 14 octets en unifiant 2 clauses q avec OR.

MATLAB, 107 octets

b=char(strsplit(char(inputdlg),' '));[~,x]=ismember(b,b(1,:));[~,f]=min(abs(1./sum(~x')-1));b(f,(~~x(f,:)))

Cela a fini par être un morceau de code très bâclé ...

Lors de son exécution, une boîte de dialogue d'entrée est ouverte dans laquelle une chaîne multi-lignes peut être collée (les sauts de ligne sont convertis en espaces et la sortie sera une cellule avec 1 chaîne très longue). J'ai choisi de convertir la cellule résultante en un caractère qui permet de diviser les espaces (le résultat est un tableau de cellules), puis de nouveau convertir en caractère pour récupérer la forme souhaitée. La fonction ismember intégrée de MATLAB fait un bon travail ici en comparant notre première ligne aux autres lignes.

Après cela, ça devient désagréable ... J'ai essayé de nombreuses façons d'exclure la première ligne de mon contrôle de «meilleure correspondance» et je me suis retrouvé avec ça. Nous recherchons la ligne, puis utilisons ces informations pour saisir les indices (en convertissant notre ismember sortie Logicals) que nous voulons que nos personnages de sortie de.

Langue Wolfram 106 octets

c=Characters[InputString[]~StringSplit~"\n"];o=c[[1]];t=Select;t[t[Rest@c,#~SubsetQ~o&][[1]],o~MemberQ~#&]

Exemple d'entrée:

Production:

Explication du code: D'abord avec InputString, nous obtenons la chaîne complète d'entrée, puis nous obtenons le premier ensemble de lettres en divisant la chaîne par un saut de ligne et en enregistrant tous les caractères de la première dans la variable o. Ensuite, nous sélectionnons dans le reste des lignes d'entrée les lignes qui ont les caractères de la première ligne (enregistrés comme variable o) comme sous-ensemble. Ensuite, avec cette ligne sélectionnée, nous récupérons les membres de cette ligne qui se trouvent dans l'ensemble d'origine.

Edit: Merci à Martin Büttner pour les conseils sur l'utilisation de la notation infixe et mes variables inutiles

Python 2, 112 octets

import sys
i=sys.stdin.readlines()
print[''.join(c for c in l if c in i[0])for l in i[1:]if set(i[0])<set(l)][0]

Exemple d'exécution: Ideone

Javascript (ES6), 107 104 102 octets

Démo d'extraits pour la prise en charge des navigateurs.

f=x=>([a]=x.split`
`).map(y=>[...y].filter(z=>~a.indexOf(z)-x).join(x='')).find(z=>z.length==a.length)

<textarea id="i" rows="6" cols="45">o@nj<G1
f]?-<I6h2vS*%l=:}c8>LK5rMdyeon,;sE[@m(73
ibhp+2Hq6yKzIf_Zo}EO3-[*0/e&Fvd]wQU=|%`C
;}>d'cg~CPtQG&%L\)MUl419bkTZ7@]:[*H"RyYj
L^<:zXJ#kj$EFlwN%B`Dd,Cs?]xRZ*K9-uQ.@&f+
i1v'7:90R-l}FMxj`,DTWK+(n32Z4Vs[p@%*eS!d
B|^Ti/ZG$}ufL9*wE[AVt]P7CrX-)2JpD<sYxd6O
ex.$4#KarS^j+'_!B"]H[\83:(DCXUgI*Lct?qAR
^GXQoy*KW&v}n']Em~\N9)fxP(qC=7#4sRdcD6%5
;inr[&$1j_!F~@pzo#blv]}<'|fRds6OW%tEg"G2
e;0T#gfo^+!:xHDN&4V=In?AwhEv$2Fd~ZLz_\81</textarea><br /><input type="button" onclick="o.value=f(i.value)" value="Run"> Output: <input type="text" id="o" readonly />

Commenté:

f=x=>
([a]=x.split('\n')) // split input by newlines, assign first value to a
.map(y=> // map function to each line
    [...y].filter(z=> // filter characters
        ~a.indexOf(z)-x // a has character z and not the first item (x is still set)
    ).join(x='') // join characters with empty string, reset x flag
).find(z=>z.length==a.length) // return string with same length as a