Enquanto me movia, quebrei minha lâmpada. Agora, preciso de um novo. É seu trabalho me fazer uma lâmpada! Não tenho certeza do tamanho que desejo, embora saiba que quero um tamanho irregular.

Seu programa / função deve receber uma entrada numérica e imprimir uma lâmpada com tantos rabiscos / solavancos.

Exemplos:

Entrada:2

Resultado:

/ - \
 ()
 ()
/ __ \

Entrada:3

Resultado:

/ - \
 ()
 ()
 ()
/ __ \

Entrada:5

Resultado:

/ - \
 ()
 ()
 ()
 ()
 ()
/ __ \

Regras:

• 0 e números negativos não importam
• Para dar às lâmpadas (um desafio esse) uma variedade maior, você deve alterar a tonalidade da lâmpada.
  • Eles devem ter 4 caracteres de largura e 1 caractere de altura.
  • Eles podem estar em qualquer forma, incluindo formas que não sejam da sombra da lâmpada.
  • Eles não devem conter espaços em branco.
  • A base deve permanecer a mesma.
• Você deve mostrar um exemplo de entrada e saída com o seu abajur.
• O código mais curto vence!

Pitão - 16 bytes

Usa aspas para a sombra, já que N é pré-inicializado para isso.

*N4VQ+d`();"/__\

Experimente online aqui .

* 4            String repetition 4x, implicit print
 N             Preinitialized to Quote
VQ             For N in range(Q)
 +             String concat
  d            Space
   `()         Repr of empty tuple
;              Close for loop
"/__\          Implicitly print string, implicit close quote

Amostra para 5:

""""
 ()
 ()
 ()
 ()
 ()
/__\

Boneco de neve 0.2.0 , 42 caracteres

)vg10sB]"[--]
"sP:" ()
"sP;bR"/__"sP92wRsP

Exemplo de execução:

llama@llama:...Code/snowman/ppcg53483lamp$ snowman lamp.snowman
5
[--]
 ()
 ()
 ()
 ()
 ()
/__\

Então, só notei que esqueci de implementar a capacidade de escapar barras invertidas dentro de strings quando resolvi esse desafio. Definitivamente, isso será algo na próxima versão, mas por enquanto, aqui está o que eu fiz para imprimir a linha final:

"/__"sP92wRsP

92é o código ASCII de uma barra invertida, wRagrupa-o em uma matriz e agora posso imprimi-lo sPporque "strings" no Snowman são na verdade apenas matrizes de números.

> <> , 43 41 38 bytes

"\__/"aiv
"&-1v!?:<&a" ()
~"!_\
?!;o>l

Entrada através de um ponto de código, por exemplo, o espaço é 32. Isso usa parte do código do próprio programa como abajur, resultando em algo que se parece com uma antena parabólica:

~\_!
 ()
 ()
 ()
 ()
 ()
/__\

(Sugestão graças a @randomra)

Por mais três bytes, podemos alterar a terceira linha para adicionar um pouco mais de personalização:

"\__/"aiv
"&-1v!?:<&a" ()
__\"\~"/
?!;o>l

Isso produz uma daquelas lâmpadas que disparam luz para cima, por falta de uma maneira melhor de colocá-la:

\__/
 ()
 ()
 ()
 ()
 ()
/__\

R, 54 52 46 bytes

cat("RRRR",rep(" ()",scan()),"/__\\",sep="\n")

Nesta versão, entrada e saída são quase misturadas:

{in / out} COLOCAR:

> cat("RRRR",rep(" ()",scan()),"/__\\",sep="\n")
1: 4
2: 
Read 1 item
RRRR
 ()
 ()
 ()
 ()
/__\

EDIT 1 : -2 bytes graças ao comentário @manatwork.
EDIT 2 : -6 bytes. O crédito total vai para @manatwork novamente

Palha , 26 bytes (não concorrente)

<#~('--'
)>( ()
)-*>(/__\)>

Use '--'como abajur, faça a entrada em unário agora em decimal

CJam, 18 bytes

"/__\
"" ()
"ri*1$

Exemplo de execução para a entrada 5:

/__\
 ()
 ()
 ()
 ()
 ()
/__\

Experimente online aqui

JavaScript ES6, 34 bytes

i=>`|==|
${` ()
`.repeat(i)}/__\\`

As novas linhas são significativas

Exemplo com entrada 5:

|==|
 ()
 ()
 ()
 ()
 ()
/__\

sed, 28 bytes

s#.# ()\n#g
s#^\|$#/__\\\n#g

Recebe entrada em unário. A sombra é a seleção óbvia (igual à base).

Execução de teste

$ echo -n 111 | sed -f lamp.sed
/__\
 ()
 ()
 ()
/__\

Gema: 30 caracteres

*=gema\n@repeat{*;\ ()\n}/__\\

Exemplo de execução:

bash-4.3$ gema '*=gema\n@repeat{*;\ ()\n}/__\\' <<< 3
gema
 ()
 ()
 ()
/__\

jq: 30 caracteres

(Código de 29 caracteres + opção de linha de comando de 1 caractere.)

8888,(range(.)|" ()"),"/__\\"

Exemplo de execução:

bash-4.3$ jq -r '8888,(range(.)|" ()"),"/__\\"' <<< 3
8888
 ()
 ()
 ()
/__\

Teste on-line (a passagem do -rURL não é suportada - verifique você mesmo Raw Output.)

C, 54 bytes

Ligue f()com a altura desejada da lâmpada.

f(n){for(puts("||||");n--;puts(" ()"));puts("/__\\");}

Experimente em ideone.

Exemplo de saída para 5:

||||
 ()
 ()
 ()
 ()
 ()
/__\

Pyke, 15 bytes

" ()"~mQAD"/__\

Experimente aqui!

     ~m         - 1000
" ()"           -  " ()"
       QAD      - duplicate(^) input times
          "/__\ - "/__\"

Saídas:

1000
 ()
 ()
/__\

Kotlin , 36 bytes

{"|MM|\n${" ()\n".repeat(it)}/__\\"}

Experimente online!

Espaço em branco , 169 bytes

[S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer][S S S T S T T   T   S S N
_Push_92_\][S S S T S T T   T   T   T   N
_Push_95__][S N
S _Duplicate_95__][S S S T  S T T   T   T   N
_Push_47_/][N
S S N
_Create_Label_LOOP][S S S N
_Push_0][T  T   T   _Retrieve_at_address_0][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][S S S N
_Push_0][S N
T   _Swap_top_two][T    T   S _Store_at_address_0][N
T   T   S N
_If_neg_Jump_to_Label_PRINT][S S S T    S T S N
_Push_10_newline][S S S T   S T S S T   N
_Push_41_)][S S S T S T S S S N
_Push_40_(][S S S T S S S S S N
_Push_32_space][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    S T S N
_Push_10_newline][S S S T   S S S S T   N
_Push_33_!][S N
S _Duplicate_33_!][S N
S _Duplicate_33_!][S N
S _Duplicate_33_!][N
S S T   N
_Create_Label_LOOP_2][T N
S S _Print_as_character][N
S N
T   N
_Jump_to_Label_LOOP_2]

Letras S(espaço), T(guia) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-código:

Empurra todos os caracteres na ordem inversa para a pilha e os imprime em um loop.

Integer i = STDIN as input
Push "\__/" to the stack
Start LOOP:
  i = i - 1
  if(i is negative):
    Go to function PRINT
  Push "\n)( " to the stack
  Go to next iteration of LOOP

function PRINT:
  Push "\n!!!!" to the stack
  Start LOOP_2:
    Print top as character to STDOUT
    Go to next iteration of LOOP_2

NOTA: ino pseudo-código acima é armazenado de volta no heap em todas as iterações de LOOP, porque não queremos deixá-lo na pilha para ser impresso no final.

Tela , 8 bytes

(×_¶/ｅ⟳║

Experimente aqui!

Explicação:

(×        repeat "(" input times
  _¶/e    encase it on both sides in "_\n/"
          the 1st line is surrounded in "_" and the second ends and starts with "/"
      ⟳   rotate the string clockwise without changing characters
       ║  palindromize horizontally with 0 overlap

05AB1E , 17 15 13 11 bytes

„ (и„/_.ø)˜∞

-2 bytes (17 → 15) graças a @EriktheOutgolfer .
-2 bytes (13 → 11) depois de se inspirar na resposta do @dzaima no Canvas .

A tampa é igual à base ( /__\).

Explicação:

„ (            # Literal string " ("
   и           # Repeat " (" the input amount of times
               #  i.e. " (" and 3 → [' (',' (',' (']
    „/_        # Literal string "/_"
       .ø      # Surround the list of " (" with "/_" on both ends
               #  i.e. [' (',' (',' ('] → ['/_',[' (',' (',' (',' ('],'/_']
         ˜     # Flatten this list
               #  i.e. ['/_',[' (',' (',' ('],'/_'] → ['/_',' (',' (',' (','/_']
          ∞    # Mirror each item
               #  i.e. ['/_',' (',' (',' (','/_'] → ['/__\',' () ',' () ',' () ','/__\']
               # And output the list new-line delimited (implicitly due to the mirror)

Resposta antiga de 13 bytes:

„/_D„ (Iиs)˜∞

Experimente online.

Excel, 31 bytes

Uma função de planilha anônima que recebe entrada como um numérico do intervalo [A1]e sai para a célula chamadora.

Esta lâmpada é musical - e ajudará a animar e iluminar o seu dia.

="/\
"&REPT(" ()
",A1)&"/__\"

Resultado

PowerShell 5.1, 28. 26 bytes

_{Obrigado Mazzy por 2 bytes}

8008;," ()"*"$args";"/__\"

Como a sombra pode ter 4 caracteres, o uso de um número salva um par de aspas. A parte mais difícil foi encontrar uma sombra bonita.

Resultado:

PS C:\Users\ItsMe\Desktop> .\scratch.ps1 4
8008
 ()
 ()
 ()
 ()
/__\

Python 2, 36 bytes

print"-"*4+"\n ()"*input()+"\n/__\\"

Para a entrada 4:

----
 ()
 ()
 ()
 ()
/__\

Observe que, para o Python, qualquer sombra de lâmpada usando pipes é um byte a menos.

-1 bytes graças a @Alex!

Japonês , 17 bytes

Æ` ()`Ãi¥² p"/__\

Experimente online!

Saída para 5é:

====
 ()
 ()
 ()
 ()
 ()
/__\

SWI-Prolog, 73 60 bytes

a(X):-write(golf),writef("%r",["\n ()",X]),write("\n/__\\").

a(5). saídas

golf
 ()
 ()
 ()
 ()
 ()
/__\

Julia, 36 bytes

n->print("|~~|\n"*" ()\n"^n*"/__\\")

Isso cria uma função sem nome que recebe um número inteiro como entrada e imprime no stdout.

Exemplo:

julia> f(4)
|~~|
 ()
 ()
 ()
 ()
/__\

Bash + coreutils, 37 bytes

yes ' ()'|sed '1i####
'$1'{a/__\\
q}'

As novas linhas são necessárias e contadas no total de bytes. GNU sed é necessário.

Corre:

./squiggly_lamp.sh 2

Resultado:

####
 ()
 ()
/__\

Ruby, 42 bytes

i=gets.to_i
puts "|--|\n#{" ()\n"*i}/__\\"

Neoscript , 28 bytes

{n|"[~~]
"+" ()
"*n+"/--\\"}

Java 7 11, 84 83 37 bytes

n->"i!!i\n"+" ()\n".repeat(n)+"/__\\"

Experimente online. (NOTA: o Java 11 ainda não é suportado no TIO, por isso String.repeat(int)foi emulado comrepeat(String,int) para a mesma contagem de bytes.)

Usa i!!icomo tampa. ¡!!¡parece melhor , mas tem mais dois bytes.

Explicação:

n->                    // Method with integer parameter and String return-type
  "i!!i\n"             //  Return the cap + new-line
  " ()\n".repeat(n)    //   appended with " ()" and a new-line `n` amount of times
  "/__\\"              //   append with "/__\"

Perl 5 , 24 bytes

$_=$<.'
 ()'x$_.'
/--\
'

Experimente online!

Usa 1000como tampa.

Adiante , 38 bytes

I"|MM|"Wr
~W" ()"oN<s!:-1~
@W"/__\"oN<

Experimente online!

Amostras

1
|MM|
 ()
/__\

2
|MM|
 ()
 ()
/__\

3
|MM|
 ()
 ()
 ()
/__\

Befunge-93 , 50 bytes

"\__/"&v
0-1_v#:<g00" ()"*25p0
*25$<>:#,_@#::::"_"

Experimente online!

Exemplo com entrada 3

____
 ()
 ()
 ()
/__\

PHP, 38 bytes

/--\<?while($argn--)echo"
 ()"?>

/__\

Salvar em arquivo; execute como pipe -nFou experimente online .