(correlato / ispirato a: Disegna una formazione di bowling )

Un passatempo divertente nei mesi invernali qui è quello di eseguire il bowling pupazzo di neve, usando una grande palla (come un pallone da basket) e piccole figure di pupazzo di neve. Ricreamolo in ASCII.

Ogni pupazzo di neve è composto da:

(.,.)
( : )

Ecco l'allineamento dei dieci "spilli" del pupazzo di neve

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

Questi "pin" sono etichettati da 1a 10come

7 8 9 10
 4 5 6
  2 3
   1

Finora, così standard. Tuttavia, a differenza del normale bowling, i perni del pupazzo di neve sono semplicemente appiattiti e non completamente rimossi. Questo viene fatto da qualcuno che ha bisogno di appiattire manualmente la neve di eventuali perni che sono stati colpiti. Un pupazzo di neve appiattito è rappresentato da _____(cinque caratteri di sottolineatura), con spazi bianchi sopra. Ecco un esempio con i 1 3 5 6 9 10pin appiattiti (significa che 2 4 7 8rimangono solo i pin):

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

         _____

Ingresso

• Un elenco di numeri interi da 1a 10 in qualsiasi formato conveniente che rappresenta quali pin sono stati colpiti e quindi devono essere appiattiti.
• Ogni numero apparirà al massimo una sola volta e i numeri possono essere in qualsiasi ordine (ordinati, non ordinati, decrescenti ordinati) - a tua scelta, qualunque cosa renda il tuo codice più golfico.
• È garantito che l'input abbia almeno un numero intero.

Produzione

La rappresentazione artistica ASCII risultante dei pin del pupazzo di neve, con i pin corretti appiattiti.

Regole

• Le nuove linee iniziali o finali o gli spazi bianchi sono tutti opzionali, purché i personaggi stessi si allineino correttamente.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che le persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

1 3 5 6 9 10

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

         _____

1 2 3

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

      _____ _____

         _____

1 2 3 4 5 6 8 9 10

(.,.)
( : ) _____ _____ _____

   _____ _____ _____

      _____ _____

         _____

05AB1E , 45 44 byte

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

Provalo online!

Spiegazione

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

Pupazzo di neve 1.0.2 , 157 byte

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

Provalo online!

Quando ho visto questa sfida, sapevo che dovevo solo rispondere nella lingua perfetta ...

Questa è una subroutine che accetta input come array di numeri e output come stringa tramite l'attuale permavar.

Avvolto per "leggibilità" / estetica:

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

Versione leggermente non golfata / commentata:

}
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

impilati , non competitivi, 118 byte

Ho aggiunto deepmape poche altre cose dopo questa sfida, insieme a tonnellate di correzioni di errori. Provalo qui!

@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

Ungolfed

{ 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

Produzione:

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

      _____ _____ 

         _____ 

Pitone 2, 248 243 241 226 224 223 221 210 206 200 177 byte

-5 grazie a @Rod

-15 grazie ancora a Rod

-1 usando di nuovo il calcolo dello spazio da Rod

Sembra più lungo a causa di più righe e rientri ma sorprendentemente più breve di 11 byte.

Sono sicuro che questo andrà sotto i 200 ...

Avevo ragione, ma non senza 23 byte di seri suggerimenti da @ Pietu1998. Grazie molto!

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

Provalo online!

Prende l'input come un elenco di numeri interi. Troppo grande a 248 ma funziona.

C # 233 221 213 203 byte

Il metodo accetta un array int a come elenco di pin caduti

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

avvolto

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

allargato

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

eliminato alcuni byte da suggerimenti nei commenti di Ghost, raznagul e auhmaan.

Lotto, 262 byte

@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

Nota: le linee 2, 3 e 4 terminano in uno spazio e producono anche uno spazio finale su ciascuna linea. Questi possono essere rimossi al costo di 5 byte. Funziona creando variabili s1 ... s10 come metà inferiori dei pupazzi di neve, quindi appiattendo quelle fornite come argomenti della riga di comando. Le righe appropriate vengono stampate due volte, la prima volta con le metà inferiori sostituite con le metà superiori. Ciò consente di risparmiare 18 byte utilizzando due set di mezze variabili superiore e inferiore.

JavaScript, 154 149 byte

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 byte

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

Un programma che accetta l'input di un elenco di numeri interi e stampa il risultato.

Suite di test

[Spiegazione che verrà dopo]

Pyth, 51 byte

Il codice contiene alcuni non stampabili, quindi ecco 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

Provalo online.

Senza non stampabili, 52 byte

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

Provalo online.

Javascript 178 169 byte

Essenzialmente una porta dalla mia risposta C #.

Prende un array int come elenco di "pin" appiattiti;

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}

avvolto:

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}

Espanso e spiegato:

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