( 코드 검토 에 대한 질문 에서 영감을 얻음 )

두 사람이 Hangman을 하고 있다고 가정 해 봅시다 .하지만 게임을 듣고 현재 상태를 그리려고합니다.

두 단어가 입력으로 주어지면 각 단어가 일치 [A-Z]+하거나 [a-z]+(선택) 행맨 게임의 현재 상태를 아래 규칙에 따라 ASCII 아트로 출력합니다.

• 첫 번째 단어는 추측 할 단어이고 두 번째 단어는 이미 추측 된 문자입니다. 이들은 임의의 순서로 입력으로 취할 수 있습니다.
• 추측 할 단어는 비어 있지 않은 것으로 보장되지만 이미 추측 된 문자는 비어있을 수 있습니다 (예 : 게임이 시작되는 것처럼).
• 이 게임은 항상 유효한 교수형 집행 인 게임입니다 (예 : 추측 된 글자는 복제되지 않으며, 게임이 끝났을 때 글자는 추측되지 않으며, 입력 한 글자 만받을 수 있습니다).
• 행맨 그림 아래에는 _글자로 아직 알 수 없고 공백으로 구분하여 추측 할 단어가 있어야 합니다. 예를 들어 추측 할 단어가 BOAT이면 행맨 그림 아래에 있어야합니다 _ _ _ _. 단어가 된 경우 BOAT로 A추측, 다음 그림은해야합니다 아래 _ _ A _.
• 있는 이미 짐작 편지를해야 추측 할 수있는 단어 아래에 없는 단어에. 이들은 임의의 순서 일 수 있으며, 원한다면 임의의 비 알파벳 분리기에 의해 분리 될 수있다.

다음은 처음 시작부터 끝까지 행맨 게임의 상태입니다. 잘못 추측 된 각 문자는 상태를 하나씩 진행시킵니다. 첫 번째 잘못 추측 된 글자는 머리를 O, 다음 글자는 몸을 |나타 냅니다 .

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

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

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

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

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

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

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

입력

• 첫 번째로 비어 있지 않은 것을 보장 하는 편리한 형식의 두 문자열 .
• 입력을 순서대로 입력 할 수 있습니다 (예 : 추측 할 단어, 추측 한 문자 또는 그 반대로). 제출시 입력 순서를 알려주십시오.

산출

위에서 설명한 바와 같이 행맨 게임의 결과 ASCII 아트 표현은 편리한 형식으로 다시 표시됩니다.

규칙

• 문자 자체가 올바르게 정렬되는 한 줄 바꿈 또는 공백은 모두 선택 사항입니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 가능하면 다른 사람들이 귀하의 코드를 시험해 볼 수 있도록 온라인 테스트 환경에 대한 링크를 포함하십시오!
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

예

#1

BOAT 과 ATG

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

# 2

ZEPPELIN 과

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

#삼

ZEPPELIN 과 EATOLINSHR

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

# 4

RHYTHM 과 ABCDE

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

# 5

BOAT 과 ATOB

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

# 6

AIRPLANE 과 AJKEI

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

파이썬 (2) , 215 (192) 184 (183) 바이트

^{Raphaël Côté 덕분에 -8 바이트
Jonathan Frech 덕분에 -1 바이트}

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)

온라인으로 사용해보십시오!

숯 , 83 69 68 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 :로 전환하여 14 바이트를 저장했습니다 switch. 단일 |을 리터럴로 인쇄하여 1 바이트를 절약했습니다 . 주 : 당시 질문은, 설정 switch자세한 정보 모드에서 전혀 일을하지 않았고 뒤에 필요 «, 간결 모드 (이 67 바이트로 간결 번역을 보여줍니다 있도록 TIO의 현재 버전은,도 버그가)에서를 동안 Map의 ' 버그로 인해 사용하지 못했습니다 Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));. 다행히도 같은 길이의 kludge를 만들었습니다 (실제로 다른 루프를 Map으로 전환하려고 시도했지만 동일한 길이로 나왔습니다). 설명:

Ｆη              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 \.

파이썬 2 , 220 바이트

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)

온라인으로 사용해보십시오!

Raphaël Côté 덕분에 -35 바이트-
세트를 사용하는 -20 바이트
-micsthepick 덕분에 -1 바이트

젤리 ,  72  73 바이트

전체 교수형 사람을 보여주는 에이스 게임 버그 수정 +1 LN 에 Lạ6끝 부분)

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

왼쪽에있는 단어와 오른쪽에있는 (독특하고 게임 내) 글자를 가져와 문자 목록을 반환하거나 입력을 명령 줄 인수로 사용하여 결과를 인쇄하는 전체 프로그램입니다.

온라인으로 사용해보십시오!

방법?

먼저 :

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

9 자리 숫자의 각 문자의 한 표현 기지 9에서 전체 매달린 사람의 숫자 값은 다음과 같습니다 <space>, <newline>, -, |, O, /,\ , =, 또는+ .

나머지 프로그램 :

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

v v2 , 94 91 83 81 바이트

@ETHproductions의 접근 방식의 아이디어에서 -3 바이트 .
여러 줄 문자열 회전을 사용하여 -8 바이트
v2를 사용하여 -2 바이트

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

두 단어 입력을 모두 문자 배열로 사용합니다. 추측 단어는 먼저, 추측 문자는 둘째입니다. 잘못된 문자는, s로 . 잘못된 문자가 없으면 마지막 행이 비어 있습니다 (즉, 출력에 추가 줄 바꿈 문자가 포함됨).

온라인으로 사용해보십시오!

설명

암시 적 : U및 V입력 문자 배열입니다.

["..."

배열을 시작하고 매달린 맨 형식 문자열을 왼쪽으로 90도 회전시킵니다.

r\d_

(교체 r) 모든 자리 ( \d다음과 같은 기능을) :

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

숫자가 >=( ¨) 잘못된 추측의 양 ( VkU l), 공백 ( S)이면 해당 숫자에 해당하는 신체 부위를 가져옵니다 ( "..."gZ).

z '=³³

매달린 사람을 오른쪽으로 90 ° =돌리고 3 * 3 ( ³³) 번 반복 하여 배열로 밉니다 .

¡VøX ?X:'_Ã

문자가 ( ¡)에 포함되어 있거나 ( X) 포함 되지 않은 경우 V( VøX) 또는 _공백 ( ¸) 과 함께 배열로 배열 된 문자를 사용하여 단어 대 추측을 밉니다 .

VkU]·

단어 대 추측의 문자가 제거 된 추측 된 문자를 k출력 배열로 푸시합니다 ( ). 배열을 닫고 개행 ( ·)으로 결합하십시오 .

회전 시각화 :

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

05AB1E , 83 바이트

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

온라인으로 사용해보십시오!

비트 맵 :

05AB1E , 18 바이트

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

온라인으로 사용해보십시오!

이것은 다음과 같은 비트 맵 계획을 추진합니다.

1102220
1131113
1151113
1555113
1515113
1111113
4444444

다음과 같은 추가 바이트 :

05AB1E , 13 바이트

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

온라인으로 사용해보십시오!

비트 맵 조각을 적절한 문자로 바꾸고 나중에 행맨 조각을 대체 할 수 있도록 5를 남겨 두십시오.

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

매달린 남자:

다음으로, 두 번째 입력에는 있지만 첫 번째 입력에는없는 글자를 잡아서 사용자가 잘못 추측 한 횟수를 계산합니다.

05AB1E , 6 바이트

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

온라인으로 사용해보십시오!

마지막으로, 우리는 2 차 비트 맵을 사용하여 매달린 사람을 대체하여 줄 바꿈으로 구분하고 최종 인쇄를 위해 준비합니다.

05AB1E , 26 바이트

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.

온라인으로 사용해보십시오!

결과적으로 첫 번째 조각이 나오고 나머지 조각은 맨 아래에 두 단어를 diff 형식으로 출력합니다.

아래 단어들 :

빠진 추측없이 첫 번째 단어를 인쇄하십시오.

05AB1E , 15 바이트

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

온라인으로 사용해보십시오!

05AB1E , 5 바이트

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

온라인으로 사용해보십시오!

이전에 레지스터에 저장 한 계산 된 누락 된 추측을 인쇄합니다.

젤리 , 86 바이트

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

온라인으로 사용해보십시오!

휴 ... 이거 재미 있었어. 나는 너무 많이 사용하지 않았습니다¤ 문자를 .

작동 원리

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 바이트

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

@raznagul 덕분에 9 바이트가 줄었습니다.

온라인으로 사용해보십시오!

풀 / 포맷 버전 :

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

이것은 314 바이트에서도 작동합니다 (아마도 더 짧을 수 있음).

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

자바 스크립트 (ES6) 203 196 187 186 185 184 180 177 176 바이트

카레 구문에서 2 개의 개별 문자 배열로 입력을받습니다.

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

시도 플레이

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>

스칼라 , 392 389 바이트

이것은 여전히 골프를 많이 할 수 있습니다 .

이것은 함수 내부 s와 t매개 변수로 사용됩니다.s 추측 할 수있는 단어와 t이미 시도 문자가 포함 된 문자열입니다.

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

편집 :
-1 바이트 : t.contains(x) -> t contains x
-1 바이트 :s.contains(x) -> s contains x
-1 바이트 :.mkString(" ") -> mkString " "

온라인으로 사용해보십시오!

PHP 7, 246 바이트

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;

명령 행 인수에서 입력을받습니다. 온라인으로 실행 -nr하거나 사용해보십시오 .

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