(ispirato a una domanda su Code Review)

Supponiamo che due persone stiano giocando a Hangman , ma hai sentito per caso il gioco e vuoi disegnare lo stato attuale.

Dato due parole come input, in cui le parole corrispondono [A-Z]+o [a-z]+(a scelta), producono lo stato corrente del gioco dell'impiccato come arte ASCII, seguendo le regole seguenti.

• La prima parola è la parola da indovinare, e la seconda parola sono le lettere già indovinate. Questi possono essere presi come input in qualsiasi ordine.
• La parola da indovinare è garantita non vuota, ma le lettere già indovinate possono essere vuote (cioè, come se fosse l'inizio del gioco).
• Il gioco sarà sempre un gioco dell'impiccato valido (ovvero, le lettere indovinate non verranno duplicate, le lettere non verranno indovinate dopo la fine del gioco, riceverai solo lettere come input, ecc.).
• Sotto il disegno dell'impiccato deve essere la parola da indovinare, con _al posto delle lettere ancora sconosciute, separate da spazi. Ad esempio, se la parola da indovinare era BOAT, allora sotto deve essere il disegno dell'impiccato _ _ _ _. Se la parola era BOATcon Aindovinato, allora sotto deve essere il disegno _ _ A _.
• Sotto la parola da indovinare ci devono essere lettere già indovinate che non sono nella parola. Questi possono essere in qualsiasi ordine e possono essere separati da qualsiasi separatore non alfabetico, se lo si desidera.

Ecco gli stati del gioco dell'impiccato, dall'inizio iniziale alla fine del gioco. Ogni lettera erroneamente indovinata fa avanzare lo stato di una. Quindi la prima lettera erroneamente indovinata fa Oapparire la testa , la successiva fa |apparire il corpo , ecc.

  +---+
  |   |
      |
      |
      |
      |
=========

  +---+
  |   |
  O   |
      |
      |
      |
=========

  +---+
  |   |
  O   |
  |   |
      |
      |
=========

  +---+
  |   |
  O   |
 /|   |
      |
      |
=========

  +---+
  |   |
  O   |
 /|\  |
      |
      |
=========

  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========

  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========

Ingresso

• Due stringhe in qualsiasi formato conveniente , con la prima garantita non vuota.
• Puoi prendere l'input in entrambi gli ordini (es. Parola da indovinare e poi lettere indovinate, o viceversa). Si prega di indicare nell'invio l'ordine di input.

Produzione

La rappresentazione artistica ASCII risultante del gioco dell'impiccato in corso, come descritto sopra, sempre in qualsiasi formato conveniente.

Regole

• Le nuove linee iniziali o finali o gli spazi bianchi sono tutti opzionali, purché i personaggi stessi si allineino correttamente.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

1 #

BOAT e ATG

  +---+
  |   |
  O   |
      |
      |
      |
=========
_ _ A T
G

2 #

ZEPPELIN e

  +---+
  |   |
      |
      |
      |
      |
=========
_ _ _ _ _ _ _ _

3 #

ZEPPELIN e EATOLINSHR

  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========
_ E _ _ E L I N
A T O S H R

# 4

RHYTHM e ABCDE

  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========
_ _ _ _ _ _
EDCBA

# 5

BOAT e ATOB

  +---+
  |   |
      |
      |
      |
      |
=========
B O A T

# 6

AIRPLANE e AJKEI

  +---+
  |   |
  O   |
  |   |
      |
      |
=========
A I _ _ _ A _ E
KJ

Python 2 , 215 192 184 183 byte

^{-8 byte grazie a Raphaël Côté
-1 byte grazie a Jonathan Frech}

a,b=input()
j=' '.join
s=b-set(a)
print"""  +---+
  |   |
  %s   |
 %s%s%s  |
 %s %s  |
      |
=========
"""%tuple('O/|\/\\'[:len(s)].ljust(6)),j(['_',i][i in b]for i in a),'\n',j(s)

Provalo online!

Carbone , 83 69 68 byte

Ｆη¿№θι⁰«ι→⊞υι»←⸿Ｆθ«⎇№ηιι_→»←⸿×=⁸↖=←↑⁵←+←³↓+|ＦＬυ≡ι⁰↓O¹←|²/|³\⁴⸿ /⁵ \«

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: salvato 14 byte passando a switch. Salvato 1 byte stampando il singolo |come valore letterale. Nota: Al momento la questione è stata impostata, switchnon ha funzionato affatto in modalità dettagliata e aveva bisogno di un finale «in modalità succinta (la versione corrente sul TIO ha né bug, in modo che mostra la traduzione succinta come 67 byte), mentre Map's i bug mi hanno impedito di usare Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));. Fortunatamente sono riuscito a trovare un kludge per la stessa lunghezza (e in effetti ho anche provato a passare l'altro loop in una mappa ma anche questo è uscito alla stessa lunghezza). Spiegazione:

Ｆη              For each letter in the guess,
  ¿№θι⁰«        if the word to be guessed does not contain the letter,
        ι→      print the failed guess, leave a gap,
          ⊞υι»  and push the letter to the array.

←⸿              Move to the start of the previous line.

Ｆθ«             For each letter in the word to be guessed,
   ⎇№ηιι        if the letter has been guessed then print it
        _       otherwise print a _.
         →»     Either way, leave a gap.

←⸿              Move to the start of the previous line.

×=⁸             Print 8 =s
   ↖=←          Print a 9th =, moving into position to
      ↑⁵        print 5 |s upwards,
        ←+←³    a + and 3 -s left,
            ↓+| and a + and a | down.

ＦＬυ             Loop once for each incorrect guess.
   ≡ι           Choose what to print based on the loop index.
     ⁰↓O        For the first incorrect guess, print an O.
     ¹←|        For the second incorrect guess, print a |.
     ²/         For the third incorrect guess, print a /.
     ³|\        For the fourth incorrect guess, print a \.
     ⁴⸿ /       For the fifth incorrect guess, print a / on the next line.
     ⁵ \        For the sixth incorrect guess, print another \.

Python 2 , 220 byte

x,y=input()
x=[['_',k][k in y]for k in x]
y-=set(x)
s='''  +---+
  |   |
  0   |
 213  |
 4 5  |
      |
'''
for i in range(6):s=s.replace(`i`,[' ','O|/\\/\\'[i]][len(y)>i])
print s+'='*9+'\n'+' '.join(x)+'\n'+''.join(y)

Provalo online!

-35 byte grazie a Raphaël Côté
-20 byte usando set
-1 byte grazie a micsthepick

Gelatina ,  72  73 byte

+1 correzione di un bug del gioco dell'asso che mostrava la persona impiccata (modificata LNin Lạ6quasi alla fine)

e€a⁸o”_$,ḟ@©K€Y,@“¥[$⁼Ż⁸½c¤ṫȷṃl®ḌvNṂeL©?Ḥ’ṃ“ -¶|O/\=+”¤Y⁶“$"÷ȷñŒ‘ḣ®Lạ6¤¤¦

Un collegamento diadico che prende la parola a sinistra e le lettere (uniche e all'interno del gioco) a destra e restituisce un elenco di caratteri, o un programma completo che prende l'input come argomento della riga di comando e stampa il risultato.

Provalo online!

Come?

In primo luogo:

“¥[$⁼Ż⁸½c¤ṫȷṃl®ḌvNṂeL©?Ḥ’ - base 250 number
                            = 305169639782226039115281574830092231403740634016078676

È il valore numerico della impiccato completa in base 9, in cui ciascuna delle 9 cifre rappresentano uno dei caratteri: <space>, <newline>, -, |, O, /, \, =, o +.

il resto del programma:

e€a⁸o”_$,ḟ@©K€Y,@“...’ṃ“...”¤Y⁶“...‘ḣ®Lạ6¤¤¦ - Main link word, letters
e€                                           - exists in letters for €ach char in word
  a⁸                                         - and with word (word with 0 at un-guessed)
    o”_$                                     - or with '_' (word with _ at un-guessed)
         ḟ@                                  - filter remove (incorrect guesses)
           ©                                 - copy the result to the register and yield
        ,                                    - pair
            K€                               - join €ach with spaces
              Y                              - join with (a) newlines
                            ¤                - nilad followed by link(s) as a nilad:
                 “...’                       - the number described above
                       “...”                 - list of chars " -¶|O/\=+" (¶ = a newline)
                      ṃ                      - base decompress using the chars as digits
               ,@                            - pair (using swapped @rguments)
                             Y               - join with (a) newlines
                                           ¦ - sparse application:
                              ⁶              -   of: a space character
                                             -   to indexes:
                                          ¤  -     nilad followed by links as a nilad:
                               “...‘         -       literal [36,34,28,26,27,19]
                                         ¤   -       another nilad chain:
                                     ®       -         recall from register
                                      L      -         length (# of bad guesses)
                                       ạ6    -         absolute difference with 6
                                    ḣ        -       head (get the indexes to "erase"
                                             -             by applying the space char)
                                             - as a full program: implicit print

Japt v2 , 94 91 83 81 byte

-3 byte da alcune idee dell'approccio di @ETHproductions a questo .
-8 byte usando la rotazione di stringhe su più righe.
-2 byte usando v2.

["+|||||
-
-
-  35
+|01
   24
"r\d_¨VkU l ?S:"O|/\\/\\"gZÃz '=³³¡VøX ?X:'_øVkU]·

Prende entrambi gli input di parole come matrici di caratteri, con la parola indovinando prima e le lettere indovinate in secondo luogo. Le lettere errate sono visualizzate separate da ,s. Quando non ci sono lettere errate, l'ultima riga è vuota (il che significa che l'output contiene una nuova riga finale).

Provalo online!

Spiegazione

Implicito: Ue Vsono array di caratteri di input.

["..."

Avviare un array e spingere la stringa di formato man sospeso, ruotata a sinistra di 90 °.

r\d_

Sostituisci ( r) ogni cifra ( \d) con la seguente funzione:

¨VkU l ?S:"O|/\\/\\"gZÃ

Se la cifra è >=( ¨) la quantità di ipotesi errate ( VkU l), uno spazio ( S), altrimenti, ottiene la parte del corpo appropriata per quella cifra ( "..."gZ).

z '=³³

Ruota l'uomo impiccato di 90 ° a destra e spingi =ripetutamente 3 * 3 ( ³³) volte sull'array.

¡VøX ?X:'_Ã

Sposta la parola per indovinare, con le lettere mappate ( ¡) su Xse stesse ( ) se contenute in V( VøX) o, in _caso contrario, e unite con spazi ( ¸), all'array.

VkU]·

Inserire le lettere indovinate, con le lettere nella parola per indovinare rimosse ( k), nell'array di output. Chiudi l'array e unisciti a newline ( ·).

Rotazione visualizzata:

+|||||      +---+
-           |   |
-      ->   0   |
-  35      213  |
+|01       4 5  |
   24             

05AB1E , 83 byte

•LO„Ÿ¼Ì‘Šη…ÔÆ#δʒΣ•6B4ÝJ"+ -|="‡²¹SK©Ùg"O/|\/\"s£v5y.;}7ô»„==«5ð:¹D²SKDg'_ׇSðý®Sðý»

Provalo online!

La bitmap:

05AB1E , 18 byte

•LO„Ÿ¼Ì‘Šη…ÔÆ#δʒΣ• # Push number described below in base-10.

Provalo online!

Questo spinge il seguente piano bitmap:

1102220
1131113
1151113
1555113
1515113
1111113
4444444

Dove i seguenti byte aggiuntivi:

05AB1E , 13 byte

6B            # Convert to base-6.
  4ÝJ         # Push 01234.
     "+ -|="  # Push that string.
            ‡ # Replace numbers with those letters.

Provalo online!

Sostituisci i pezzi della bitmap con i caratteri appropriati, lasciando i 5 per sostituire i pezzi dell'impiccato in seguito:

  +---+
  |   |
  5   |
 555  |
 5 5  |
      |
=======

L'impiccato:

Quindi, calcoliamo quante volte l'utente ha indovinato errato afferrando le lettere che si trovano nel secondo input, ma non nel primo input:

05AB1E , 6 byte

²¹SK   # Get wrong guesses.
    ©Ù # Store them, and get unique wrong letters.

Provalo online!

Infine, usiamo una bitmap secondaria per sostituire l'uomo impiccato, separandolo da newline e preparandolo per la stampa finale:

05AB1E , 26 byte

g                           # Get the number of "messups".                       
 "O/|\/\"s£                 # Only that many chars of the hanged "bitmap".
           v5y.;}           # Replace 5's with "bitmap".
                 7ô»        # Split into rows.
                    „==«5ð: # Remove additional 5's.

Provalo online!

Ciò si traduce nei primi pezzi, gli unici pezzi rimanenti vengono emessi le due parole in basso in un formato diff ...

Le parole qui sotto:

Stampa la prima parola senza le ipotesi mancanti:

05AB1E , 15 byte

¹D²SK          # Word without the missing guesses.
     Dg'_ׇ    # Replace missing guesses with "_".
           Sðý # Join by spaces.

Provalo online!

05AB1E , 5 byte

®     # Print stored missing guesses.
 Sðý  # Separated by spaces.
    » # Print everything in stack with newlines.

Provalo online!

Stampa le ipotesi perse calcolate da prima memorizzate in un registro.

Gelatina , 86 byte

3ȷ6Dẋ6Ḍ+“Ȧṇ⁹c’
œ-Lḣ@“Ñæçðøþ‘⁵*$€×“µI,’D¤¤S+¢Dị“+-|/\O ”Us7Y,”=x9¤Y;⁷,œ-ðjɓi@€ị³;”_¤K;⁷

Provalo online!

Accidenti ... è stato divertente. Non ho mai usato così tanti ¤personaggi.

Come funziona

3ȷ6Dẋ6Ḍ+“Ȧṇ⁹c’ (1) the literal 300000030000003000000300000030003001222100
3ȷ6              - literal 3*10^6 = 3000000
   D             - digits
    ẋ6           - repeat six times
      Ḍ          - return to integer: 300000030000003000000300000030000003000000
       +         - add
        “Ȧṇ⁹c’   - literal 2998222100

œ-Lḣ@“Ñæçðøþ‘⁵*$€×“µI,’D¤¤S+¢Dị“+-|/\O ”Us7Y,”=x9¤Y,œ-;⁷ð,ɓi@€ị³;”_¤K;⁷
œ-Lḣ@“Ñæçðøþ‘⁵*$€×“µI,’D¤¤S - representation of the body parts
œ-L                           - wrong letters length
   ḣ@                         - get that many elements from the start of
                        ¤¤    - the literal:
     “Ñæçðøþ‘                   - [16, 22, 23, 24, 29, 31]
             ⁵*$€               - 10 to the power of each of them
                 ×              - multiplies by
                  “µI,’D        - the list [6, 4, 3, 5, 4, 5]
                          S   - sum
+¢Dị“+-|/\O ”Us7Y,”=x9¤;⁷  - complete the man
+                           - add
 ¢                          - the literal 3000000...1222100 calculated by link 1
  D                         - digits
   ị“+-|/\O ”               - index into the string “+-|/\O ”
             Us7Y           - reverse, split into lines of 7, join by linefeeds
                 ,          - append
                  ”=x9¤;⁷     - the string “=========”
                       ;⁷    - add a newline
,œ-                 - append missed letters:
,                      - append
 œ-                    - set difference
ð,ɓi@€ị³;”_¤K;⁷     - append the blanks        
ð,ɓ                   - append
   i@€ị³;”_¤            - each letter if it is included in guesses, _ otherwise
            K         - join by spaces  
             ;⁷       - add a newline

C #, 305 296 byte

using System.Linq;w=>g=>{var r=string.Concat(g.Where(c=>!w.Contains(c)));var n=r.Length;return$@"  +---+
  |   |
  {(n>0?"O":" ")}   |
 {(n>2?"/":" ")+(n>1?"|":" ")+(n>3?"\\":" ")}  |
 {(n>4?"/":" ")} {(n>5?"\\":" ")}  |
      |
=========
{string.Join(" ",w.Select(c=>g.Contains(c)?c:'_'))}
"+r;}

Risparmiato 9 byte grazie a @raznagul.

Provalo online!

Versione completa / formattata:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<string, Func<string, string>> f = w=>g=>
        {
            var r = string.Concat(g.Select(c => !w.Contains(c) ? c + "" : ""));
            var n = r.Length;

            return $@"  +---+
  |   |
  {(n > 0 ? "O" : " ")}   |
 {(n > 2 ? "/" : " ") + (n > 1 ? "|" : " ") + (n > 3 ? "\\" : " ")}  |
 {(n > 4 ? "/" : " ")} {(n > 5 ? "\\" : " ")}  |
      |
=========
{string.Join(" ", w.Select(c => g.Contains(c) ? c : '_'))}
" + r;
        };

        Console.WriteLine(f("BOAT")("ATG") + "\n");
        Console.WriteLine(f("ZEPPELIN")("") + "\n");
        Console.WriteLine(f("ZEPPELIN")("EATOLINSHR") + "\n");
        Console.WriteLine(f("RHYTHM")("ABCDE") + "\n");
        Console.WriteLine(f("BOAT")("ATOB") + "\n");

        Console.ReadLine();
    }
}

Questo funziona anche per 314 byte (probabilmente potrebbe essere ancora più breve):

using System.Linq;w=>g=>{var r=string.Concat(g.Select(c=>!w.Contains(c)?c+"":""));var s=$@"  +---+
  |   |
  0   |
 213  |
 4 5  |
      |
=========
{string.Join(" ",w.Select(c=>g.Contains(c)?c:'_'))}
"+r;for(int i=0;i<6;++i)s=s.Replace(i+"",i<r.Length?i<1?"O":i<2?"|":i<3?"/":i<4?"\\":i<5?"/":"\\":" ");return s;}

JavaScript (ES6), 203 196 187 186 185 184 180 177 176 byte

Accetta input come 2 array di singoli caratteri nella sintassi del curry.

a=>g=>`  +---+
  |   |
  1   |
 324  |
 5 6  |
      |
=========
${a.map(x=>g[s="includes"](x)?x:"_")}
`.replace(/\d|,/g,m=>" O|/\\/\\"[!!w[~-m]*~~m],w=g.filter(x=>!a[s](x)))+w

Prova a giocare

o.innerText=(f=
a=>g=>`  +---+
  |   |
  1   |
 324  |
 5 6  |
      |
=========
${a.map(x=>g[s="includes"](x)?x:"_")}
`.replace(/\d|,/g,m=>" O|/\\/\\"[!!w[~-m]*~~m],w=g.filter(x=>!a[s](x)))+w)([...i.value="ZEPPELIN"])([...j.value=""])
oninput=_=>o.innerText=f([...i.value.toUpperCase()])([...j.value.toUpperCase()])

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>Word: </label><input id=i type=password><label for=j>Guesses: </label><input id=j><pre id=o>

Scala , 392 389 byte

Questo potrebbe essere ancora fortemente giocabile a golf.

Questo è all'interno di una funzione che accetta se tcome parametri, con sla parola da indovinare e tla stringa contenente lettere già provate.

var f=s.map(x=>if(t contains x)x else"_") mkString " "
var o="""  +---+
  |   |
  0   |
 213  |
 4 5  |
      |
=========
"""
var c=0
var g=t.filter(x=>if(s contains x){false}else{c match{case 0=>o=o.replace("0","o")
case 1=>o=o.replace("1","|")
case y if y==2|y==5=>o=o.replace(y+"","\\")
case y if y==3|y==4=>o=o.replace(y+"","/")
case _=>()}
c+=1
true})
o.replaceAll("\\d"," ")+f+"\n"+g

EDIT:
-1 byte: t.contains(x) -> t contains x
-1 byte: s.contains(x) -> s contains x
-1 byte:.mkString(" ") -> mkString " "

Provalo online!

PHP 7, 246 byte

for($t="  +---+
  |   |
  1   |
 324  |
 5 6  |
      |
=========
";$c=($w=$argv[1])[$i++];)$t.=strstr($g=$argv[2],$c)?"$c ":"_ ";for($t.="
";$c=$g[$k++];)strstr($w,$c)?:$t.=$c.!++$n." ";for(;$p++<6;)$t=strtr($t,$p," O|/\/\\"[$p>$n?0:$p]);echo$t;

accetta input dagli argomenti della riga di comando. Corri con -nro provalo online .

for($t="  +---+\n  |   |\n  1   |\n 324  |\n 5 6  |\n      |\n=========\n";
    $c=($w=$argv[1])[$i++]; # 1. loop $c through word
)
    $t.=strstr($g=$argv[2],$c)  # if guessed,
        ?"$c ":"_ ";                # then append letter, else append underscore
for($t.="\n";$c=$g[$k++];)  # 2. loop through guesses
    strstr($w,$c)?:             # if not in word
        $t.=$c.!++$n." ";           # add to output, increment $n
for(;$p++<6;)               # 3. loop through possible false guesses
    $t=strtr($t,$p," O|/\/\\"[  # replace digit:
        $p>$n                   # if above no. of wrong guesses
            ?0:$p                   # then with space, else with hangman character
    ]);
echo$t;                     # 4. print