(inspirado por una pregunta sobre la revisión de código)

Supongamos que dos personas están jugando al Ahorcado , pero solo has escuchado el juego y quieres dibujar el estado actual.

Dadas dos palabras como entrada, donde las palabras coinciden [A-Z]+o [a-z]+(a su elección), muestran el estado actual del juego del ahorcado como arte ASCII, siguiendo las siguientes reglas.

• La primera palabra es la palabra a adivinar, y la segunda palabra son las letras ya adivinadas. Estos pueden tomarse como entrada en cualquier orden.
• La palabra a adivinar está garantizada como no vacía, pero las letras ya adivinadas pueden estar vacías (es decir, como si fuera el comienzo del juego).
• El juego siempre será un juego de ahorcado válido (es decir, las letras adivinadas no se duplicarán, las letras no se adivinarán más allá del final del juego, solo recibirá letras como entrada, etc.).
• Debajo del dibujo del ahorcado debe estar la palabra a adivinar, _en lugar de letras aún desconocidas, separadas por espacios. Por ejemplo, si la palabra a adivinar era BOAT, entonces debajo del dibujo del ahorcado debe estar _ _ _ _. Si la palabra fue BOATcon Aadivinado, a continuación, debajo del dibujo debe ser _ _ A _.
• Debajo de la palabra a adivinar debe haber letras ya adivinadas que no están en la palabra. Estos pueden estar en cualquier orden y pueden estar separados por cualquier separador no alfabético, si así se desea.

Estos son los estados del juego del ahorcado, desde el inicio inicial hasta el final del juego. Cada letra adivinada erróneamente avanza el estado en uno. Entonces, la primera letra adivinada erróneamente hace Oaparecer la cabeza , la siguiente hace |aparecer el cuerpo , etc.

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

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

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

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

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

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

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

Entrada

• Dos cadenas en cualquier formato conveniente , con la primera garantizada no vacía.
• Puede tomar la entrada en cualquier orden (por ejemplo, palabra para adivinar y luego letras adivinadas, o viceversa). Indique en su envío el orden de entrada.

Salida

La representación de arte ASCII resultante del juego del ahorcado en progreso, como se describió anteriormente, nuevamente en cualquier formato conveniente.

Reglas

• Las nuevas líneas o espacios en blanco iniciales o finales son opcionales, siempre que los caracteres se alineen correctamente.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

# 1

BOAT y ATG

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

# 2

ZEPPELIN y

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

# 3

ZEPPELIN y EATOLINSHR

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

# 4

RHYTHM y ABCDE

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

# 5

BOAT y ATOB

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

# 6

AIRPLANE y AJKEI

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

Python 2 , 215 192 184 183 bytes

^{-8 bytes gracias a Raphaël Côté
-1 byte gracias 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)

Pruébalo en línea!

Carbón , 83 69 68 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: guardado 14 bytes al cambiar a switch. Se guardó 1 byte imprimiendo el single |como literal. Nota: En el momento de definir la cuestión, switchno funcionaba en absoluto en modo detallado y necesitaba un arrastre «en modo sucinto (la versión actual de TIO tiene ni fallo, por lo que muestra la traducción sucinta como 67 bytes), mientras que Map's los errores me impidieron usar Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));. Afortunadamente, logré crear un kludge para la misma longitud (y de hecho también intenté cambiar el otro bucle a un Mapa, pero también salió a la misma longitud). Explicación:

Ｆη              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 bytes

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)

Pruébalo en línea!

-35 bytes gracias a Raphaël Côté
-20 bytes usando conjuntos
-1 byte gracias a micsthepick

Jalea ,  72  73 bytes

+1 arreglando un error del juego de as que mostraba a la persona colgada por completo (cambiado LNa Lạ6casi el final)

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

Un enlace diádico que toma la palabra a la izquierda y las letras (únicas y dentro del juego) a la derecha y devuelve una lista de caracteres, o un programa completo que toma la entrada como argumentos de línea de comando e imprime el resultado.

Pruébalo en línea!

¿Cómo?

En primer lugar:

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

Es el valor numérico del ahorcado completa en la base 9, donde cada uno de los 9 dígitos representan uno de los personajes: <space>, <newline>,- , |, O, /, \, =, o +.

El resto del programa:

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 bytes

-3 bytes de algunas ideas del enfoque de @ETHproductions para esto .
-8 bytes mediante la rotación de cadenas multilínea.
-2 bytes usando v2.

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

Toma ambas entradas de palabras como matrices de caracteres, con la palabra de adivinanza primero y las letras adivinadas en segundo lugar. Las letras incorrectas se muestran separadas por ,s. Cuando no hay letras incorrectas, la última línea está en blanco (lo que significa que la salida contiene una nueva línea final adicional).

Pruébalo en línea!

Explicación

Implícito: Uy Vson matrices de entrada de caracteres.

["..."

Inicie una matriz y empuje la cadena de formato de hombre colgado, girada a la izquierda 90 °.

r\d_

Reemplazar (r ) cada dígito ( \d) con la siguiente función:

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

Si el dígito es >=( ¨) la cantidad de conjeturas incorrectas ( VkU l), un espacio (S ), de lo contrario, obtenga la parte del cuerpo adecuada para ese dígito ( "..."gZ).

z '=³³

Gire al ahorcado 90 ° hacia la derecha y empuje = repetidamente 3 * 3 ( ³³) veces hacia la matriz.

¡VøX ?X:'_Ã

Empuje la palabra para adivinar, con letras asignadas ( ¡) a sí mismas ( X) si están contenidas en V( VøX), o_ si no, y unidas con espacios ( ¸), a la matriz.

VkU]·

Empuje las letras adivinadas, con las letras en la palabra para adivinar eliminadas (k ), a la matriz de salida. Cierre la matriz y únase con nuevas líneas ( ·).

Rotación visualizada:

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

05AB1E , 83 bytes

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

Pruébalo en línea!

El mapa de bits:

05AB1E , 18 bytes

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

Pruébalo en línea!

Esto empuja el siguiente plan de mapa de bits:

1102220
1131113
1151113
1555113
1515113
1111113
4444444

Donde los siguientes bytes adicionales:

05AB1E , 13 bytes

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

Pruébalo en línea!

Reemplace las piezas del mapa de bits con los caracteres apropiados, dejando los 5 para reemplazar las piezas del verdugo más tarde:

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

El Ahorcado:

A continuación, calculamos cuántas veces el usuario adivinó mal al tomar las letras que están en la segunda entrada, pero no en la primera entrada:

05AB1E , 6 bytes

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

Pruébalo en línea!

Finalmente, usamos un mapa de bits secundario para sustituir al ahorcado, separándolo por nuevas líneas y preparándolo para la impresión final:

05AB1E , 26 bytes

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.

Pruébalo en línea!

Esto da como resultado las primeras piezas, las únicas piezas restantes emiten las dos palabras en la parte inferior en formato diff ...

Las palabras de abajo:

Imprime la primera palabra sin las conjeturas que faltan:

05AB1E , 15 bytes

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

Pruébalo en línea!

05AB1E , 5 bytes

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

Pruébalo en línea!

Imprima las conjeturas perdidas calculadas de antes que almacenamos en un registro.

Jalea , 86 bytes

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

Pruébalo en línea!

Menos mal ... esto fue divertido. Nunca he usado tantos ¤personajes.

Cómo funciona

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 bytes

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;}

Svaed 9 bytes gracias a @raznagul.

Pruébalo en línea!

Versión completa / formateada:

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();
    }
}

Esto también funciona para 314 bytes (probablemente podría ser aún más corto):

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 bytes

Toma la entrada como 2 matrices de caracteres individuales en la sintaxis de 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

Intenta jugarlo

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 bytes

Esto aún podría ser muy golfable.

Esto está dentro de una función que toma sy tcomo parámetros, con sla palabra para adivinar y tla cadena que contiene letras ya probadas.

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

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

Pruébalo en línea!

PHP 7, 246 bytes

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;

toma datos de los argumentos de la línea de comandos. Ejecutar -nro probarlo en línea .

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