(lié / inspiré par: Dessiner une formation de bowling )

Un passe-temps amusant pendant les mois d'hiver ici consiste à jouer au bowling avec un bonhomme de neige, en utilisant une grosse balle (comme un ballon de basket) et de minuscules figurines de bonhomme de neige. Recréons cela en ASCII.

Chaque bonhomme de neige se compose des éléments suivants:

(.,.)
( : )

Voici l'alignement des dix "épingles" de bonhomme de neige

(.,.) (.,.) (.,.) (.,.)
( : ) ( : ) ( : ) ( : )
   (.,.) (.,.) (.,.)
   ( : ) ( : ) ( : )
      (.,.) (.,.)
      ( : ) ( : )
         (.,.)
         ( : )

Ces "broches" sont étiquetées de 1à 10comme

7 8 9 10
 4 5 6
  2 3
   1

Jusqu'à présent, si standard. Cependant, contrairement au bowling normal, les quilles de bonhomme de neige sont simplement aplaties et ne sont pas totalement retirées. Cela est fait par quelqu'un qui a besoin d'aplatir manuellement la neige des broches qui ont été frappées. Un bonhomme de neige aplati est représenté par _____(cinq traits de soulignement), avec un espace au-dessus. Voici un exemple avec les 1 3 5 6 9 10broches aplaties (ce qui signifie que seules les 2 4 7 8broches restent):

(.,.) (.,.)
( : ) ( : ) _____ _____
   (.,.)
   ( : ) _____ _____
      (.,.) 
      ( : ) _____

         _____

Contribution

• Une liste d'entiers de 1à 10 dans n'importe quel format pratique représentant les broches qui ont été frappées et doivent donc être aplaties.
• Chaque numéro n'apparaîtra qu'une seule fois, et les numéros peuvent être dans n'importe quel ordre (trié, non trié, trié décroissant) - votre choix, quel que soit votre code golfier.
• L'entrée est garantie d'avoir au moins un entier.

Sortie

La représentation artistique ASCII résultante des épingles de bonhomme de neige, avec les épingles correctes aplaties.

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 les gens 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 3 5 6 9 10

(.,.) (.,.)
( : ) ( : ) _____ _____
   (.,.)
   ( : ) _____ _____
      (.,.) 
      ( : ) _____

         _____

1 2 3

(.,.) (.,.) (.,.) (.,.)
( : ) ( : ) ( : ) ( : )
   (.,.) (.,.) (.,.)
   ( : ) ( : ) ( : )

      _____ _____

         _____

1 2 3 4 5 6 8 9 10

(.,.)
( : ) _____ _____ _____

   _____ _____ _____

      _____ _____

         _____

05AB1E , 45 44 octets

TF"(.,.)( : )"„ _5×{«4ä2ä¹N>åè})4L£Rvyø»}».c

Essayez-le en ligne!

Explication

TF                                           # for N in [0 ... 9] do:
  "(.,.)( : )"                               # push string
              „ _                            # push the string " _"
                 5×                          # repeat it 5 times
                   {                         # sort
                    «                        # concatenate the strings
                     4ä                      # split the string in 4 parts
                       2ä                    # split the list in 2 parts
                         ¹N>åè               # if index+1 is in the input, push the first part
                                             # else push the second part
                              }              # end loop
                               )             # wrap stack in a list
                                4L£          # split list in parts of size 1,2,3,4
                                   R         # reverse list
                                    v        # for each list in list of lists
                                     yø      # transpose the list
                                       »     # join by spaces and newlines
                                        }    # end loop
                                         »   # join by newlines
                                          .c # centralize

Snowman 1.0.2 , 157 octets

(()("789:045600230001"4aG::48nSdU][:#:]eq]/nM;AsI[:"_____"wR["     "wR/aC;:"( : )"wR["(.,.)"wR/aC;bI;:"  "wRdUaC;bI\#**\;aMaZ:" "aJ1AfL;aM;aM1AfL"
"aJ1AfL*))

Essayez-le en ligne!

Quand j'ai vu ce défi, je savais que je n'avais qu'à répondre dans la langue parfaite ...

Il s'agit d'un sous-programme qui prend les entrées sous forme de tableau de nombres et les sorties sous forme de chaîne via le permavar actuel.

Enveloppé pour "lisibilité" / esthétique:

(()("789:045600230001"4aG::48nSdU][:#:]eq]/nM;AsI[
:"_____"wR["     "wR/aC;:"( : )"wR["(.,.)"wR/aC;bI
;:"  "wRdUaC;bI\#**\;aMaZ:" "aJ1AfL;aM;aM1AfL"
"aJ1AfL*))

Version légèrement non golfée / commentée:

}
1wR`
3wR`aC`
5wR`aC`
6wR`aC`
9wR`aC`
*

((
    )(
    "789:045600230001"  // pin layout data
    4aG                 // split into groups of 4; we need each row twice
    :                   // map over groups of 2 output lines
        :               // map over pins (or whitespace)
            48nS        // subtract ascii '0'
            dU][        // duplicate the pin; we need it in the if{}
            :           // if (pin) {
                #:]eq]/nM;AsI[:"_____"wR["     "wR/aC;:"( : )"wR["(.,.)"wR/aC;bI
            ;:          // } else {
                "  "wRdUaC
            ;bI         // }
            \#**\       // maneuver the permavars around to discard pin
        ;aM
        aZ:" "aJ1AfL;aM
    ;aM
    1AfL                // flatten (simulate a flatmap)
    "
"aJ                     // join on newline
    1AfL                // flatten again into a single string
    *
))

#sP

empilés , non compétitives, 118 octets

J'ai ajouté deepmapet quelques autres choses après ce défi, ainsi que des tonnes de corrections de bugs. Essayez-le ici!

@a((7 8 9 10)(4 5 6)(2 3)(1)){e:('(.,.)
( : )' ' 
_'5 hrep)a e has#'  'hcat
}deepmap{e i:' 
 'i 3*hrep e,$hcat#/!LF+}map

Non golfé

{ a :
  ((7 8 9 10) (4 5 6) (2 3) (1))
  { e :
    (
      '(.,.)' LF '( : )' + + 
      ' ' LF '_' + + 5 hrep
    ) @possible
    a e has @ind
    possible ind get @res
    '  ' @padding
    res padding hcat return
  } deepmap
  { e i:
    ' ' LF ' ' + + i 3 * hrep
    e ,
    $hcat insert!
    LF +
  } map
} @:bowl

(1 2 3 4 6 10) bowl out

Sortie:

(.,.) (.,.) (.,.)       
( : ) ( : ) ( : ) _____ 
         (.,.)       
   _____ ( : ) _____ 

      _____ _____ 

         _____ 

Python 2, 248 243 241 226 224 223 221 210 206 200 177 octets

-5 avec merci à @Rod

-15 à nouveau grâce à Rod

-1 en utilisant à nouveau le calcul de l'espace de Rod

Semble plus long en raison de plus de lignes et de retraits, mais étonnamment 11 octets plus court.

Je suis sûr que cela passera sous 200 ...

J'avais raison mais pas sans 23 octets de conseils sérieux de @ Pietu1998. Merci beaucoup!

i,z=input(),0;m=['']*10;n=m[:]
for x in range(11):m[x-1],n[x-1]=('(.,.)',' '*5,'( : )','_'*5)[x in i::2]
for y in 10,6,3,1:
 for q in m,n:print' '*3*z+' '.join(q[y-4+z:y])
 z+=1

Essayez-le en ligne!

Prend l'entrée comme une liste d'entiers. Beaucoup trop gros à 248 mais ça marche.

C # 233 221 213 203 octets

prend un tableau int comme la liste des broches tombées

string S(int[]a){string o="",x=o,y=o,z=o;for(int i=10;i>0;){var c=a.Contains(i);x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":"( : ) ")+y;if(i==7|i<5&i--!=3){o+=$"{z}{x}\n{z}{y}\n";x=y="";z+="   ";}}return o;}

enveloppé

string S(int[]a){string o="",x=o,y=o,z=o;for(int i=10;i>0;)
{var c=a.Contains(i);x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":
"( : ) ")+y;if(i==7|i<5&i--!=3){o+=$"{z}{x}\n{z}{y}\n";x=y="";
z+="   ";}}return o;}

étendu

string S(int[] a)
{
    string o = "", x = o, y = o, z= o;
    for (int i = 10; i > 0;)
    {
        var c = a.Contains(i);
        x = (c ? "      " : "(.,.) ") + x;
        y = (c ? "_____ " : "( : ) ") + y;

        if (i==7|i<5&i--!=3)
        {
            o += $"{z}{x}\n{z}{y}\n";
            x = y = "";
            z += "   ";
        }
    }
    return o;
}

renversé quelques octets par des suggestions dans les commentaires de Ghost, raznagul et auhmaan.

Lot, 262 octets

@echo off
for /l %%i in (1,1,10)do set s%%i=( : ) 
for %%i in (%*)do set s%%i=_____ 
set l=call:l 
%l%%s7%%s8%%s9%%s10%
%l%"   %s4%%s5%%s6%
%l%"      %s2%%s3%
%l%"         %s1%
exit/b
:l
set s=%~1
set s=%s:( : )=(.,.)%
echo(%s:_____=     %
echo(%~1

Remarque: les lignes 2, 3 et 4 se terminent dans un espace et produisent également un espace de fin sur chaque ligne. Ceux-ci peuvent être supprimés au coût de 5 octets. Fonctionne en créant les variables s1 ... s10 comme les moitiés inférieures des bonhommes de neige, puis en aplatissant celles données comme arguments de ligne de commande. Les lignes appropriées sont imprimées deux fois, la première fois avec les moitiés inférieures remplacées par les moitiés supérieures. Cela économise 18 octets de plus en utilisant deux ensembles de variables de moitié supérieure et inférieure.

JavaScript, 154 149 octets

f=
a=>`6 7 8 9
_3 4 5
__1 2
___0
`[r='replace'](/\d|_/g,m=>++m?~a.indexOf(m)?'_____':'( : )':'   ')[r](/.*\n?/g,m=>m[r](/ : |_/g,s=>s=='_'?' ':'.,.')+m)


I.oninput=()=>O.innerHTML=f(JSON.parse(`[${I.value.match(/\d+/g)}]`))
I.oninput()

<input id=I value="1 3 5 6 9 10"><pre id=O>

Pyth, 63 octets

j.ejm+**3k;j;db)_CcR[1 3 6).e:*T]btMQ@m*T]*5d,d\_kc2"(.,.)( : )

Un programme qui prend l'entrée d'une liste d'entiers et imprime le résultat.

Suite de tests

[Explication à venir plus tard]

Pyth, 51 octets

Le code contient des non imprimables, voici donc un xxdhexdump.

00000000: 6a6d 2e5b 3233 5f6a 3b6d 4063 323f 7d6b  jm.[23_j;m@c2?}k
00000010: 5172 2235 2035 5f22 392e 2220 3b5b 8db2  Qr"5 5_"9." ;[..
00000020: 1778 a822 6472 4673 4d50 4253 2d34 2f64  .x."drFsMPBS-4/d
00000030: 323b 38                                  2;8

Essayez-le en ligne.

Sans imprimables, 52 octets

jm.[23_j;m@c2?}kQr"5 5_"9").,.() : ("drFsMPBS-4/d2;8

Essayez-le en ligne.

Javascript 178 169 octets

Essentiellement un port de ma réponse C #.

Prend un tableau int comme la liste des "broches" aplaties;

f=a=>{o=x=y=z="";for(i=10;i>0;){c=a.includes(i);x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":"( : ) ")+y;if(i==7|i<5&i--!=3){o+=z+x+"\n"+z+y+"\n";x=y="";z+= "   ";}}return o}

Enveloppé:

f=a=>{o=x=y=z="";for(i=10;i>0;){c=a.includes(i);
x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":"( : ) ")+y;
if(i==7|i<5&i--!=3){o+=z+x+"\n"+z+y+"\n";x=y="";
z+= "   ";}}return o}

Développé et expliqué:

// function f takes parameter a (an array of ints) 
f = a => {

    // four strings:
    // o: output
    // x: top row of snowmen
    // y: bottom row of snowmen
    // z: padding to indent the snowmen
    o = x = y = z = "";

    // loop from 10 to 1 (the pins)
    // remove the "afterthought" decrement - we can do that later
    for (i = 10; i > 0;) {

        // set the boolean c to whether the current pin has been flattened
        c = a.includes(i);

        // prefix x and y with the appropriate "sprite"
        // using a ternary if on c
        x = (c ? "      " : "(.,.) ") + x;
        y = (c ? "_____ " : "( : ) ") + y;

        // determine if we've reached the end of a row (i equals 7, 4, 2 or 1)
        // use non shortcircuit operators to save bytes and ensure we hit the final i, because...
        // we also decrement i here 
        // (we didn't do this in the for loop declaration to save a byte)
        if (i == 7 | i < 5 & i-- != 3) {

            // concatenate our rows x & y,
            // prefixing them with the padding z,
            // postfixing them with a newline
            o += z + x + "\n" + z + y + "\n";

            // reset x and y rows
            x = y = "";

            // increase our padding for next time
            z += "   ";
        }
    }

    // return our final string (no semicolon to save a byte)
    return o
}