21

(inspiré par une question sur Code Review)

Supposons que deux personnes jouent au pendu , mais vous n'avez entendu que le jeu et souhaitez dessiner l'état actuel.

Étant donné deux mots en entrée, où les mots correspondent chacun [A-Z]+ou [a-z]+(votre choix), sortez l'état actuel du jeu du pendu en tant qu'art ASCII, en suivant les règles ci-dessous.

Le premier mot est le mot à deviner, et le second mot est les lettres déjà devinées. Ceux-ci peuvent être pris en entrée dans n'importe quel ordre.
Le mot à deviner est garanti non vide, mais les lettres déjà devinées peuvent être vides (c'est-à-dire comme si c'était le début du jeu).
Le jeu sera toujours un jeu de bourreau valide (c'est-à-dire que les lettres devinées ne seront pas dupliquées, les lettres ne seront pas devinées après la fin du jeu, vous ne recevrez que des lettres en entrée, etc.).
Au-dessous du dessin du bourreau doit être le mot à deviner, avec _à la place des lettres encore inconnues, séparées par des espaces. Par exemple, si le mot à deviner était BOAT, alors en dessous du dessin du bourreau doit être _ _ _ _. Si le mot a été BOATavec Adeviné, puis sous le dessin doit être _ _ A _.
En dessous du mot à deviner, il doit y avoir des lettres déjà devinées qui ne sont pas dans le mot. Ceux-ci peuvent être dans n'importe quel ordre et peuvent être séparés par n'importe quel séparateur non alphabétique, si vous le souhaitez.

Voici les états du jeu du pendu, du début à la fin du jeu. Chaque lettre faussement devinée fait avancer l'État d'un point. Ainsi, la première lettre erronée fait Oapparaître la tête , la suivante fait |apparaître le corps , etc.

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

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

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

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

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

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

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

Contribution

Deux chaînes dans n'importe quel format pratique , avec la première garantie non vide.
Vous pouvez prendre l'entrée dans l'un ou l'autre ordre (par exemple, mot à deviner puis lettres devinées, ou vice versa). Veuillez indiquer dans votre soumission l'ordre d'entrée.

Sortie

La représentation artistique ASCII résultante du jeu du pendu en cours, comme décrit ci-dessus, à nouveau dans n'importe quel format pratique.

Règles

Les sauts de ligne ou les espaces de début ou de fin sont tous facultatifs, tant que les caractères eux-mêmes s'alignent correctement.
Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
Les failles standard sont interdites.
Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

#1

BOAT et ATG

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

# 2

ZEPPELIN et

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

# 3

ZEPPELIN et EATOLINSHR

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

# 4

RHYTHM et ABCDE

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

# 5

BOAT et ATOB

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

# 6

AIRPLANE et AJKEI

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

code-golf ascii-art game AdmBorkBork
la source

les mauvaises lettres doivent conserver l'ordre d'entrée?

Rod

@Rod Non, vous n'avez pas besoin de conserver l'ordre des suppositions incorrectes.

AdmBorkBork

2

Veuillez ajouter un cas de test où toutes les lettres sont devinées correctement et un où toutes ont été devinées

M. Xcoder

@ Mr.Xcoder J'ai ajouté le cas de test # 5 où la personne a deviné "BOAT" tout de suite.

AdmBorkBork

J'ai ajouté un cas de test qui n'a que 2 lettres incorrectes pour distinguer entre l'ordre de construction correct et la construction de haut en bas / de gauche à droite.

Justin Mariner

10

Python 2 , 215 192 184 184 183 octets

^{-8 octets grâce à Raphaël Côté}
^{-1 octet grâce à 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)

Essayez-le en ligne!

Barre
la source

En convertissant tous les \ n en sauts de ligne et en utilisant une chaîne multiligne avec "" ", ainsi qu'en utilisant" n'importe quel format pratique "d'entrée et en redéfinissant les appels définis dans l'entrée, j'ai pu passer à 172 octets.

Raphaël Côté

hmm, pourriez-vous lier les changements? J'ai seulement réussi à atteindre 184 octets

Rod

184 est bon: la suppression des ensembles du code a en fait interrompu la sortie, donc cela n'a pas fonctionné. Changer le \ n pour qu'ils deviennent de nouvelles lignes a aidé mais je n'ai en fait supprimé que 3 octets à 189. tio.run/…

Raphaël Côté

1

Je pense que vous devriez montrer la pièce du corps ( |) au lieu du bras gauche ( /) quand il y a 2 lettres erronées: Essayez-le en ligne

Justin Mariner

"\\/"est égal à "\/".

Jonathan Frech

8

Fusain , 83 69 68 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Modifier: enregistré 14 octets en basculant sur switch. Enregistré 1 octet en imprimant le single |comme un littéral. Note: Au moment où la question a été réglée, switchn'a pas fonctionné du tout en mode verbeux et avait besoin d' un arrière «en mode Succinct (la version actuelle sur TIO n'a ni bug, il montre la traduction succincts 67 octets), alors que Mapl » des bugs m'ont empêché d'utiliser Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));. Heureusement, j'ai réussi à trouver un kludge pour la même longueur (et en effet, j'ai également essayé de passer l'autre boucle à une carte, mais elle est également sortie à la même longueur). Explication:

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

Neil
la source

2

cette langue ... ça me fait peur.

Sergey Grinev du

@SergeyGrinev D: pourquoi est-ce si effrayant

ASCII uniquement

@ ASCII uniquement J'ai remarqué que vous avez corrigé Map (chaîne, expression) mais Map (tableau, expression) est toujours bogué - il modifie le tableau d'origine lorsqu'il est utilisé comme expression plutôt que comme commande. Essayez-le en ligne!

Neil

@ Heh uniquement ASCII, c'est une excellente idée pour une langue, mais les scripts ressemblent à quelque chose que Lovecraft utiliserait pour invoquer le sort Cthulhu.

Sergey Grinev

@Neil C'est le comportement prévu, principalement pour qu'il modifie le canevas lors du mappage du type de données Cells, mais je suppose que oui, vous devrez souvent utiliser les données d'origine après la carte, elles devraient être corrigées d'ici demain

ASCII uniquement le

7

Python 2 , 220 octets

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)

Essayez-le en ligne!

-35 octets grâce à Raphaël Côté
-20 octets en utilisant des sets
-1 octet grâce à micsthepick

HyperNeutrino
la source

3

belle idée pour le "remplacer" par des chiffres :)

V. Courtois

@ V.Courtois Merci :) J'allais utiliser translatemais cela s'est avéré être plus long lol.

HyperNeutrino

Salut @HyperNeutrino, bon travail avec la soumission! Je pense que les 2 boucles à la fin pourraient être mises en une, en utilisant cela for i in range(7):s=s.replace(`i`,'O|/\\/\\'[i] if i<c else ' '). Cela vous donne une seule boucle et vous changez simplement le remplacement si vous êtes plus c. Vous pouvez réduire à 251 octets de cette façon :)

Raphaël Côté

@ RaphaëlCôté Beau golf. Merci!

HyperNeutrino

c est juste devenu inutile. Utilisez simplement len (y) et économisez 4 octets! On gère!

Raphaël Côté

5

Gelée , 72 73 octets

+1 corrigeant un bug du jeu d'as qui montrait la personne pendue (changé LNen Lạ6presque à la fin)

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

Un lien dyadique prenant le mot à gauche et les lettres (uniques et intra-jeu) à droite et renvoyant une liste de caractères, ou un programme complet prenant l'entrée comme arguments de ligne de commande et imprimant le résultat.

Essayez-le en ligne!

Comment?

D'abord:

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

La valeur numérique de la personne pleine Pendu dans la base 9, où chacun des 9 chiffres représentent l' un des personnages: <space>, <newline>, -, |, O, /, \, =ou +.

le reste du programme:

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

Jonathan Allan
la source

Cela échoue sur le cas de test BOATet ATOB. Essayez-le en ligne!

fireflame241

Ah merci de l'avoir signalé, je vais le réparer pendant 2 octets ... juste en écrivant une explication.

Jonathan Allan

fait, et faites que 1 octet.

Jonathan Allan

Remarque: Le passé pour «accrocher» quand il s'agit de personnes est «accroché» et non «accroché». Juste un nitpick alors ayez +1 pour compensation :)

HyperNeutrino

@ ΗγρεŗN̛ευτŗιͷo Heh, j'avais accroché dans un endroit et pendu dans un autre et changé ce dernier. (J'ai aussi dit "complètement", comme si la personne incomplète n'avait pas été complètement pendue aussi).

Jonathan Allan

3

Japt v2 , 94 91 83 81 octets

-3 octets de quelques idées de l'approche @ETHproductions à ce sujet .
-8 octets en utilisant la rotation de chaîne multiligne.
-2 octets en utilisant v2.

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

Prend les deux entrées de mots comme des tableaux de caractères, le mot devinant en premier et les lettres devinées en second. Les lettres incorrectes sont affichées séparées par le par ,. Lorsqu'il n'y a pas de lettres incorrectes, la dernière ligne est vide (ce qui signifie que la sortie contient une nouvelle ligne de fin supplémentaire).

Essayez-le en ligne!

Explication

Implicite: Uet Vsont des tableaux de caractères d'entrée.

["..."

Démarrez un tableau et appuyez sur la chaîne de format homme suspendu, tournée de 90 ° vers la gauche.

r\d_

Remplacez ( r) chaque chiffre ( \d) par la fonction suivante:

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

Si le chiffre est >=( ¨) le nombre de suppositions erronées ( VkU l), un espace ( S), sinon, obtenez la partie du corps appropriée pour ce chiffre ( "..."gZ).

z '=³³

Faites pivoter l'homme suspendu de 90 ° vers la droite et poussez =3 * 3 ( ³³) fois sur le tableau.

¡VøX ?X:'_Ã

Poussez le mot à deviner, avec des lettres mappées ( ¡) à elles-mêmes ( X) si elles sont contenues dans V( VøX), ou _sinon, et jointes avec des espaces ( ¸), au tableau.

VkU]·

Poussez les lettres devinées, avec les lettres du mot à deviner supprimées ( k), dans le tableau de sortie. Fermez le tableau et joignez-vous à newlines ( ·).

Rotation visualisée:

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

Justin Mariner
la source

J'ai eu quelque chose de similaire: ethproductions.github.io/japt/… (bien que maintenant je remarque que les trois segments du milieu sont placés dans le mauvais ordre). Je vois certaines parties de la vôtre qui sont plus courtes que la façon dont je l'ai fait, peut-être que nos réponses peuvent se combiner en quelque chose d'encore plus court.

ETHproductions

@ETHproductions Je ne pense pas que votre idée d'incrémentation Wpuisse fonctionner car les parties du corps n'apparaissent pas de gauche à droite / de haut en bas. J'ai cependant pu enregistrer quelques octets à partir de votre version.

Justin Mariner

2

05AB1E , 83 octets

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

Essayez-le en ligne!

Le Bitmap:

05AB1E , 18 octets

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

Essayez-le en ligne!

Cela pousse le plan bitmap suivant:

Où les octets supplémentaires suivants:

05AB1E , 13 octets

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

Essayez-le en ligne!

Remplacez les morceaux du bitmap par les caractères appropriés, en laissant les 5 pour remplacer les morceaux du bourreau plus tard:

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

Le pendu:

Ensuite, nous calculons le nombre de fois où l'utilisateur s'est trompé en saisissant les lettres qui se trouvent dans la deuxième entrée, mais pas dans la première entrée:

05AB1E , 6 octets

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

Essayez-le en ligne!

Enfin, nous utilisons un bitmap secondaire pour le remplacer dans l'homme pendu, en le séparant par des retours à la ligne et en le préparant pour l'impression finale:

05AB1E , 26 octets

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.

Essayez-le en ligne!

Il en résulte les premières pièces, les seules pièces restantes étant la sortie des deux mots en bas dans un format diff ...

Les mots ci-dessous:

Imprimez le premier mot sans les suppositions manquantes:

05AB1E , 15 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

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

Essayez-le en ligne!

Imprimez les suppositions manquées calculées précédemment que nous avons stockées dans un registre.

Urne de poulpe magique
la source

1

J'aime vraiment l'idée du bitmap (essayer de l'implémenter dans ma propre réponse, même), mais votre réponse place le bras gauche ( /) avant le corps ( |). Deux fausses lettres devraient faire apparaître les morceaux de tête et de corps. Essayez-le en ligne

Justin Mariner

1

Gelée , 86 octets

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

Essayez-le en ligne!

Ouf ... c'était amusant. Je n'ai jamais utilisé autant de ¤caractères.

Comment ça marche

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

fireflame241
la source

Cela attire l'homme dans le mauvais ordre; le torse doit venir après la tête, avant le bras gauche.

Shaggy

1

C #, 305 296 octets

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 octets grâce à @raznagul.

Essayez-le en ligne!

Version complète / formatée:

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

Cela fonctionne également pour 314 octets (pourrait probablement être encore plus court):

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

TheLethalCoder
la source

Vous pouvez remplacer g.Select(c=>!w.Contains(c)?c+"":"")par g.Where(c=>!w.Contains(c)).

raznagul

@raznagul Merci!

TheLethalCoder

1

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

Prend l'entrée comme 2 tableaux de caractères individuels dans la syntaxe 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

Essayez de jouer

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>

Développer l'extrait

Hirsute
la source

Le milieu pièce « corps » devrait venir deuxième et le troisième bras gauche, de sorte que le nombre une partie de votre chaîne doit être 1, 324, 5 6(voir le dernier cas de test).

Justin Mariner

Oups, je ne sais pas comment j'ai fait ça. Merci de l'avoir signalé, @JustinMariner

Shaggy

0

Scala , 392 389 octets

Cela pourrait encore être fortement jouable au golf.

C'est à l'intérieur d'une fonction prenant set tcomme paramètres, avec sle mot à deviner et tla chaîne contenant des lettres déjà essayées.

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

MODIFIER:
-1 octet: t.contains(x) -> t contains x
-1 octet: s.contains(x) -> s contains x
-1 octet:.mkString(" ") -> mkString " "

Essayez-le en ligne!

V. Courtois
la source

0

PHP 7, 246 octets

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;

prend l'entrée des arguments de ligne de commande. Courez avec -nrou essayez-le en ligne .

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

Titus
la source

Pendu ASCII en cours

Contribution

Sortie

Règles

Exemples

#1

# 2

# 3

# 4

# 5

# 6

Réponses:

Python 2 , 215 192 184 184 183 octets

Fusain , 83 69 68 octets

Python 2 , 220 octets

Gelée , 72 73 octets

Comment?

Japt v2 , 94 91 83 81 octets

Explication

05AB1E , 83 octets

Le Bitmap:

05AB1E , 18 octets

05AB1E , 13 octets

Le pendu:

05AB1E , 6 octets

05AB1E , 26 octets

Les mots ci-dessous:

05AB1E , 15 octets

05AB1E , 5 octets

Gelée , 86 octets

C #, 305 296 octets

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

Essayez de jouer

Scala , 392 389 octets

PHP 7, 246 octets