Dibuja un rayo ASCII

35

Introducción

En parte inspirado por esta pregunta de StackOverflow , dibujemos un Lightning Bolt ASCII.

Escriba un programa que tome un número entero positivo a ntravés de STDIN o línea de comando y envíe el rayo ASCII a continuación.

Entrada

Entero positivo que nrepresenta el número de niveles de zig-zag de rayos para dibujar

Salida de ejemplo

n = 1

__
\ \
 \ \
  \ \
   \/

n = 2

__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

n = 3

__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

n = 4

__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

. . . etc.

Notas adicionales

  • Puede escribir una función que tome ncomo único argumento e imprima o devuelva la cadena.
  • Los espacios finales y las nuevas líneas están bien.
  • No hay espacios iniciales excepto donde sea apropiado para el patrón designado.
  • El código más corto en bytes gana.
code-golf  ascii-art 
— CzarMatt
fuente
2
¿Cuántos de esos desafíos hemos visto hasta ahora?
— flawr
@flawr Demasiados 😯
— Beta Decay

Respuestas:

19

Java, 201 196 189 186 182 bytes

Obviamente no es el mejor, pero está en Java.

class I{public static void main(String[]a){System.out.print(("__\na a"+new String(new byte[new Byte(a[0])-1]).replace("\0","__a\\  __\\\n a")+"  a   \\/").replace("a","\\ \\\n"));}}
— Olivia Trewin
fuente
23
Ah, Java, el lenguaje donde ya has perdido antes de comenzar a escribir el cuerpo de tu mainmétodo.
— David Richerby
2
A veces pienso que mainno debería contar para el recuento de bytes, y algunos idiomas que tienen palabras clave detalladas deberían tener permitidas las macros. Entonces sería interesante
— Alec Teal
@AlecTeal Totalmente de acuerdo, algunas preguntas en realidad especifican que solo requieren fragmentos funcionales, pero la mayoría no.
— David Mulder
66
Puede escribir una función que tome n como único argumento e imprima o devuelva la cadena. Entonces, umm, probablemente deberías hacer eso;)
— Geobits
Puede tardar 6 meses, pero codegolf.stackexchange.com/a/64713/42736 o el uso de una función lo acortan.
— J Atkin
10

CJam, 41 bytes

":¡ö cQïO[nu÷&,"255b6b"
 _\/X"f='X/~ri(*\

Probablemente pueda exprimir algunos bytes más, pero aquí hay algo de compresión. Escogí una base que no conduciría a que no se puedan imprimir.

Pruébalo en línea .

El rayo se divide en top + middle * (input-1) + bottom, donde top, middle, bottom(comprimido con la conversión de base) son

__
\. 

  \
.\.\
__\.\
\..__ 

    \
.\.\
..\.\
...\/

(Los espacios están marcados con .s)

40 bytes

Gracias a Optimizer

"¹Ñ³Û- + ÎDx ^ áÐ" 254b6b "
_ \ 0 / "f =) / ~ ri (* \
— Sp3000
fuente
40
— Optimizador
gracias por la explicación top + middle * (input-1) + bottom, me recordó que powershell podría multiplicar cadenas: P
— Nacht - Reinstate Monica
8

JavaScript ( ES6 ) 76

Usando una cadena de plantilla, las 3 nuevas líneas son significativas y contadas.

Prueba de ejecución del fragmento (solo Firefox)

f=n=>`__
1 1${`__1\\  __\\
 1`.repeat(n-1)}  1   \\/`.replace(/1/g,`\\ \\
`)

// TEST

go=_=>O.innerHTML=f(I.value)

go()
N: <input id=I value=3><button onclick='go()'>Test</button>
<pre id=O></pre>
Expandir fragmento

— edc65
fuente
7

PowerShell, 72 63 bytes

Estúpido Windows y tu \ r \ n ... ¡Esto podría haber sido 67 59 bytes!

%{$a="\ \
";"__
$a"+" $a`__$a\  __\
"*($_-1)+" $a  $a   \/"}
— Nacht - Restablece a Monica
fuente
Para el golf de código, creo que \ r \ n todavía cuenta como \ n, ya que hace lo mismo
— MilkyWay90
6

PHP - 84 79 78 bytes

<?php
define('N',3); // <- didnt count these bytes as TS said I could take var N as input
?>
<?="__
\ \
 \ \ ".str_repeat("
__\ \
\  __\
 \ \ ",N-1)."
  \ \ 
   \/"

Ver el origen del resultado o envolverlo <pre />para verificar los resultados. Las nuevas líneas son obligatorias en el código.
El -1 podría moverse al define, pero lo consideré un truco.

1ra mejora: reemplazar \ncon nuevas líneas reales
2da: Como puedo definir una var, utilicé un CONTANTE, guarda la $. + un espacio innecesario en str_repeat
3rd: eliminó accidentalmente el -1, pero guardó un byte utilizando en <?=lugar de echo.

— Martijn
fuente
6

Pyth, 60 54 bytes (Gracias @isaacg)

Mi primer intento en Pyth, probablemente muy malo.

"__
\ \ "VtQ" \ \ 
__\ \ 
\  __\ ")" \ \ 
  \ \ 
   \/

Verifícalo aquí .

— JNV
fuente
¡Bienvenido a Pyth! Por cierto, Pyth permite nuevas líneas literales en sus cadenas, que serían 1 carácter más corto que \n. Además, el primero \\ en el programa podría ser solo un \ .
— isaacg
@isaacg Gracias.
— JNV
4

Brainfuck, 164 bytes

,<++++++++++++++++[>--->+>++++++>++>++++++>+++<<<<<<-]>->--->---->>->-<..<<<.>.>
.<.<.>>.<.>.<.<.<[>>>>..<<.>.<.<.>.>..>..<<.<.>>.<.>.<.<.<-]>>>..<.>.<.<.>>...<.
>>>.

Con comentarios:

Initialise n and character set with i as counter
Memory = in♪\ _/
,<++++++++++++++++[>--->+>++++++>++>++++++>+++<<<<<<-]>->--->---->>->-

Draw top of lightning bolt
<..<<<.>.>.<.<.>>.<.>.<.<.<

Draw lightning bolt zigzags
[>>>>..<<.>.<.<.>.>..>..<<.<.>>.<.>.<.<.<-]

Draw lightning bolt tip
>>>..<.>.<.<.>>...<.>>>.

Bien, ¿cómo responde Brainfuck a Java y C #?

— Hand-E-Food
fuente
Woah, buen golf, especialmente en BF!
— MilkyWay90
4

> <> (Pez), 409 bytes

Ejecute por fish.py bolt.fish --value ndónde bolt.fishestá el nombre del programa y nes su entrada entera positiva.

\
\         "__"       a
\         "\ \"      a
\         " \ \"     a
\r1-:?!vr "__\ \"    a
\     !0  "\  __\"   a
\     !6  " \ \"  a04.
>r   9a.  "__\ \"    \
      /   "\  __\"  \ 
       /  " \ \"   \  
        / "  \ \" \   
         /"   \/"\    
                 aaaaa
|o|!~r           /    
         \        /   
        \          /  
       \            / 
      \              /

No es corto, pero se ve genial. Mi intento fue intentar que pareciera un rayo. Además, siempre errores al finalizar.

— Capitán Hombre
fuente
3

Perl, 69 + 1

69 caracteres, más 1 para el -ncambio de línea de comando para obtener la entrada de stdin.

$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"

Ejemplo de uso:

perl -ne '$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"' <<<"2"
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
— ossifrage aprensivo
fuente
1
Algunas mejoras posibles: perl -pe'$_="__\ns s"."__s\\ __\\\n s"x--$_." s \\/";s!s!\\ \\\n!g'. También \nse puede reemplazar con un salto de línea literal para otros 3 caracteres guardados.
— nutki
3

Javascript (ES6), 86

No voy a ganar, pero me encanta la solución de 1 línea y odio los cortes.

f=n=>atob("X18KXCBc"+"CiBcIFwKX19cIFwKXCAgX19c".repeat(n-1)+"CiBcIFwKICBcIFwKICAgXC8")
— Michael M.
fuente
¡Guay! Que esta haciendo
— rpax
1
@rpax Usé la codificación base64 para evitar \\ y \ n. Echa un vistazo a la atob documentación
— Michael M.
3

C, 101 bytes

Mi implementación no tan original en c

f(n){puts("__\n\\ \\");for(;--n;puts(" \\ \\\n__\\ \\\n\\  __\\"));puts(" \\ \\\n  \\ \\\n   \\/");}
— Johan du Toit
fuente
3

C #, 221 bytes

class C{static void Main(string[]n){int e=System.Int32.Parse(n[0]);var o=@"__{0}\ \{0} \ \{0}";while(e>1){o+=@"__\ \{0}\  __\{0} \ \{0}";e--;}System.Console.WriteLine(o + @"  \ \{0}   \/{0}",System.Environment.NewLine);}}

Esta no es la mejor o la respuesta más pequeña, pero pensé que lo intentaría. La respuesta de Fsacer es mucho más corta y creo que deberías echarle un vistazo. Simplemente decidí hacer esto solo como un método alternativo realmente.

— Comunidad
fuente
1
Oye, aquí lo dejé caer fácilmente a 182B. Código:class C{static void Main(string[]n){var e=int.Parse(n[0]);var o=@"__{0}\ \{0} \ \{0}";while(e-->1){o+=@"__\ \{0}\ __\{0} \ \{0}";}System.Console.Write(o+@" \ \{0} \/{0}","\n");}}
— fsacer
Agradable, y solo curioso, pero ¿por qué cambiaste el tipo de e de int a var? Todavía son 3 caracteres: P
No hay razón, tal vez porque amo la palabra clave var :)
— fsacer
3

C #, 166 bytes

class I{static void Main(string[]a){System.Console.Write(("__\na a"+"".PadLeft(int.Parse(a[0])-1).Replace(" ",@"__a\  __\
 a")+@"  a   \/").Replace("a",@"\ \
"));}}

EDITAR 1: mejoró el resultado de 186B a 173B
EDITAR 2: guardó 1B utilizando en PadLeftlugar de PadRight
EDITAR 3: guardó 8B eliminando PadLeftel segundo parámetro y utilizando literales de cadena textuales

— fsacer
fuente
Agradable ... Puede eliminar el publical principio, y en lugar de usar una matriz de caracteres, puede usar String.PadRight(int, char), que es más corto y le permitirá usar un carácter ascii que no necesita escapar.
— VisualMelon
Algunos ajustes: * suelte el segundo parámetro a PadLeft (); está implícito (-4) * cambia 2 de las cadenas a textualmente (el OP dice que las nuevas líneas están bien, y solo necesitamos \ n, no completo \ r \ n, entonces -4) Resultado final: clase I {static void Main ( cadena [] a) {System.Console.Write (("__ \ na a" + "". PadLeft (int.Parse (a [0]) - 1) .Replace ("", @ "__ a \ __ \ a ") +" a \\ / "). Reemplazar (" a ", @" \ \ "));}} [¡No puedo mostrar nuevas líneas en los comentarios, pero puedes editar la respuesta original!]
— sellotape
Buenos consejos, fue difícil formatear textualmente en orden :)
— fsacer
3

Awk, 101 + 8 bytes

101 caracteres, más 8 para -v n=$1obtener un entero del shell.

'{l="\\ \\";print"__\n"l"\n "l;for(i=1;i<n;++i)print"__"l"\n\\  __\\\n "l}END{print"  "l"\n   \\/"}'

Nuevo en este sitio de SE, no está claro si esos parámetros deberían contar.

Sin golf

awk 
-v n=$1
'{
  l="\\ \\";
  print "__\n"l"\n "l;
  for(i=1; i<n; ++i)
    print "__"l"\n\\  __\\\n "l
}
END
{
  print "  "l"\n   \\/"
}'

Ejemplo de uso:

lightning() { echo | awk -v n=$1 '{l="\\ \\";print"__\n"l"\n "l;for(i=1;i<n;++i)print"__"l"\n\\  __\\\n "l}END{print"  "l"\n   \\/"}'; }
lightning 3
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
— justbrowsing
fuente
— Martin Ender
Vamos a formularlo como " calculado ese derecho", porque definitivamente no se hizo bien. Si la asignación de variable se coloca después del código, no hay necesidad de la -v parte. Sin mencionar que toda la idea variable es innecesaria, al igual que el ENDbloque separado . 89 caracteres: {l="\\ \\";print"__\n"l"\n "l;for(;--$1;)print"__"l"\n\\ __\\\n "l;print" "l"\n \\/"} pastebin.com/NCznF9kH
— manatwork
3

Python 97 82 78char:

print(("__\nl l"+"__l\  __\\\n l"*~-input()+"  l   \/").replace('l','\ \\\n'))

Este es mi primer código de golf

@ (^ _ ^) @

Prueba aquí

— Pwed
fuente
¿Esto es Python 3? ¿Esa entrada () funcionará para enteros?
— Renae Lider
2

C, 119108 bytes

p(t){for(;t;t/=4)putchar(" \\_\n"[t%4]);}main(c){for(p(13434);p(836),--c;p(57154842));p(265488);puts("/");}

Primer intento, 150 bytes

v(a){putchar(a);}s(b){b--?v(32),s(b):v(92);}l(b){s(b);s(1);v(10);}main(c){for(puts("__\n\\ \\");l(1),--c;puts("__\\ \\\n\\  __\\"));l(2);s(3);v(47);}

mainestá aceptando un argumento int, así que ejecuta de esta manera: ./lightning . . .pasar 4como argumento.

— aragaer
fuente
2

Pitón 3, 126 118 117 bytes

Solo algo para comenzar con nosotros.

n=int(input())
p=print
p('__\n\\ \\')
for i in[0]*~-n:p(r''' \ \
__\ \
\  __\
''',end='')
p(r''' \ \
  \ \
   \/
''')
— El numero uno
fuente
Si no necesita la variable de bucle, puede iterar a través [0]*(n-1)para obtener n-1iteraciones. También puedes escribir (n-1)como ~-n.
— randomra
Puede guardar un byte cambiando i in [0]a i in[0].
— mbomb007
¡Bienvenido! Una impresión de una sola línea en el bucle es también más corta: for i in[0]*~-n:p(' \\ \\\n__\\ \\\n\\ __\\').
— randomra
2

Python 2, 76 bytes

print'__\n\ \\\n \ \\\n'+r'''__\ \
\  __\
 \ \
'''*~-input()+'  \ \\\n   \/'

Simplemente imprima las primeras tres líneas, luego imprima las siguientes tres líneas n-1 veces, y luego imprimir las últimas 2 líneas. Todo de una vez.

Y aquí hay un buen intento en una alternativa que (desafortunadamente) usa exactamente el mismo número de bytes:

print('__\n| |'+'__|\  __\\\n |'*~-input()+'  |   \/').replace('|','\ \\\n')
— Matty
fuente
¿Has intentado usar el formato% s para la parte media?
— Sp3000
@ Sp3000 Necesito llaves alrededor para que funcione con el *, eso me da 77 bytes, o no lo alineo, pero eso cuesta 79 bytes. :(
— Matty
2

F #, 98 caracteres, 105 bytes

let l n=(@"__♪◙\z"+String.replicate(n-1)@" \z__\z\  __\♪◙"+ @" \z  \z   \/").Replace("z"," \\\n")
— Hand-E-Food
fuente
2

CJam 54 Chars

No es el más corto, pero desde que comencé CJam hoy, estoy contento con él.

rd(:T;{'__}:W~N{'\:XSXN}:V~SV{WVXSSWXNSV;N}T*SSVSSSX'/

Intentalo

— TobiasR.
fuente
2

Pascal: 149 142 141 137 caracteres

var n:Word;begin
Read(n);Writeln('__'#10'\ \'#10' \ \');for n:=2to n do Writeln('__\ \'#10'\  __\'#10' \ \');Write('  \ \'#10'   \/')end.

Después de todo, la única fortaleza de golf de Pascal es que las barras invertidas no necesitan escapar ...

— hombre trabajando
fuente
1
for n:=2 to n doTambién funciona.
— randomra
Gracias, @randomra. Creo que fue hace ~ 18 años cuando me di cuenta de esta posibilidad ... Es bueno recordarlo.
— manatwork
2

Hojas de cálculo de Google, 60 bytes

Función de hoja de trabajo anónima que toma entrada del rango [A1]y salidas a la celda que llama.

="__
\ \
 \ \
"&REPT("__\ \
\  __\
 \ \
",A1-1)&"  \ \
   \/
— Taylor Scott
fuente
1

SpecBAS - 135 104 bytes

El apóstrofe en las instrucciones PRINT mueve el cursor a una nueva línea.

SpecBAS le permite incorporar caracteres ASCII en una cadena a través de #n, por lo que ha incorporado algunos retornos de carro (ASCII 13).

Construyó una cadena usando retornos de carro y otros caracteres, luego solía REP$repetirla la cantidad requerida de veces.

1 LET b$="\ \": INPUT n: PRINT "__"'b$+REP$(#13" "+b$+#13"__"+b$+#13"\  __\",n-1)'" ";b$'"  ";b$'"   \/"
— Brian
fuente
1

PHP 155

$l=PHP_EOL;echo$l;echo "__$l";for($i=0;$i<$argv[1];$i++){if($i>=1)echo "__\\ \\$l\\  __\\$l";else echo "\\ \\$l";echo " \\ \\$l";}echo "  \\ \\$l   \\/$l";

Versión sin golf

$n = $argv[1];

echo PHP_EOL;
echo '__'.PHP_EOL;
for($i=0;$i<$n;$i++)
{
    if($i>=1) {
        echo '__\\ \\'.PHP_EOL.'\\  __\\'.PHP_EOL;

    }
    else
    {
        echo '\\ \\'.PHP_EOL;
    }   
    echo ' \\ \\'.PHP_EOL; 


}    
echo '  \\ \\'.PHP_EOL;
echo '   \\/';
echo PHP_EOL;
— kuldeep.kamboj
fuente
Su código se puede mejorar aún más, lo bajó a 121 bytes. echo$l=PHP_EOL,"__$l";$g="\\ \\$l";for($i=0;$i<$argv[1];$i++){echo($i?"__$g\\ __\\$l":$g)," $g";}echo" $g",' \\/',$l;
— Octfx
Además: eliminar el $i=0; quite los corchetes para el forbucle; incremente el contador dentro del bucle ( echo($i++?"…).
— Blackhole
1

Java, 183 180 bytes

class L{public static void main(String[]a){String b="__\n\\ \\\n \\ \\\n";for(int i=1;i<new Long(a[0]);++i)b+="__\\ \\\n\\  __\\\n \\ \\\n";System.out.print(b+"  \\ \\\n   \\/");}}

Lua, 110 bytes

function l(n)print("__\n\\ \\\n \\ \\\n"..string.rep("__\\ \\\n\\  __\\\n \\ \\\n",n-1).."  \\ \\\n   \\/")end
— ECS
fuente
1

Retina , 46 bytes

.+
__#r r$0x  r   \/
1x

1
__r\  __\# r
r
\ \#

Toma la entrada como unario.

Cada línea debe ir a su propio archivo y #debe cambiarse a nueva línea en los archivos. Esto no es práctico, pero puede ejecutar el código tal cual, como un archivo, con la -sbandera, manteniendo los #marcadores. Puede cambiar los #'s a nuevas líneas en la salida para facilitar la lectura si lo desea. P.ej:

> echo -n 11|retina -s lightning|tr # '\n'
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

El algoritmo es muy simple. Los pares de líneas (expresiones regulares - pares sustitutos) realizan los siguientes pasos de sustitución:

  • Entrada envolvente con la parte superior e inferior del rayo.
  • Restar 1de la entrada unaria.
  • Cambia cada dígito unario en la parte media del rayo.
  • Descomprima las \ \partes comprimidas del rayo para obtener la salida deseada.
— randomra
fuente
Pruébalo en línea! (incluye conversión decimal) pero pude hacerlo en 45 bytes: ¡ Pruébelo en línea! (incluye conversión decimal).
— Neil
1

Powershell, 59 bytes

'__
\ \'
,' \ \
__\ \
\  __\'*--$args[0]
' \ \
  \ \
   \/'

Script de prueba:

$f = {

'__
\ \'
,' \ \
__\ \
\  __\'*--$args[0]
' \ \
  \ \
   \/'

}

&$f 1
&$f 2
&$f 3
&$f 4

Salida:

__
\ \
 \ \
  \ \
   \/
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

Explicación:

Este script es tradicional top+ middle+ bottom. Solo hay una cosa inteligente: la coma antes de la cadena central obliga a repetir un elemento de matriz en lugar de una cadena. Por lo tanto, cada uno middlese muestra en una nueva línea.

— mazzy
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.