D'un défi dans un livre de programmation il y a longtemps, PNZ est un jeu où l'utilisateur doit deviner trois chiffres uniques dans le bon ordre.

Règles :

1. Un nombre aléatoire à 3 chiffres sans chiffres répétitifs est généré. (C'est ce que l'utilisateur essaie de deviner)
2. L'utilisateur entre une estimation de 3 chiffres, qui doit être évaluée par le programme.
3. Sortez un "P" pour chaque chiffre correct au bon endroit.
4. Sortez un "N" pour chaque chiffre correct dans un endroit incorrect.
5. N'émettez un "Z" que si aucun chiffre n'est correct.
6. Continuez à accepter les entrées jusqu'à ce que tous les chiffres soient corrects et au bon endroit, puis sortez "PPP" suivi du nombre de suppositions qu'il a fallu sur une nouvelle ligne.

Remarque :

• Un «chiffre correct» signifie que l'un des chiffres de la supposition est également l'un des chiffres du nombre aléatoire à 3 chiffres.

• Un «endroit correct» signifie qu'il s'agit d'un «chiffre correct» ET qu'il est au même endroit que le nombre aléatoire à 3 chiffres.

• L'ordre de sortie doit être tout d'abord "P", puis "N" ou seulement "Z" si rien n'est correct.

• Si une entrée contient des chiffres répétés, « P » est prioritaire sur « N » (Exemple: Number: 123 Input: 111 Output: P)

• (FACULTATIF) Les entrées qui ne sont pas exactement de 3 chiffres ne doivent pas être évaluées ni prises en compte dans le total cumulé des suppositions

Exemple si les chiffres générés étaient 123

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

Exemple si les chiffres générés étaient 047

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

C'est CodeGolf, donc le programme le plus court gagne!

JavaScript (ES6) 184 187 195

Modifier les octets enregistrés thx @Neil Modifier les octets enregistrés thx @ user81655

(les nouvelles lignes comptent pour 1 octet)

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)

Tester

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)

PowerShell v2 +, 177 231 168 octets

$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

Curieusement, j'ai pu jouer à la version fixe pour être plus courte que la version non fixe ... oO

Un grand merci à @ edc65 pour son aide et son inspiration!

Explication:

$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

Exemple d'exécution:

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

R , 178 166 octets

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="")}

Essayez-le en ligne!

Le lien TIO est juste pour le nombre d'octets - essayez ceci dans votre console R! (ou faites-moi savoir s'il existe une autre option).

Consultez l'historique pour une version moins ludique et plus lisible.