(inspiriert von einer Frage bei Code Review)

Angenommen, zwei Personen spielen Hangman , aber Sie haben das Spiel nur mitgehört und möchten den aktuellen Status zeichnen.

Geben Sie bei zwei eingegebenen Wörtern, bei denen die Wörter übereinstimmen, [A-Z]+oder [a-z]+(nach Ihrer Wahl) den aktuellen Status des Henkerspiels als ASCII-Grafik gemäß den folgenden Regeln aus.

• Das erste Wort ist das zu erratende Wort und das zweite Wort sind die bereits erratenen Buchstaben. Diese können in beliebiger Reihenfolge eingegeben werden.
• Das zu erratende Wort ist garantiert nicht leer, aber die bereits erratenen Buchstaben können leer sein (dh als wäre es der Beginn des Spiels).
• Das Spiel wird immer ein gültiges Henkerspiel sein (dh erratene Buchstaben werden nicht dupliziert, Buchstaben werden nach dem Ende des Spiels nicht erraten, Sie erhalten nur Buchstaben als Eingabe usw.).
• Unterhalb der Henkerzeichnung muss sich das zu erratende Wort befinden. Anstelle _der noch unbekannten Buchstaben müssen Leerzeichen verwendet werden. Wenn zum Beispiel das zu erratende Wort lautete BOAT, muss es unter der Henkerzeichnung stehen _ _ _ _. Wenn das Wort BOATmit Aerraten wurde, dann muss unten die Zeichnung stehen _ _ A _.
• Unter dem zu erratenden Wort müssen sich bereits erratene Buchstaben befinden, die nicht im Wort enthalten sind. Diese können in beliebiger Reihenfolge angegeben werden und bei Bedarf durch ein nicht alphabetisches Trennzeichen voneinander getrennt werden.

Hier sind die Zustände des Henkerspiels vom Anfang bis zum Ende des Spiels. Jeder falsch erratene Buchstabe rückt den Staat um eins vor. Der erste falsch erratene Buchstabe lässt den Kopf Oerscheinen, der nächste lässt den Körper |erscheinen usw.

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

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

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

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

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

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

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

Eingang

• Zwei Zeichenfolgen in einem beliebigen Format , wobei die erste garantiert nicht leer ist.
• Sie können die Eingabe in beliebiger Reihenfolge vornehmen (z. B. zu erratende Wörter und dann erratene Buchstaben oder umgekehrt). Bitte geben Sie bei Ihrer Einsendung die Eingabereihenfolge an.

Ausgabe

Die resultierende ASCII-Grafikdarstellung des laufenden Henkerspiels, wie oben beschrieben, wieder in einem beliebigen geeigneten Format.

Regeln

• Führende oder nachfolgende Zeilenumbrüche oder Leerzeichen sind optional, sofern die Zeichen selbst korrekt ausgerichtet sind.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

# 1

BOAT und ATG

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

# 2

ZEPPELIN und

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

#3

ZEPPELIN und EATOLINSHR

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

# 4

RHYTHM und ABCDE

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

# 5

BOAT und ATOB

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

# 6

AIRPLANE und AJKEI

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

Python 2 , 215 192 184 183 Bytes

^{-8 Bytes dank Raphaël Côté
-1 Bytes dank 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)

Probieren Sie es online!

Kohle , 83 69 68 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 14 Bytes durch Umschalten auf gespeichert switch. 1 Byte durch Drucken der Single |als Literal gespeichert . Hinweis: Die Frage Damals wurde festgelegt, switchhat nicht funktioniert überhaupt in Verbose - Modus und einen nachgestellten benötigt «in Prägnante Modus (die aktuelle Version auf TIO weder Fehler hat, so ist es die Prägnante Übersetzung als 67 Bytes zeigt), während Map‚s Fehler haben mich daran gehindert Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));. Zum Glück habe ich es geschafft, einen Kludge für die gleiche Länge zu finden (und zwar habe ich auch versucht, die andere Schleife auf eine Map umzuschalten, aber es ist auch mit der gleichen Länge herausgekommen). Erläuterung:

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

Probieren Sie es online!

-35 Bytes dank Raphaël Côté
-20 Bytes mit Sets
-1 Bytes dank Micsthepick

Jelly ,  72  73 Bytes

+1 Behebung eines Ass-Spielfehlers, bei dem die Person, die vollständig gehängt wurde, angezeigt wurde (geändert LNgegen Lạ6Ende)

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

Ein dyadischer Link, der das Wort links und die (eindeutigen und spielinternen) Buchstaben rechts aufnimmt und eine Liste von Zeichen zurückgibt, oder ein vollständiges Programm, das die Eingabe als Befehlszeilenargumente verwendet und das Ergebnis druckt.

Probieren Sie es online!

Wie?

Zuerst:

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

Ist der numerische Wert des vollen Erhängten in der Basis 9, wobei jede der neun Ziffern eines des Zeichens darstellen: <space>, <newline>, -, |, O, /, \, =, oder +.

der Rest des Programms:

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 von einigen Ideen aus @ETHproductions 'Ansatz dazu .
-8 Bytes durch mehrzeilige Zeichenfolgenrotation.
-2 Bytes mit v2.

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

Nimmt beide Worteingaben als Arrays von Zeichen, wobei das erratene Wort an erster Stelle und die erratenen Buchstaben an zweiter Stelle stehen. Falsche Buchstaben werden durch ,s getrennt angezeigt . Wenn keine falschen Buchstaben vorhanden sind, ist die letzte Zeile leer (was bedeutet, dass die Ausgabe eine zusätzliche nachgestellte Zeile enthält).

Probieren Sie es online!

Erläuterung

Implizit: Uund Vsind Eingabezeichen-Arrays.

["..."

Starten Sie ein Array und drücken Sie die um 90 ° nach links gedrehte Zeichenfolge im Hanging-Man-Format.

r\d_

Ersetzen Sie ( r) jede Ziffer ( \d) durch die folgende Funktion:

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

Wenn die Ziffer >=( ¨) die Anzahl der falschen Vermutungen ( VkU l) ist, wird ein Leerzeichen ( S) angezeigt. Andernfalls erhalten Sie das entsprechende Körperteil für diese Ziffer ( "..."gZ).

z '=³³

Drehen Sie den hängenden Mann um 90 ° nach rechts und drücken Sie ihn =3 * 3 ( ³³) Mal wiederholt auf das Array.

¡VøX ?X:'_Ã

Schieben Sie das zu erratende Wort mit den Buchstaben ¡, die entweder auf sich selbst ( X) abgebildet sind ( ), wenn sie in V( VøX) enthalten sind, oder, _wenn nicht, mit Leerzeichen ( ¸) in das Array.

VkU]·

Schieben Sie die erratenen Buchstaben, wobei die Buchstaben im zu erratenden Wort entfernt sind ( k), in das Ausgabe-Array. Schließen Sie das Array und verbinden Sie es mit newlines ( ·).

Drehung visualisiert:

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

05AB1E , 83 Bytes

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

Probieren Sie es online!

Die Bitmap:

05AB1E , 18 Bytes

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

Probieren Sie es online!

Dadurch wird der folgende Bitmap-Plan übertragen:

1102220
1131113
1151113
1555113
1515113
1111113
4444444

Wobei die folgenden zusätzlichen Bytes:

05AB1E , 13 Bytes

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

Probieren Sie es online!

Ersetzen Sie die Teile der Bitmap durch die entsprechenden Zeichen und lassen Sie die 5 für das spätere Ersetzen der Teile des Henkers:

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

Die Gehenkten:

Als nächstes berechnen wir, wie oft der Benutzer falsch geraten hat, indem wir die Buchstaben in der zweiten Eingabe, aber nicht in der ersten Eingabe erfassen:

05AB1E , 6 Bytes

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

Probieren Sie es online!

Schließlich verwenden wir eine sekundäre Bitmap, um den Erhängten durch Zeilenumbrüche zu ersetzen und ihn für den endgültigen Druck vorzubereiten:

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.

Probieren Sie es online!

Dies führt zu den ersten Stücken, wobei die einzigen verbleibenden Stücke die beiden Wörter am unteren Rand in einem unterschiedlichen Format ausgeben ...

Die Wörter unten:

Gib das erste Wort ohne die fehlenden Vermutungen aus:

05AB1E , 15 Bytes

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

Probieren Sie es online!

05AB1E , 5 Bytes

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

Probieren Sie es online!

Drucken Sie die berechneten fehlenden Vermutungen aus, die wir zuvor in einem Register gespeichert haben.

Jelly , 86 Bytes

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

Probieren Sie es online!

Puh ... das hat Spaß gemacht. Ich habe noch nie so viele ¤Zeichen verwendet.

Wie es funktioniert

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 dank @raznagul.

Probieren Sie es online!

Voll / Formatierte Version:

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

Dies funktioniert auch für 314 Bytes (könnte wahrscheinlich noch kürzer sein):

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

Nimmt die Eingabe als 2 Arrays einzelner Zeichen in der aktuellen Syntax an.

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

Versuchen Sie es zu spielen

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

Dies könnte immer noch schwer Golf sein.

Dies ist innerhalb einer Funktion unter sund tals Parameter, wobei sdas zu erratende Wort und tdie Zeichenfolge bereits ausprobierte Buchstaben enthalten.

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

Probieren Sie es 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;

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Laufen Sie mit -nroder versuchen Sie es 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