Dessinez un éclair ASCII

35

introduction

Inspiré en partie par cette question de StackOverflow , dessinons un éclair ASCII.

Ecrivez un programme qui prend un entier positif nvia STDIN ou une ligne de commande et génère le Lightning Bolt ASCII ci-dessous.

Contribution

Positif Entier nreprésentant le nombre de niveaux zig-zag éclair à dessiner.

Exemple de sortie

n = 1

__
\ \
 \ \
  \ \
   \/

n = 2

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

n = 3

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

n = 4

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

. . . etc

Notes complémentaires

  • Vous pouvez écrire une fonction qui prend ncomme seul argument et affiche ou renvoie la chaîne.
  • Les espaces de fuite et les nouvelles lignes sont acceptables.
  • Aucun espace de début, sauf dans les cas appropriés pour le motif désigné.
  • Le code le plus court en octets gagne.
code-golf  ascii-art 
— CzarMatt
source
2
Combien de ces défis avons-nous vu jusqu'à présent?
— Flawr
@flawr Too many
— Beta Decay

Réponses:

19

Java, 201 196 189 186 182 octets

De toute évidence , pas le meilleur, mais il 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
source
23
Ah, Java, le langage dans lequel vous avez déjà perdu avant de commencer à taper le corps de votre mainméthode.
— David Richerby
2
Je pense parfois que le mainnombre d'octets ne devrait pas être pris en compte, et que quelques langues comportant des mots clés explicites devraient peut-être être autorisées à utiliser des macros. Alors ce serait intéressant
— Alec Teal
@AlecTeal Totalement d'accord, certaines questions précisent qu'elles ne requièrent que des extraits fonctionnels, mais que la plupart ne le font pas.
— David Mulder
6
Vous pouvez écrire une fonction qui prend n comme seul argument et affiche ou renvoie la chaîne. Alors, vous devriez probablement faire ça;)
— Geobits
Il peut être en retard de 6 mois, mais codegolf.stackexchange.com/a/64713/42736 ou l'utilisation d'une fonction le raccourcit.
— J Atkin
10

CJam, 41 octets

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

Je peux probablement extraire quelques octets de plus, mais voici une compression. J'ai choisi une base qui ne mènerait pas à des non imprimables.

Essayez-le en ligne .

L'éclair est divisé en top + middle * (input-1) + bottom, où top, middle, bottom(comprimé en utilisant la conversion de la base) sont

__
\. 

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

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

(Les espaces sont marqués d'un .s)

40 octets

Merci à Optimizer

"¹Ñ³Û- + ÎDx ^ áÐ" 254b6b "
_ \ 0 / "f =) / ~ ri (* \
— Sp3000
source
40
— Optimiseur
merci pour l'explication avec top + middle * (input-1) + bottom, cela m'a rappelé que powershell pourrait multiplier les chaînes: P
— Nacht - Réintégrer Monica
8

JavaScript ( ES6 ) 76

En utilisant la chaîne de modèle, les 3 nouvelles lignes sont significatives et comptées.

Tester l'exécution de l'extrait de code (Firefox uniquement)

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>
Développer l'extrait

— edc65
source
7

PowerShell, 72 63 octets

Windows stupide et votre \ r \ n ... Cela aurait pu être 67 59 octets!

%{$a="\ \
";"__
$a"+" $a`__$a\  __\
"*($_-1)+" $a  $a   \/"}
— Nacht - Rétablir Monica
source
Pour le code golf, je pense que \ r \ n compte toujours comme \ n, car il fait la même chose
— MilkyWay90
6

PHP - 84 79 78 octets

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

Affichez la source des résultats ou intégrez-la <pre />pour vérifier les résultats. Les nouvelles lignes sont obligatoires dans le code.
Le -1 pourrait être déplacé vers le define, mais j'ai considéré cela comme une triche.

1ère amélioration: remplacer \npar de nouvelles lignes réelles
2ème: Depuis que je peux définir une var, j'ai utilisé un CONTANT, le coffre-fort $. + un espace inutile dans str_repeat
3rd: Suppression accidentelle du -1, mais sauvegarde d'un octet en utilisant <?=au lieu de echo.

— Martijn
source
6

Pyth, 60 54 octets (Merci @isaacg)

Mon premier essai sur Pyth, probablement très mauvais.

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

Vérifiez ici .

— JNV
source
Bienvenue sur Pyth! Soit dit en passant, Pyth autorise les nouvelles lignes littérales dans ses chaînes, ce qui correspond à un caractère plus court que \n. En outre, le premier \\ programme pourrait être juste un \ .
— isaacg
@isaacg Merci.
— JNV
4

Brainfuck, 164 octets

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

Avec des commentaires:

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, comment cette réponse de Brainfuck bat Java et C #?

— Hand-E-Food
source
Woah, beau golf, surtout en BF!
— MilkyWay90
4

> <> (Poisson), 409 octets

Run by fish.py bolt.fish --value noù bolt.fishest le nom du programme et ncorrespond à votre entrée entière positive.

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

Ce n'est pas court, mais ça a l'air cool. J'essayais de faire en sorte que cela ressemble à un coup de foudre. En outre, il se trompe toujours à la fin.

— Capitaine homme
source
3

Perl, 69 + 1

69 caractères, plus 1 pour le -ncommutateur de ligne de commande pour extraire une entrée de stdin.

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

Exemple d'utilisation:

perl -ne '$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"' <<<"2"
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
— ossifrage délirant
source
1
Quelques améliorations possibles: perl -pe'$_="__\ns s"."__s\\ __\\\n s"x--$_." s \\/";s!s!\\ \\\n!g'. \nPeut également être remplacé par un saut de ligne littéral pour 3 autres caractères sauvegardés.
— nutki
3

Javascript (ES6), 86

Je ne vais pas gagner, mais j'adore la solution à 1 ligne et je déteste les barres obliques.

f=n=>atob("X18KXCBc"+"CiBcIFwKX19cIFwKXCAgX19c".repeat(n-1)+"CiBcIFwKICBcIFwKICAgXC8")
— Michael M.
source
Cool! Qu'est-ce qu'il fait?
— RPAP
1
@rpax J'ai utilisé l'encodage en base64 pour éviter les \\ et \ n. Consultez la atob documentation
— Michael M.
3

C, 101 octets

Ma mise en oeuvre pas si originale en c

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

C #, 221 octets

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

Ce n'est pas la meilleure, ni la plus petite réponse, mais je me suis dit que j'essaierais. La réponse de Fsacer est beaucoup plus courte et je pense que vous devriez vérifier. J'ai juste décidé de faire cela comme une méthode alternative vraiment.

— Communauté
source
1
Hey, ici je l'ai facilement laissé tomber à 182B. Code: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
Sympa, et juste curieux, mais pourquoi avez-vous changé le type de e de int en var? Il reste encore 3 personnages: P
Aucune raison, peut-être parce que j'adore le mot-clé var :)
— fsacer
3

C #, 166 octets

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: amélioration du résultat de 186B à 173B
EDIT 2: sauvegarde de 1B en utilisant à la PadLeftplace dePadRight
EDIT 3: sauvegarde de 8B en supprimant PadLeftle second paramètre et en utilisant des chaînes de caractères littérales

— fsacer
source
Sympa ... Vous pouvez vous en passer publicau début, et au lieu d’utiliser un tableau de caractères, vous pouvez utiliser String.PadRight(int, char), ce qui est plus court et vous permettra d’utiliser un caractère ascii qui n’a pas besoin d’être échappé.
— VisualMelon
Quelques ajustements: * déposez le deuxième paramètre à PadLeft (); c'est implicite (-4) * changez verbalement 2 des chaînes (l'OP dit que les nouvelles lignes sont correctes, et nous avons seulement besoin de \ n, pas de \ n complet, mais -4) Résultat final: class I {static void Main ( string [] a) {System.Console.Write (("__ \ na a" + "". PadLeft (int.Parse (a [0]) - 1). Remplacez ("", @ "__ a \ __ \ a ") +" a \\ / "). Remplacez (" a ", @" \ \ "));}} [Je ne peux pas afficher de nouvelles lignes dans les commentaires, mais vous pouvez modifier la réponse d'origine!]
— Sellotape
Bons conseils, il était difficile de formater textuellement dans l'ordre :)
— fsacer
3

Awk, 101 + 8 octets

101 caractères, plus 8 pour -v n=$1obtenir un entier du shell.

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

Nouveau sur ce site SE, ne sait pas si ces paramètres doivent compter.

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

Exemple d'utilisation:

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
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
— simplement croisement
source
Voici le consensus sur le comptage des indicateurs de ligne de commande. Donc, je pense que vous avez bien fait les choses.
— Martin Ender
Formulons cela comme « calculé ce droit», car certainement pas bien fait . Si l'affectation de variable est placée après le code, la -v pièce n'est pas nécessaire . Sans mentionner que toute l'idée de variable est inutile, tout comme le ENDbloc séparé . 89 personnages: {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'))

C'est mon premier code golf

@ (^ _ ^) @

Testez ici

— Pwed
source
C'est Python 3? Est-ce que input () fonctionnera pour les entiers?
— Renae Lider
2

C, 119 108 octets

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

Première tentative, 150 octets

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

mainaccepte un argument int, alors lancez comme ceci: ./lightning . . .à passer 4comme argument.

— aragaer
source
2

Python 3, 126 118 117 octets

Juste quelque chose pour nous lancer.

n=int(input())
p=print
p('__\n\\ \\')
for i in[0]*~-n:p(r''' \ \
__\ \
\  __\
''',end='')
p(r''' \ \
  \ \
   \/
''')
— Le numéro un
source
Si vous n'avez pas besoin de la variable de boucle, vous pouvez effectuer une itération [0]*(n-1)pour obtenir des n-1itérations. Vous pouvez également écrire en (n-1)tant que ~-n.
— randomra
Vous pouvez enregistrer un octet en changeant i in [0]à i in[0].
— mbomb007
Bienvenue! Une impression en ligne unique dans la boucle est également plus courte: for i in[0]*~-n:p(' \\ \\\n__\\ \\\n\\ __\\').
— randomra
2

Python 2, 76 octets

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

Imprimez simplement les trois premières lignes, puis les trois n-1fois, puis les 2 dernières lignes. Tout en un.

Et voici un bon essai pour une alternative qui utilise (malheureusement) exactement le même nombre d'octets:

print('__\n| |'+'__|\  __\\\n |'*~-input()+'  |   \/').replace('|','\ \\\n')
— Matty
source
Avez-vous essayé d’utiliser la mise en forme% s pour la partie centrale?
— Sp3000
@ Sp3000 J'ai besoin d'accolades tout autour pour le faire fonctionner avec le *. Cela me donne 77 octets - ou ne l'aligne pas, mais cela coûte 79 octets. :(
— Matty
2

F #, 98 caractères, 105 octets

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

CJam 54 Chars

pas le plus court, mais depuis que j'ai commencé CJam aujourd'hui, je suis content de cela.

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

L'essayer

— TobiasR.
source
2

Pascal: 149 142 141 137 caractères

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

Après tout, la seule force de Pascal en matière de golf est que les antislashs sont incontournables…

— homme au travail
source
1
for n:=2 to n dofonctionne aussi.
— randomra
Merci, @randomra. Je pense que c'était il y a environ 18 ans, quand j'étais conscient de cette possibilité… Il est bon de s'en souvenir.
— Manatwork
2

Google Sheets, 60 octets

Fonction de feuille de travail anonyme qui prend des entrées de plage [A1]et des sorties dans la cellule appelante.

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

SpecBAS - 135 104 octets

L'apostrophe dans les instructions PRINT déplace le curseur sur une nouvelle ligne.

SpecBAS vous permet d’incorporer des caractères ASCII dans une chaîne via #n . Vous avez donc intégré des retours à la ligne (ASCII 13).

Construit une chaîne en utilisant des retours à la ligne et d'autres caractères, puis utilisé REP$pour la répéter le nombre de fois requis.

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

Version non-golfée

$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
source
Votre code peut encore être amélioré, il a été réduit à 121 octets. echo$l=PHP_EOL,"__$l";$g="\\ \\$l";for($i=0;$i<$argv[1];$i++){echo($i?"__$g\\ __\\$l":$g)," $g";}echo" $g",' \\/',$l;
— Octfx
En outre: retirez le $i=0; enlever les crochets pour la forboucle; incrémente le compteur dans la boucle ( echo($i++?"…).
— Blackhole
1

Java, 183 180 octets

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 octets

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

Retina , 46 octets

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

1
__r\  __\# r
r
\ \#

Prend l'entrée comme unaire.

Chaque ligne doit aller dans son propre fichier et #doit être changée en nouvelle ligne dans les fichiers. Cela n’est pas pratique, mais vous pouvez exécuter le code tel quel, en tant que fichier unique, avec l’ -sindicateur, en conservant les #marqueurs. #Si vous le souhaitez, vous pouvez modifier les caractères en nouvelles lignes dans la sortie pour en améliorer la lisibilité. Par exemple:

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

L'algorithme est très simple. Les paires de lignes (paires regex - substitute) effectuent les étapes de substitution suivantes:

  • Entrée Surround avec le haut et le bas de l'éclair.
  • Soustrayez 1de l'entrée unaire.
  • Changer chaque chiffre unaire dans la partie centrale de la foudre.
  • Décompressez les \ \parties comprimées de l'éclair pour obtenir le résultat souhaité.
— randomra
source
Essayez-le en ligne! (y compris la conversion décimale), mais j’ai pu le faire en 45 octets: essayez-le en ligne! (comprend la conversion décimale).
— Neil
1

Powershell, 59 octets

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

Script de test:

$f = {

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

}

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

Sortie:

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

Explication:

Ce script est traditionnel top+ middle+ bottom. Une seule chose intelligente: la virgule précédant la chaîne du milieu oblige à répéter un élément de tableau plutôt qu'une chaîne. Par conséquent, chacun middleest affiché sur une nouvelle ligne.

— mazzy
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.