Desenhe um raio ASCII

35

Introdução

Parcialmente inspirado por essa pergunta do StackOverflow , vamos desenhar um Lightning Bolt ASCII.

Escreva um programa que obtenha um número inteiro positivo nvia STDIN ou linha de comando e emita o ASCII Lightning Bolt abaixo.

Entrada

Número inteiro positivo que nrepresenta o número de camadas de zigue-zague de raios para desenhar.

Saída de exemplo

n = 1

__
\ \
 \ \
  \ \
   \/

n = 2

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

n = 3

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

n = 4

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

. . . etc

Notas Adicionais

  • Você pode escrever uma função que aceite ncomo único argumento e imprima ou retorne a string.
  • Espaços à direita e novas linhas estão bem.
  • Não há espaços à esquerda, exceto onde apropriado para o padrão designado.
  • O menor código em bytes vence.
code-golf  ascii-art 
— CzarMatt
fonte
2
Quantos desses desafios já vimos até agora?
— flawr
@flawr Too many 😯
— Decay Beta

Respostas:

19

Java, 201 196 189 186 182 bytes

Obviamente não é o melhor, mas é em 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
fonte
23
Ah, Java, a linguagem em que você já perdeu antes de começar a digitar o corpo do seu mainmétodo.
— David Richerby
2
Às vezes acho que isso mainnão deve contar para a contagem de bytes, e talvez alguns idiomas com palavras-chave detalhadas devam ter macros permitidas. Então seria interessante
— Alec Teal
@AlecTeal Concordo totalmente, algumas perguntas na verdade especificam que exigem apenas snippets funcionais, mas a maioria não.
— David Mulder
6
Você pode escrever uma função que aceita n como o único argumento e imprime ou retorna a string. Então, umm, você provavelmente deve fazer isso;)
— Geobits
Pode demorar seis meses, mas codegolf.stackexchange.com/a/64713/42736 ou o uso de uma função a tornam mais curta.
— J Atkin
10

CJam, 41 bytes

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

Provavelmente posso extrair mais alguns bytes, mas aqui está uma compactação. Eu escolhi uma base que levaria a não imprimíveis.

Experimente online .

O raio é dividido em top + middle * (input-1) + bottom, onde top, middle, bottom(comprimida utilizando a conversão de bases) são

__
\. 

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

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

(Os espaços estão marcados com .s)

40 bytes

Graças ao Optimizer

"¹Ñ³Û- + ÎDx ^ áÐ" 254b6b "
_ \ 0 / "f =) / ~ ri (* \
— Sp3000
fonte
40
— Otimizador
Obrigado pela explicação com top + middle * (input-1) + bottom, ele me lembrou que PowerShell poderia multiplicar cordas: P
— Nacht - Reintegrar Monica
8

JavaScript ( ES6 ) 76

Usando a sequência de modelo, as três novas linhas são significativas e contadas.

Teste a execução do snippet (apenas 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 snippet

— edc65
fonte
7

PowerShell, 72 63 bytes

Windows estúpido e seu \ r \ n ... Isso poderia ter sido 67 59 bytes!

%{$a="\ \
";"__
$a"+" $a`__$a\  __\
"*($_-1)+" $a  $a   \/"}
— Nacht - Restabelecer Monica
fonte
Para o código de golfe, acho que \ r \ n ainda conta como \ n, uma vez que faz a mesma coisa
— 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)."
  \ \ 
   \/"

Visualize a fonte de resultados ou envolva-a <pre />para verificar os resultados. As novas linhas são necessárias no código.
O -1 poderia ser movido para o define, mas considerei isso uma trapaça.

1º aprimoramento: substitua \npor novas linhas reais
2º: Como eu posso definir um var, usei um CONTANT, segura o $. + um espaço desnecessário em str_repeat
3º: removeu acidentalmente o -1, mas salvou um byte usando em <?=vez de eco.

— Martijn
fonte
6

Pyth, 60 54 bytes (Obrigado @isaacg)

Minha primeira tentativa em Pyth, provavelmente muito ruim.

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

Verifique aqui .

— JNV
fonte
Bem-vindo ao Pyth! A propósito, Pyth permite novas linhas literais em suas strings, que seriam 1 caractere menor que \n. Além disso, o primeiro \\ no programa poderia ser apenas um \ .
— Isaacg
@isaacg Obrigado.
— JNV
4

Brainfuck, 164 bytes

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

Com comentários:

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

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

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

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

Ok, como essa resposta Brainfuck vence Java e C #?

— Mão-E-Comida
fonte
Woah, bom golfe, especialmente em BF!
— MilkyWay90
4

> <> (Peixe), 409 bytes

Execute por fish.py bolt.fish --value nonde bolt.fishestá o nome do programa e né sua entrada inteira positiva.

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

Não é curto, mas parece legal. Minha tentativa foi tentar fazer parecer um relâmpago. Além disso, sempre erros na conclusão.

— Capitão Homem
fonte
3

Perl, 69 + 1

69 caracteres, mais 1 para a -nlinha de comando alternar para buscar entrada de stdin.

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

Exemplo de uso:

perl -ne '$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"' <<<"2"
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
— ossifrage melindroso
fonte
11
Algumas melhorias possíveis: perl -pe'$_="__\ns s"."__s\\ __\\\n s"x--$_." s \\/";s!s!\\ \\\n!g'. Além disso\n pode ser substituído por uma quebra de linha literal para outros 3 caracteres salvos.
— nutki
3

Javascript (ES6), 86

Não vou ganhar, mas eu amo a solução em 1 linha e odeio barras.

f=n=>atob("X18KXCBc"+"CiBcIFwKX19cIFwKXCAgX19c".repeat(n-1)+"CiBcIFwKICBcIFwKICAgXC8")
— Michael M.
fonte
Legal! O que esta fazendo?
— Rpax 6/06/2015
11
@rpax Eu usei a codificação base64 para evitar \\ e \ n. Dê uma olhada na atob documentação
— Michael M.
3

C, 101 bytes

Minha implementação não tão original em c

f(n){puts("__\n\\ \\");for(;--n;puts(" \\ \\\n__\\ \\\n\\  __\\"));puts(" \\ \\\n  \\ \\\n   \\/");}
— Johan du Toit
fonte
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);}}

Essa não é a melhor ou a menor resposta, mas achei que tentaria. A resposta da Fsacer é muito mais curta e acho que você deveria conferir. Eu apenas decidi fazer isso apenas como um método alternativo.

— Comunidade
fonte
11
Ei, aqui eu facilmente deixei cair para 182B. 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 6/06/2015
Legal, e apenas curioso, mas por que você mudou o tipo de e de int para var? Ainda são 3 caracteres: P
Nenhuma razão, talvez porque eu amor var palavra-chave :)
— 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",@"\ \
"));}}

EDIT 1: aprimorou o resultado de 186B para 173B
EDIT 2: salvou 1B usando em PadLeftvez de PadRight
EDIT 3: salvou 8B removendo PadLefto segundo parâmetro e usando literais de string literal

— fsacer
fonte
Bom ... Você pode acabar com o publicno início e, em vez de usar uma matriz de caracteres, você pode usar String.PadRight(int, char), que é mais curto e permitirá que você use um caractere ascii que não precise escapar.
— VisualMelon
Alguns ajustes: * solte o segundo parâmetro em PadLeft (); está implícito (-4) * altere 2 das strings para literalmente (o OP diz que novas linhas são boas e só precisamos \ n, mas não \ \ \ \ \ \, então -4) Resultado final: classe I {static void Main ( string [] a) {System.Console.Write (("__ \ na a" + "". PadLeft (int.Parse (a [0]) - 1). Substitua ("", @ "__ a \ __ \ a ") +" a \\ / "). Replace (" a ", @" \ \ "));}} [Não consigo exibir novas linhas nos comentários, mas você pode editar a resposta original!]
— sellotape
Sugestões agradáveis, era difícil Verbatim formatação, a fim :)
— fsacer
3

Awk, 101 + 8 bytes

101 caracteres, mais 8 para -v n=$1obter um número inteiro do shell.

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

Novo neste site SE, não está claro se esses parâmetros devem contar.

Ungolfed

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   \\/"
}'

Exemplo 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
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
— só navegando
fonte
— Martin Ender
Vamos formulá-lo como " calculado corretamente", porque definitivamente não é feito corretamente. Se a atribuição de variável for colocada após o código, não haverá necessidade da -v peça. Sem mencionar que toda a ideia da variável é desnecessária, assim como o ENDbloco 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 é o meu primeiro código de golfe

@ (^ _ ^) @

Teste aqui

— Pwed
fonte
Este é o python 3? Essa entrada () funcionará para números inteiros?
— precisa
2

C, 119 108 bytes

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

Primeira tentativa, 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á aceitando um argumento int, então execute assim: ./lightning . . .para passar 4como argumento.

— aragaer
fonte
2

Python 3, 126 118 117 bytes

Apenas algo para nos começar.

n=int(input())
p=print
p('__\n\\ \\')
for i in[0]*~-n:p(r''' \ \
__\ \
\  __\
''',end='')
p(r''' \ \
  \ \
   \/
''')
— O número um
fonte
Se você não precisar da variável loop, pode iterar através [0]*(n-1)da calha para obter n-1iterações. Você também pode escrever (n-1)como ~-n.
— randomra
Você pode salvar um byte, alterando i in [0]para i in[0].
— mbomb007
Bem vinda! Uma cópia única linha no circuito também é mais curto: for i in[0]*~-n:p(' \\ \\\n__\\ \\\n\\ __\\').
— Random20
2

Python 2, 76 bytes

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

Basta imprimir as três primeiras linhas, depois as próximas três linhas n-1e depois as 2 linhas finais. Tudo de uma só vez.

E aqui está uma boa tentativa de uma alternativa que (infelizmente) use exatamente o mesmo número de bytes:

print('__\n| |'+'__|\  __\\\n |'*~-input()+'  |   \/').replace('|','\ \\\n')
— Matty
fonte
Você já tentou usar a formatação% s para a parte do meio?
— Sp3000 6/06/15
@ Sp3000 Preciso de chaves ao redor para fazer funcionar com o *, que me dá 77 bytes - ou não o inline, mas custa 79 bytes. :(
— Matty
2

F #, 98 caracteres, 105 bytes

let l n=(@"__♪◙\z"+String.replicate(n-1)@" \z__\z\  __\♪◙"+ @" \z  \z   \/").Replace("z"," \\\n")
— Mão-E-Comida
fonte
2

CJam 54 Chars

não é o mais curto, mas desde que eu comecei o CJam hoje, estou feliz com isso.

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

Tente

— TobiasR.
fonte
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.

Afinal, a única força do golfe de Pascal é que as barras invertidas não precisam escapar ...

— homem a trabalhar
fonte
11
for n:=2 to n dotambém funciona.
— randomra
Obrigado, @randomra. Eu acho que foi ~ 18 anos atrás, quando eu estava ciente dessa possibilidade ... É bom lembrar disso.
— manatwork
2

Planilhas Google, 60 bytes

Função de planilha anônima que leva a entrada do intervalo [A1]e as saídas para a célula chamadora.

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

EspecificaçõesBAS - 135 104 bytes

O apóstrofo nas instruções PRINT move o cursor para uma nova linha.

O SpecBAS permite incorporar caracteres ASCII em uma string por meio de #n , portanto, incorporou alguns retornos de carro (ASCII 13).

Construiu uma sequência usando retornos de carro e outros caracteres e, em seguida, usou-a REP$para repeti-la o número necessário de vezes.

1 LET b$="\ \": INPUT n: PRINT "__"'b$+REP$(#13" "+b$+#13"__"+b$+#13"\  __\",n-1)'" ";b$'"  ";b$'"   \/"
— Brian
fonte
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";

Versão Ungolfed

$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
fonte
Seu código pode ser melhorado ainda mais, chegando 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
Além disso: remova o $i=0; remova os suportes do forloop; incremente o contador dentro do loop ( 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
fonte
1

Retina , 46 bytes

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

1
__r\  __\# r
r
\ \#

Toma a entrada como unária.

Cada linha deve ir para seu próprio arquivo e #deve ser alterada para nova linha nos arquivos. Isso é impraticável, mas você pode executar o código como está, como um arquivo, com o -ssinalizador, mantendo os #marcadores. Você pode alterar as #linhas para novas linhas na saída para facilitar a leitura, se desejar. Por exemplo:

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

O algoritmo é muito simples. Os pares de linhas (regex - pares substitutos) executam as seguintes etapas de substituição:

  • Entrada surround com a parte superior e inferior do raio.
  • Subtraia 1da entrada unária.
  • Mude cada dígito unário para a parte do meio do raio.
  • Descomprima as \ \partes compactadas do raio para obter a saída desejada.
— randomra
fonte
Experimente online! (inclui conversão decimal), mas consegui fazê-lo em 45 bytes: Experimente online! (inclui conversão decimal).
— Neil
1

Powershell, 59 bytes

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

Script de teste:

$f = {

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

}

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

Saída:

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

Explicação:

Este script é tradicional top+ middle+ bottom. Há apenas uma coisa inteligente: a vírgula antes da cadeia do meio força a repetir um elemento da matriz em vez de uma cadeia. Portanto, cada um middleé exibido em uma nova linha.

— confuso
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.