(inspirado em uma pergunta sobre Code Review)

Suponha que duas pessoas estejam jogando carrasco , mas você só ouviu o jogo e deseja desenhar o status atual.

Dadas duas palavras como entrada, onde as palavras correspondem [A-Z]+ou [a-z]+(sua escolha), produz o estado atual do jogo da forca como arte ASCII, seguindo as regras abaixo.

• A primeira palavra é a palavra a ser adivinhada, e a segunda palavra são as letras já adivinhadas. Eles podem ser tomados como entrada em qualquer ordem.
• A palavra a ser adivinhada é garantida como não vazia, mas as letras já adivinhadas podem estar vazias (ou seja, como se fosse o início do jogo).
• O jogo sempre será um jogo da forca válido (ou seja, as letras adivinhadas não serão duplicadas, as letras não serão adivinhadas após o final do jogo, você receberá apenas letras como entrada, etc.).
• Abaixo do desenho da forca, deve haver a palavra a ser adivinhada, com _letras no lugar ainda desconhecidas, separadas por espaços. Por exemplo, se a palavra a ser adivinhada era BOAT, abaixo do desenho da forca deve estar _ _ _ _. Se a palavra foi BOATcom Aadivinhou, em seguida, seguir o desenho deve ser _ _ A _.
• Abaixo da palavra a ser adivinhada, deve haver letras já adivinhadas que não estão na palavra. Eles podem estar em qualquer ordem e podem ser separados por qualquer separador não alfabético, se desejado.

Aqui estão os estados do jogo da forca, do início ao fim do jogo. Cada letra adivinhada incorretamente avança o estado em um. Assim, a primeira letra incorretamente adivinhada faz a cabeça Oaparecer, a próxima faz o corpo |aparecer, etc.

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

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

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

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

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

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

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

Entrada

• Duas strings em qualquer formato conveniente , com a primeira garantida não vazia.
• Você pode receber a entrada em qualquer ordem (por exemplo, palavra para adivinhar e depois adivinhar letras ou vice-versa). Indique no seu envio a ordem de entrada.

Saída

A representação artística ASCII resultante do jogo da forca em andamento, como descrito acima, novamente em qualquer formato conveniente.

Regras

• Novas linhas à esquerda ou à direita ou espaços em branco são opcionais, desde que os próprios caracteres estejam alinhados corretamente.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• Lacunas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

# 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 bytes

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

Experimente online!

Carvão , 83 69 68 bytes

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

Experimente online! Link é a versão detalhada do código. Editar: salvou 14 bytes mudando para switch. Economizou 1 byte imprimindo o single |como um literal. Nota: Na época, a questão foi definida, switchnão funcionou em tudo no modo detalhado e precisava de uma fuga «no modo sucinto (a versão atual no TIO tem nem erro, para que ele mostre a tradução sucinta como 67 bytes), enquanto Map's erros me impediram de usar Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));. Felizmente, consegui criar um kludge do mesmo tamanho (e, de fato, também tentei mudar o outro loop para um mapa, mas ele também saiu do mesmo comprimento). Explicação:

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

Experimente online!

-35 bytes graças ao Raphaël Côté
-20 bytes usando conjuntos
-1 byte graças ao micsthepick

Geléia ,  72  73 bytes

+1 corrigindo um bug do jogo ás que mostrava a pessoa enforcada completa (alterada LNpara Lạ6quase no final)

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

Um link diádico que pega a palavra à esquerda e as letras (exclusivas e dentro do jogo) à direita e retorna uma lista de caracteres, ou um programa completo que aceita a entrada como argumentos da linha de comando e imprime o resultado.

Experimente online!

Quão?

Primeiramente:

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

É o valor numérico da pessoa enforcado completo na base 9, onde cada um dos 9 dígitos representam um dos personagens: <space>, <newline>, -, |, O, /, \, =, ou+ .

o restante do 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 algumas idéias da abordagem do @ETHproductions .
-8 bytes usando a rotação de cadeia de linhas múltiplas.
-2 bytes usando v2.

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

Pega as duas entradas de palavras como matrizes de caracteres, com a palavra de adivinhação primeiro e as letras adivinhadas em segundo. Letras incorretas são mostradas separadas por ,s. Quando não há letras incorretas, a última linha fica em branco (o que significa que a saída contém uma nova linha à direita).

Experimente online!

Explicação

Implícito: Ue Vsão matrizes de caracteres de entrada.

["..."

Inicie uma matriz e empurre a corda de formato suspenso, girada para a esquerda 90 °.

r\d_

Substitua ( r) todos os dígitos ( \d) pela seguinte função:

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

Se o dígito for >=( ¨) a quantidade de suposições incorretas ( VkU l), um espaço ( S), caso contrário, obtenha a parte do corpo apropriada para esse dígito ( "..."gZ).

z '=³³

Gire o homem pendurado 90 ° para a direita e empurre =3 * 3 ( ³³) vezes repetidas para a matriz.

¡VøX ?X:'_Ã

Empurre a palavra para adivinhar, com letras mapeadas ( ¡) para si mesmas ( X) se contidas em V( VøX) ou, _se não estiverem, e unidas a espaços ( ¸), na matriz.

VkU]·

Empurre as letras adivinhadas, com as letras da palavra a adivinhar removidas ( k), para a matriz de saída. Feche a matriz e junte-se às novas linhas (· ).

Rotação 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ðý»

Experimente online!

O bitmap:

05AB1E , 18 bytes

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

Experimente online!

Isso envia o seguinte plano de bitmap:

1102220
1131113
1151113
1555113
1515113
1111113
4444444

Onde os seguintes bytes adicionais:

05AB1E , 13 bytes

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

Experimente online!

Substitua as partes do bitmap pelos caracteres apropriados, deixando os 5 para substituir as partes do carrasco mais tarde:

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

O homem enforcado:

Em seguida, calculamos quantas vezes o usuário adivinhou errado pegando as letras que estão na segunda entrada, mas não na primeira entrada:

05AB1E , 6 bytes

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

Experimente online!

Finalmente, usamos um bitmap secundário para substituir o homem enforcado, separando por novas linhas e preparando-o para a impressão 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.

Experimente online!

Isso resulta nas primeiras peças, as únicas peças restantes sendo as duas palavras na parte inferior em um formato diff ...

As Palavras Abaixo:

Imprima a primeira palavra sem as suposições ausentes:

05AB1E , 15 bytes

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

Experimente online!

05AB1E , 5 bytes

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

Experimente online!

Imprima as suposições perdidas calculadas anteriormente armazenadas em um registro.

Geléia , 86 bytes

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

Experimente online!

Uau ... isso foi divertido. Eu nunca usei tantos ¤personagens.

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

Obteve 9 bytes graças a @raznagul.

Experimente online!

Versão completa / formatada:

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

Isso também funciona para 314 bytes (provavelmente ainda pode ser mais curto):

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

Recebe entrada como 2 matrizes de caracteres individuais na sintaxe de currying.

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

Experimente Reproduzir

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

Isso ainda pode ser bastante jogável.

Isso está dentro de uma função que assume se tcomo parâmetros, com sa palavra a adivinhar e ta sequência contendo as letras já tentadas.

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

Experimente online!

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;

recebe entrada dos argumentos da linha de comando. Corra com -nrou experimente 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