(relacionado / inspirado por: Desenhe uma formação de boliche )

Um passatempo divertido nos meses de inverno aqui é jogar boliche de boneco de neve, usando uma bola grande (como uma bola de basquete) e pequenas figuras de boneco de neve. Vamos recriar isso em ASCII.

Cada boneco de neve consiste no seguinte:

(.,.)
( : )

Aqui está o alinhamento dos dez "pinos" do boneco de neve

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

Estes "pins" são rotulados a partir 1de 10como

7 8 9 10
 4 5 6
  2 3
   1

Até agora, tão padrão. No entanto, ao contrário do boliche normal, os pinos do boneco de neve são apenas achatados e não totalmente removidos. Isso é feito por alguém que precisa achatar manualmente a neve dos pinos atingidos. Um boneco de neve achatado é representado por _____(cinco sublinhados), com espaço em branco acima. Aqui está um exemplo com os 1 3 5 6 9 10pinos achatados (o que significa que apenas os 2 4 7 8pinos permanecem):

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

         _____

Entrada

• Uma lista de números inteiros de 1para 10 em qualquer formato conveniente representando quais pinos foram atingidos e, portanto, precisam ser achatados.
• Cada número aparecerá apenas no máximo uma vez, e os números podem estar em qualquer ordem (ordenada, não ordenada, ordenada descendente) - sua escolha, independentemente do que torne seu código mais eficiente.
• A entrada é garantida para ter pelo menos um número inteiro.

Saída

A representação artística ASCII resultante dos pinos do boneco de neve, com os pinos corretos achatados.

Regras

• Novas linhas à esquerda ou à direita ou espaços em branco são opcionais, desde que os próprios caracteres estejam alinhados corretamente.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que as pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

1 3 5 6 9 10

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

         _____

1 2 3

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

      _____ _____

         _____

1 2 3 4 5 6 8 9 10

(.,.)
( : ) _____ _____ _____

   _____ _____ _____

      _____ _____

         _____

05AB1E , 45 44 bytes

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

Experimente online!

Explicação

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

Boneco de neve 1.0.2 , 157 bytes

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

Experimente online!

Quando vi esse desafio, sabia que tinha que responder na linguagem perfeita ...

Essa é uma sub-rotina que recebe a entrada como uma matriz de números e as saídas como uma string através do permavar atual.

Embrulhado para "legibilidade" / estética:

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

Versão levemente ungolfed / comentada:

}
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

empilhados , não-concorrentes, 118 bytes

Eu adicionei deepmape algumas outras coisas após esse desafio, junto com toneladas de correções. Experimente aqui!

@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

Saída:

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

      _____ _____ 

         _____ 

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

-5 com agradecimentos a @Rod

-15 novamente graças a Rod

-1 usando o cálculo de espaço novamente da Rod

Parece mais devido a mais linhas e recuos, mas surpreendentemente 11 bytes mais curto.

Tenho certeza que isso vai ficar abaixo de 200 ...

Eu estava certo, mas não sem 23 bytes de dicas sérias do @ Pietu1998. Muito Obrigado!

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

Experimente online!

Recebe a entrada como uma lista de números inteiros. Muito grande em 248, mas funciona.

C # 233 221 213 203 bytes

O método utiliza uma matriz int a como a lista de pinos caídos

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

embrulhado

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

expandido

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

derrubou alguns bytes por sugestões nos comentários de Ghost, raznagul e auhmaan.

Lote, 262 bytes

@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: As linhas 2, 3 e 4 terminam em um espaço e também produz um espaço à direita em cada linha. Estes podem ser removidos a um custo de 5 bytes. Funciona criando as variáveis ​​s1 ... s10 como as metades inferiores dos bonecos de neve, achatando as fornecidas como argumentos da linha de comando. As linhas apropriadas são impressas duas vezes, pela primeira vez com as metades inferiores substituídas pelas metades superiores. Isso economiza 18 bytes usando dois conjuntos de variáveis ​​da metade superior e inferior.

JavaScript, 154 149 bytes

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>

Pitão, 63 bytes

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

Um programa que recebe a entrada de uma lista de números inteiros e imprime o resultado.

Suíte de teste

[Explicação que vem depois]

Pitão, 51 bytes

O código contém alguns imprimíveis, então aqui está um 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

Experimente online.

Sem imprimíveis, 52 bytes

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

Experimente online.

Javascript 178 169 bytes

Essencialmente uma porta da minha resposta c #.

Toma uma matriz int como a lista de "pinos" achatados;

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}

Embrulhado:

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}

Expandido e explicado:

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