Mientras me movía, rompí mi lámpara. Ahora necesito uno nuevo. ¡Es tu trabajo hacerme una lámpara! No estoy seguro de qué tamaño quiero, aunque sé que quiero uno ondulado.

Su programa / función debe incluir una entrada numérica e imprimir una lámpara con tantos garabatos / protuberancias.

Ejemplos:

Entrada:2

Salida:

/ - \
 ()
 ()
/ __ \

Entrada:3

Salida:

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

Entrada:5

Salida:

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

Reglas:

• 0 y números negativos no importan
• Para darle a las lámparas (un desafío de este tipo) más variadas, debe cambiar la pantalla de la lámpara.
  • Deben tener 4 caracteres de ancho y 1 de alto.
  • Pueden tener cualquier forma, incluso formas sin pantalla de lámpara.
  • No deben contener espacios en blanco.
  • La base debe permanecer igual.
• Debe mostrar un ejemplo de entrada y salida con la pantalla de su lámpara.
• ¡El código más corto gana!

Pyth - 16 bytes

Utiliza comillas para el tono ya que N está preinicializado a eso.

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

Pruébelo en línea aquí .

* 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

Muestra para 5:

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

Muñeco de nieve 0.2.0 , 42 caracteres

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

Ejecución de muestra:

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

Así que solo noté que olvidé implementar la capacidad de escapar de las barras diagonales inversas cuando resolví este desafío. Eso definitivamente será algo en la próxima versión, pero por ahora, esto es lo que hice para imprimir la línea final:

"/__"sP92wRsP

92es el código ASCII para una barra diagonal inversa, lo wRenvuelve en una matriz y ahora puedo imprimirlo sPporque las "cadenas" en Snowman son en realidad solo matrices de números.

> <> , 43 41 38 bytes

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

Entrada a través de un punto de código, por ejemplo, el espacio es 32. Esto usa parte del propio código del programa como pantalla, lo que da como resultado algo que parece una antena parabólica:

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

(Sugerencia gracias a @randomra)

Para tres bytes más, podemos cambiar la tercera línea para agregar un poco más de personalización:

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

Esto produce una de esas lámparas que disparan la luz hacia arriba, a falta de una mejor manera de decirlo:

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

R, 54 52 46 bytes

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

En esta versión, entrada y salida. están casi mezcladas:

{entrada / salida} PONER:

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

EDITAR 1 : -2 bytes gracias al comentario de @manatwork.
EDITAR 2 : -6 bytes. El crédito completo va a @manatwork nuevamente

Paja , 26 bytes (no competitivos)

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

Úselo '--'como pantalla de lámpara, tome la entrada en unario ahora en decimal

CJam, 18 bytes

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

Ejecución de muestra para la entrada 5:

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

Pruébalo en línea aquí

JavaScript ES6, 34 bytes

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

Las nuevas líneas son significativas.

Ejemplo con entrada de 5:

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

sed, 28 bytes

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

Toma entrada en unario. La sombra es la selección obvia (igual que la base).

Prueba de funcionamiento

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

Gema: 30 caracteres

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

Ejecución de muestra:

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

jq: 30 caracteres

(Código de 29 caracteres + opción de línea de comando de 1 carácter).

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

Ejecución de muestra:

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

Prueba en línea ( -rno se admite el paso por la URL; compruebe usted mismo la salida sin formato).

C, 54 bytes

Llame f()con la altura deseada de la lámpara.

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

Pruébalo con ideone.

Ejemplo de salida para 5:

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

Pyke, 15 bytes

" ()"~mQAD"/__\

Pruébalo aquí!

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

Salidas:

1000
 ()
 ()
/__\

Kotlin , 36 bytes

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

Pruébalo en línea!

Espacio en blanco , 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébalo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocódigo:

Empuja todos los caracteres en orden inverso a la pila y luego los imprime en un bucle.

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: ien el pseudocódigo anterior se almacena de nuevo en el montón en cada iteración de LOOP, porque no queremos dejarlo en la pila para que se imprima al final.

Lienzo , 8 bytes.

(×_¶/ｅ⟳║

Pruébalo aquí!

Explicación:

(×        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) gracias a @EriktheOutgolfer .
-2 bytes (13 → 11) después de inspirarse en la respuesta de Canvas de @dzaima .

La tapa es igual a la base ( /__\).

Explicación:

„ (            # 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)

Antigua respuesta de 13 bytes:

„/_D„ (Iиs)˜∞

Pruébalo en línea.

Excel, 31 bytes

Una función de hoja de trabajo anónima que toma la entrada como un valor numérico del rango [A1]y las salidas a la celda que llama.

Esta lámpara es musical y ayudará a animar y alegrar tu día.

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

Salida

PowerShell 5.1, 28 26 bytes

_{Gracias Mazzy por 2 bytes}

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

Dado que la sombra puede tener 4 caracteres, usar un número ahorra un par de comillas. La parte más difícil fue encontrar un tono agradable.

Salida:

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

Python 2, 36 bytes

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

Para la entrada 4:

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

Tenga en cuenta que para Python que cualquier pantalla de lámpara que use tuberías es un byte menos.

-1 bytes gracias a @Alex!

Japt , 17 bytes

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

Pruébalo en línea!

La salida para 5es:

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

SWI-Prolog, 73 60 bytes

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

a(5). salidas

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

Julia, 36 bytes

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

Esto crea una función sin nombre que toma un entero como entrada e imprime en stdout.

Ejemplo:

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

Bash + coreutils, 37 bytes

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

Las nuevas líneas son necesarias y se cuentan en el total de bytes. Se requiere GNU sed.

Correr:

./squiggly_lamp.sh 2

Salida:

####
 ()
 ()
/__\

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)+"/__\\"

Pruébalo en línea. (NOTA: Java 11 aún no es compatible con TIO, por lo que String.repeat(int)se ha emulado conrepeat(String,int) el mismo número de bytes).

Usos i!!icomo gorra. ¡!!¡Se ve mejor , pero es dos bytes más.

Explicación:

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$_.'
/--\
'

Pruébalo en línea!

Usos 1000como la tapa.

Por delante , 38 bytes

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

Pruébalo en línea!

Muestras

1
|MM|
 ()
/__\

2
|MM|
 ()
 ()
/__\

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

Befunge-93 , 50 bytes

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

Pruébalo en línea!

Ejemplo con entrada 3

____
 ()
 ()
 ()
/__\

PHP, 38 bytes

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

/__\

Guardar en archivo; ejecutar como tubería -nFo probarlo en línea .