PNZ (indovina 3 cifre univoche in ordine)

Da una sfida in un libro di programmazione molto tempo fa, PNZ è un gioco in cui l'utente deve indovinare tre cifre univoche nell'ordine corretto.

Regole :

Viene generato un numero casuale di 3 cifre senza cifre ripetute. (Questo è ciò che l'utente sta cercando di indovinare)
L'utente inserisce un'ipotesi di 3 cifre, che deve essere valutata dal programma.
Emetti una "P" per ogni cifra corretta in una posizione corretta.
Emette una "N" per ogni cifra corretta in una posizione errata.
Emette una "Z" solo se nessuna cifra è corretta.
Continuare ad accettare input fino a quando tutte le cifre sono corrette e nella posizione corretta, quindi generare "PPP" seguito dal numero di ipotesi effettuate su una nuova riga.

Nota :

Una "cifra corretta" significa che una delle cifre nell'ipotesi è anche una delle cifre nel numero casuale di 3 cifre.
Un "Posto corretto" significa che è una "cifra corretta" E si trova nello stesso posto del numero casuale a 3 cifre.
L'ordine di emissione dovrebbe essere prima tutto "P", quindi "N" o solo "Z" se nulla è corretto.
Se un ingresso contiene cifre ripetute, "P" è prioritaria rispetto "N" (Esempio: Number: 123 Input: 111 Output: P)
(OPZIONALE) Gli input che non sono esattamente di 3 cifre non devono essere valutati né conteggiati per il totale parziale delle ipotesi

Esempio se le cifre generate erano 123

> 147
P
> 152
PN
> 126
PP
> 123
PPP
4

Esempio se le cifre generate erano 047

> 123
Z
> 456
N
> 478
NN
> 947
PP
> 047
PPP
5

Questo è CodeGolf, quindi vince il programma più corto!

code-golf interactive

— Signor pubblico
fonte

Benvenuti in PPCG! Questa è una grande prima sfida, ma temo che l'abbiamo già fatto. Il gioco è altrimenti noto come Mastermind. Ecco la sfida esistente ma non riesco a decidere se chiudere la vecchia o la nuova. Mi sto inclinando leggermente verso la chiusura, ma lascerò decidere alla comunità.

— Martin Ender,

@ MartinBüttner Ah, questo è il mio male. Sembra un problema abbastanza simile. Concordo con te e lascio decidere alla community.

— Mr Public,

@ MartinBüttner Qual è il criterio qui? In che misura il vecchio dovrebbe avere la precedenza?

— Luis Mendo,

@ MartinBüttner Penso che tra la richiesta delle cifre di essere uniche e la natura interattiva, questa sfida è abbastanza distinta per essere utile.

— AdmBorkBork,

@LuisMendo Penso che non ci siano criteri ufficiali, perché chiudere le vecchie sfide è una cosa abbastanza recente. Il mio criterio personale è "quale sfida è migliore e / o più barebone".

— Martin Ender,

Risposte:

JavaScript (ES6) 184 187 195

Modifica Salvato 8 byte thx @Neil Modifica Salvato 3 byte thx @ user81655

(newline contati come 1 byte)

d=[...'0123456789']
x=[10,9,8].map(l=>d.splice(Math.random()*l,1))
for(c=p=a='';!p[2];++c)g=prompt(a),n=p='',x.map((d,i)=>d-g[i]?~g.search(d)?n+='N':0:p+='P'),a=p+n||'Z'
alert(a+' '+c)

Test

d=[...'0123456789']
x=[10,9,8].map(l=>d.splice(Math.random()*l,1))
for(c=p=a='';!p[2];++c)
  g=prompt(a),
  n=p='',
  x.map((d,i)=>
        d-g[i]?~g.search(d)?n+='N':0:p+='P'
       ),
  a=p+n||'Z'
alert(a+' '+c)

Espandi frammento

— edc65
fonte

Penso che d.splice(v=Math.random()*-~l,1)ti risparmi 5 o forse anche 8 byte (a scapito di alcune prestazioni).

— Neil,

@Neil ho rifiutato la giunzione quando ho iniziato a trovare una soluzione, mi è sembrato lungo. Ora ci riproverò

— edc65,

@ user81655 giusto, grazie. Davvero un cast strano

— edc65,

PowerShell v2 +, 177 231 168 byte

$g=-join(0..9|Random -c 3);for($c=0;$o-ne"PPP";$c++){$n=$p='';$i=read-host;$o=-join(0..2|%{((("","N")[$i.IndexOf($g[$_])-ge0]),"P")[$g[$_]-eq$i[$_]]}|sort -des);($o,"Z")[!$o]}$c

Stranamente, sono stato in grado di giocare a golf la versione fissa per essere più corta rispetto alla versione non fissata ... oO

Mille grazie a @ edc65 per la sua assistenza e ispirazione!

Spiegazione:

$g=-join(0..9|Random -c 3)   # Create an array @(0,1,2,...9) and choose 3 distinct elements
for($c=0;$o-ne"PPP";$c++){   # Loop until output = "PPP", incrementing $count each time
  $i=read-host               # Read input from the user

  $o=-join(0..2|%{((("","N")[$i.IndexOf($g[$_])-ge0]),"P")[$g[$_]-eq$i[$_]]}|sort -des)
       # OK, this is the convoluted part. We're constructing an array of "N", "P", or "",
       # sorting them by descending order (so the P's are first), and then joining them
       # together into a string. The array is constructed by essentially an if/elseif/else
       # statement that is evaluated three times thanks to the 0..2|%{} loop.
       # Starting from the innermost, we choose between "" and "N" based on whether the
       # input number has the current-digit of the secret number somewhere within it. We
       # then choose between that or "P" based on whether it's the _current_ digit of the
       # user input number.

  ($o,"Z")[!$o]
       # Here we output either $o from above or "Z" based on whether $o is empty
}
$c                           # The loop finished (meaning the user guessed), output $count

Esempio di esecuzione:

PS C:\Tools\Scripts\golfing> .\pnz.ps1
123
N
111
Z
222
P
452
PN
562
NN
275
PN
258
PPP
7

— AdmBorkBork
fonte

Come si controlla che le cifre non vengano ripetute?

— edc65,

@ edc65 Uscita corretta. Quello era costoso. Continuo a lavorare sul golf, ma non sono fiducioso ...

— AdmBorkBork,

Sono sicuro che puoi fare di meglio. Sfrutta il fatto che l'ipotesi può avere ripetizioni, ma il numero da indovinare no. Ad esempio, nella mia risposta

— parto

@ edc65 Grazie per l'ispirazione e l'assistenza: la versione fissa è stata più corta della versione non fissa! : D

— AdmBorkBork,

Ora sono tenuto a

— votare

R , 178 166 byte

y=!(s<-sample(48:57,3))
while(any(y!=s)){F=F+1
y<-utf8ToInt(readline())
cat(rep("P",p<-sum(y==s)),rep("N",n<-sum(y%in%s)-p
),if(!(n+p))"Z","
",if(all(y==s))F,sep="")}

Provalo online!

Il collegamento TIO è solo per il conteggio dei byte: prova questo nella tua console R! (o fatemi sapere se esiste un'opzione alternativa).

Vedi la cronologia per la versione meno giocata e più leggibile.

— Jayce
fonte