Keep Talking and Nobody Explodes è un gioco multiplayer locale in cui un giocatore ha il controllo di una "bomba" virtuale e deve essere guidato da un altro giocatore, l '"esperto", che ha accesso al manuale di disinnesco della bomba. Uno dei moduli da disarmare nel gioco è il modulo tastiera, che è ciò di cui ci occuperemo in questa sfida.

L'obiettivo

L'input inizierà con una singola riga di caratteri ASCII stampabili tranne lo spazio (da 0x21 a 0x7E). Questi rappresentano i pulsanti della tastiera visibili all'utente.

Le prossime righe rappresenteranno "chiavi" - solo una riga conterrà tutti i caratteri della prima riga, non necessariamente in ordine. Il tuo compito è quello di emettere i caratteri della tastiera, nell'ordine della riga chiave corrispondente.

Ad esempio, se l'input era

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

poi i pulsanti del tastierino sono 5, ~, Fe y. Solo la quarta riga di tasti ~Fi(&5gycontiene tutti questi caratteri, quindi emettiamo i caratteri della tastiera nell'ordine in cui appaiono, ad es ~F5y.

Regole e chiarimenti

• L'input deve essere una singola stringa multilinea, con i pulsanti della tastiera e le linee chiave su linee separate.
• Ci sarà esattamente una riga chiave che contiene tutti i caratteri della tastiera.
• Ogni riga, ovvero la riga iniziale della tastiera e le seguenti righe chiave, non avrà caratteri duplicati.
• A differenza del gioco, non puoi assumere nulla riguardo al numero di caratteri della tastiera, alla lunghezza di ciascuna linea di tasti o al numero di linee di tasti. Tuttavia, tutte le linee chiave hanno la stessa lunghezza.
• L'output può contenere una nuova riga finale finale facoltativa. Allo stesso modo puoi assumere in entrambi i casi una newline finale facoltativa nell'input, ma specifica nella tua risposta se hai bisogno dell'ipotesi.
• Anche se questa sembra già essere una pratica comune , lo dirò esplicitamente: terminare con un errore va bene per questa sfida, purché l'output STDOUT sia corretto (se questa è la forma di output scelta). Speriamo che questo renda più facile la gestione degli input.

Casi test

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

Uscita: 7 . Solo l'ultima riga contiene a 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

Uscita : 0b~. La quarta riga chiave contiene già i caratteri nell'ordine giusto.

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

Uscita : zTuM. La linea chiave è la quarta, anche se la terza linea chiave manca molto.

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

Uscita : n1j@o<G. La riga chiave è la seconda ultima riga.

punteggio

Questo è code-golf , quindi vince il codice nel minor numero di byte.

CJam, 13 12 byte

qN/(f&{,}$W=

Provalo qui.

Spiegazione

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

Provalo online

Spiegazione

@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 byte

eolN@Lz.z

Dimostrazione

@Lz.z: Filtra tutte le linee per l'intersezione con la prima linea.

olN: Ordina per lunghezza

e: Impiega più tempo.

Haskell, 49 byte

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

La prima riga definisce una funzione di supporto g, la funzione senza nome sulla seconda riga è la mia risposta.

Spiegazione

L'algoritmo è quello ovvio: dividere l'input in righe, trovare la riga che contiene tutti i caratteri della prima riga e filtrare tutti gli altri caratteri su quella riga.

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 byte

Questa potrebbe essere stata una bella sfida per Prolog se non fosse stato per i requisiti combinati di input multilinea e caratteri senza caratteri di escape "e" nell'input. Esiste un grosso pezzo di codice (p e r) per leggere un file come carattere codici che è quello che dovevo fare per accettare input senza caratteri di escape su più righe.

Se solo esistesse come carattere senza caratteri di escape, potrei leggere l'input come una stringa.
Se solo "esistesse come carattere senza caratteri di escape, potrei leggere gli input come un atomo.
Se l'input non fosse multilinea, diciamo separato da spazio, potrei leggerlo come una riga di codici.

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),!.

Come funziona

1. Apre il file t (che contiene tutti gli input) da leggere
2. Leggi tutte le righe come codici carattere e inseriscile in un elenco di elenchi (1 elenco per riga)
3. Esamina gli elenchi di coda e verifica se l'elenco di intestazioni esiste come sottoinsieme di tale elenco
4. Interseca l'elenco corrispondente con la testa per ottenere i personaggi desiderati nell'ordine corretto
5. Stampa la soluzione

Come eseguire Il
programma viene eseguito con il comando:
p.
Il file con nome t contenente l'input deve trovarsi nella stessa directory.

Modifica: salvato 14 byte unificando 2 clausole q con OR.

MATLAB, 107 byte

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

Questo ha finito per essere un pezzo di codice molto sciatto ...

Durante l'esecuzione, viene aperta una finestra di dialogo di input in cui è possibile incollare una stringa multilinea (le nuove righe vengono convertite in spazi e l'output sarà una cella con 1 stringa molto lunga). Ho scelto di convertire la cella risultante in un carattere che rende possibile la divisione negli spazi (il risultato è un array di celle) e quindi di nuovo la conversione in carattere per recuperare la forma desiderata. La funzione ismember integrata di MATLAB fa un buon lavoro qui nel confrontare la nostra prima linea con le altre linee.

Dopo di che diventa brutto ... Ho provato molti modi per escludere la prima riga dal mio controllo "miglior abbinamento" e ho finito con questo. Guardiamo per la linea e quindi utilizzare queste informazioni per afferrare gli indici (convertendo il nostro IsMember uscita a Logicals) che vogliamo che i nostri personaggi in uscita da.

Lingua Wolfram 106 byte

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

Esempio di input:

Produzione:

Spiegazione del codice: prima con InputString otteniamo l'intera stringa di input, quindi otteniamo il primo set di lettere suddividendo la stringa per newline e salvando tutti i caratteri del primo nella variabile o. Successivamente, selezioniamo dal resto delle righe di input quelle righe che hanno i caratteri della prima riga (salvati come variabile o) come sottoinsieme. Quindi con quella linea selezionata, prendiamo i membri di quella linea che si trovano nel set originale.

Modifica: grazie a Martin Büttner per i suggerimenti sull'uso della notazione infissa e delle mie variabili non necessarie

Python 2, 112 byte

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]

Esempio di esecuzione: Ideone

Javascript (ES6), 107 104 102 byte

Demo dello snippet per i browser di supporto.

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

ha commentato:

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