ASCII लाइटनिंग बोल्ट ड्रा करें

Question

परिचय

आंशिक रूप से इस StackOverflow प्रश्न से प्रेरित है , चलो एक ASCII लाइटिंग बोल्ट आकर्षित करते हैं।

एक प्रोग्राम लिखें जो nSTDIN या कमांड लाइन के माध्यम से एक सकारात्मक पूर्णांक लेता है और नीचे ASCII लाइटिंग बोल्ट आउटपुट करता है।

इनपुट

पॉजिटिव इंटेगर nआकर्षित करने के लिए बिजली के झिग-झग की संख्या का प्रतिनिधित्व करते हैं।

उदाहरण आउटपुट

n = 1

__
\ \
 \ \
  \ \
   \/

n = 2

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

n = 3

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

एन = 4

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

। । । आदि

---

अतिरिक्त नोट्स

• आप एक फ़ंक्शन लिख सकते हैं nजो एकमात्र तर्क के रूप में लेता है और स्ट्रिंग को प्रिंट या रिटर्न करता है।
• ट्रेलिंग स्पेस और नई लाइनें ठीक हैं।
• निर्दिष्ट पैटर्न के लिए उपयुक्त जगह के अलावा कोई अग्रणी स्थान नहीं।
• बाइट्स में सबसे छोटा कोड जीतता है।

Comments

हमने अब तक उन चुनौतियों में से कितनी को देखा है?

— 23

@ फ़्लावर बहुत 😯

— बीटा

Answer 1

जावा, 201 196 189 186 182 बाइट्स

जाहिर है नहीं सबसे अच्छा है, लेकिन यह है जावा में।

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

Comments

आह, जावा, वह भाषा जहाँ आप पहले ही खो चुके हैं इससे पहले कि आप अपने mainतरीके का शरीर टाइप करना शुरू करें ।

— डेविड रिचीर्बी

मुझे कभी-कभी लगता है कि mainबाइट काउंट की ओर नहीं गिनना चाहिए, और कुछ भाषाओं में जो वर्बोज़ कीवर्ड हैं, उन्हें शायद मैक्रोज़ की अनुमति दी जानी चाहिए। तब यह दिलचस्प होगा

— एलेक टीले

@AlecTeal पूरी तरह से सहमत हैं, कुछ प्रश्न वास्तव में निर्दिष्ट करते हैं कि उन्हें केवल कार्यात्मक स्निपेट की आवश्यकता होती है, लेकिन अधिकांश ऐसा नहीं करते हैं।

— डेविड मूलर

आप एक फ़ंक्शन लिख सकते हैं जो केवल तर्क और प्रिंट के रूप में n लेता है या स्ट्रिंग लौटाता है। तो, उम्म, आपको शायद ऐसा करना चाहिए;)

— भूत

यह 6 महीने देरी से हो सकता है, लेकिन codegolf.stackexchange.com/a/64713/42736 या किसी फ़ंक्शन का उपयोग करके इसे छोटा बना सकते हैं।

— J Atkin

Answer 2

CJam, 41 बाइट्स

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

मैं शायद कुछ और बाइट्स निचोड़ सकता हूं, लेकिन यहां कुछ संपीड़न है। मैंने एक आधार चुना, जिससे कोई अनहोनी न हो।

इसे ऑनलाइन आज़माएं ।

बिजली बोल्ट में विभाजित है top + middle * (input-1) + bottom, जहां top, middle, bottom(आधार रूपांतरण का उपयोग संकुचित) कर रहे हैं

__
\. 

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

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

(रिक्त स्थान .एस के साथ चिह्नित हैं )

40 बाइट्स

ऑप्टिमाइज़र को धन्यवाद

"¹Ñ³Û- + IDX ^ विज्ञापन" 254b6b "
_ \ 0 / "f =) / ~ री (* \ _

Comments

40

— अनुकूलक

इस स्पष्टीकरण के लिए धन्यवाद top + middle * (input-1) + bottom, इसने मुझे याद दिलाया कि शक्तियाँ कई गुना बढ़ा सकती हैं: P

— Nacht - Monica

Answer 3

जावास्क्रिप्ट ( ईएस 6 ) 76

टेम्पलेट स्ट्रिंग का उपयोग करते हुए, 3 नईलाइन्स महत्वपूर्ण और गिनी जाती हैं।

स्निपेट (केवल फ़ायरफ़ॉक्स) चलाने वाला टेस्ट

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>

Answer 4

पॉवरशेल, 72 63 बाइट्स

स्टुपिड विंडोज और आपका \ n \ n ... यह 67 59 बाइट्स हो सकता है !

%{$a="\ \
";"__
$a"+" $a`__$a\  __\
"*($_-1)+" $a  $a   \/"}

Comments

कोड गोल्फ के लिए, मुझे लगता है कि \ r \ n अभी भी \ n के रूप में गिना जाता है, क्योंकि यह एक ही काम करता है

— MilkyWay90

Answer 5

PHP - 84 79 78 बाइट्स

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

परिणाम की <pre />जाँच करें या परिणाम की जाँच करने के लिए लपेटें । कोड में newlines आवश्यक हैं।
-1 को स्थानांतरित किया जा सकता है define, लेकिन मैंने माना कि एक धोखा।

पहला सुधार: \nवास्तविक नई
सूचियों के साथ बदलें 2: चूंकि मैं एक var को परिभाषित कर सकता हूं, मैंने एक CONTANT का उपयोग किया, इसे सुरक्षित करता है $। + str_repeat
3 में एक अनावश्यक स्थान : गलती से -1 को हटा दिया गया, लेकिन <?=प्रतिध्वनि के बजाय का उपयोग करके एक बाइट को बचाया ।

Answer 6

पायथ, 60 54 बाइट्स (साभार @isaacg)

पायथ में मेरा पहला प्रयास, शायद बहुत बुरा है।

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

इसे यहाँ सत्यापित करें ।

Comments

Pyth में आपका स्वागत है! वैसे, पाइथ अपने तार में शाब्दिक नएपन की अनुमति देता है, जो कि 1 वर्ण से कम होगा \n। इसके अलावा, \\ कार्यक्रम में पहला सिर्फ एक हो सकता है \ ।

— इसहाक

@isaacg धन्यवाद

— JNV

Answer 7

सीजेएम, 50 बाइट्स

"__
\ \
"q~(" \ \
__\ \
\  __\
"*" \ \
"_S\"   \/"

इसे यहाँ आज़माएँ

Answer 8

ब्रेनफक, 164 बाइट्स

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

टिप्पणियों के साथ:

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

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

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

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

ठीक है, यह ब्रेनफॉक जावा और सी # की पिटाई का जवाब कैसे देता है?

Comments

वाह, अच्छी गोल्फिंग, विशेष रूप से BF में!

— MilkyWay90

Answer 9

> <> (मछली), 409 बाइट्स

प्रोग्राम नाम fish.py bolt.fish --value nकहां bolt.fishहै और nआपके पॉजिटिव पूर्णांक इनपुट के द्वारा रन करें।

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

यह छोटा नहीं है, लेकिन यह अच्छा लग रहा है। मेरी कोशिश यह थी कि इसे बिजली की हड़ताल की तरह बनाने की कोशिश की जाए। इसके अलावा, यह हमेशा पूरा होने पर त्रुटियां करता है।

Answer 10

पर्ल, 69 + 1

69 अक्षर, -nकमांड लाइन स्विच के लिए प्लस 1 स्टड से इनपुट लाने के लिए।

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

उपयोग उदाहरण:

perl -ne '$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"' <<<"2"
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

Comments

कुछ सुधार संभव perl -pe'$_="__\ns s"."__s\\ __\\\n s"x--$_." s \\/";s!s!\\ \\\n!g':। इसके अलावा \nएक और 3 चरित्र बचाया के लिए एक शाब्दिक लाइन ब्रेक के साथ बदला जा सकता है।

— नटकी

Answer 11

जावास्क्रिप्ट (ईएस 6), 86

जीतने वाला नहीं है, लेकिन मुझे 1-लाइन समाधान पसंद है और मुझे स्लैश से नफरत है।

f=n=>atob("X18KXCBc"+"CiBcIFwKX19cIFwKXCAgX19c".repeat(n-1)+"CiBcIFwKICBcIFwKICAgXC8")

Comments

ठंडा! यह क्या कर रहा है?

— rpax

@rpax मैंने \\ और \ n से बचने के लिए बेस 64 एनकोडिंग का उपयोग किया। atob प्रलेखन

— माइकल एम।

Answer 12

सी, 101 बाइट्स

सी में मेरा मूल कार्यान्वयन नहीं है

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

Answer 13

सी #, 221 बाइट्स

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

यह सबसे अच्छा या सबसे छोटा जवाब नहीं है, लेकिन मुझे लगा कि मैं इसे आजमाऊंगा। Fsacer का उत्तर बहुत छोटा है और मुझे लगता है कि आपको इसकी जाँच करनी चाहिए। मैंने अभी-अभी इसे वैकल्पिक विधि के रूप में करने का फैसला किया है।

Comments

अरे, यहाँ मैंने इसे आसानी से 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

अच्छा है, और सिर्फ जिज्ञासु, लेकिन आपने ई के प्रकार को int से var में क्यों बदल दिया? यह अभी भी 3 अक्षर है: P

कोई कारण नहीं, हो सकता है क्योंकि मुझे var कीवर्ड पसंद है :)

— fsacer

Answer 14

सी #, 166 बाइट्स

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: 186B से 173B
EDIT 2 के परिणाम में सुधार : EDIT 3 केPadLeft बजाय 1B का उपयोग करके बचाया PadRight
: 8B को PadLeftदूसरे पैरामीटर को छोड़ कर और शब्दशः स्ट्रिंग शाब्दिक का उपयोग करके सहेजा गया

Comments

नाइस ... आप publicशुरुआत में दूर कर सकते हैं , और एक चार सरणी का उपयोग करने के बजाय, आप उपयोग कर सकते हैं String.PadRight(int, char), जो छोटा है और आपको एसेसी चार का उपयोग करने देगा जो भागने की आवश्यकता नहीं है।

— विजुअलमेल

कुछ ट्विक्स: * PadLeft () के लिए दूसरा पैरामीटर ड्रॉप करें; यह निहित है (-4) * स्ट्रिंग के 2 को शब्दशः में बदल दें (ओपी कहते हैं कि नई लाइनें ठीक हैं, और हमें केवल \ n की आवश्यकता है, पूर्ण \ r \ n नहीं, इसलिए -4) अंतिम परिणाम: वर्ग I {स्टेटिक शून्य मेन ( string [] a) {System.Console.Write (("__ \ na a" + "। PadLeft (int.Parse (a [0]) - 1) .Replace (" ", @" ___ a \ _ \ _ a) ") +" a \\ / ")। प्रतिस्थापित करें (" a "," "\" ");}}} [मैं टिप्पणियों में नई सूची प्रदर्शित नहीं कर सकता, लेकिन आप मूल उत्तर को संपादित कर सकते हैं!]

— sellotape

अच्छा सुझाव, यह क्रम में शब्दशः तैयार करने के लिए कठिन था :)

— fsacer

Answer 15

अवाक, 101 + 8 बाइट्स

101 वर्ण, प्लस 8 -v n=$1शेल से पूर्णांक प्राप्त करने के लिए।

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

इस एसई साइट पर नया, स्पष्ट नहीं है कि क्या उन मापदंडों को गिनना चाहिए।

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

उपयोग उदाहरण:

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
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

Comments

यहां कमांड-लाइन के झंडे गिनने पर सहमति बनी है। इसलिए मुझे लगता है कि आपने सही किया है।

— मार्टिन एंडर

चलो इसे " सही गणना " के रूप में तैयार करते हैं , क्योंकि निश्चित रूप से सही नहीं किया गया है। यदि चर असाइनमेंट कोड के बाद रखा जाता है, तो -v भाग की कोई आवश्यकता नहीं है । इस बात का उल्लेख नहीं है कि अलग-अलग ENDब्लॉक की तरह, संपूर्ण चर विचार अनावश्यक है । 89 अक्षर: {l="\\ \\";print"__\n"l"\n "l;for(;--$1;)print"__"l"\n\\ __\\\n "l;print" "l"\n \\/"} pastebin.com/NCznF9kH

— मैनटवर्क

Answer 16

पायथन 97 82 78 चार्च:

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

यह मेरा पहला कोड गोल्फ है

@ (^ _ ^) @

यहाँ परीक्षण करें

Comments

यह अजगर 3 है? क्या वह इनपुट () पूर्णांक के लिए काम करेगा?

— रेने लिडर

Answer 17

सी, 119 108 बाइट्स

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

पहला प्रयास, 150 बाइट्स

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

mainएक अंतर तर्क को स्वीकार कर रहा है, इसलिए इस तरह से चलाएँ: तर्क के रूप में ./lightning . . .पारित करने के लिए 4।

Answer 18

पायथन 3, 126 118 117 बाइट्स

हमें शुरू करने के लिए बस कुछ चाहिए।

n=int(input())
p=print
p('__\n\\ \\')
for i in[0]*~-n:p(r''' \ \
__\ \
\  __\
''',end='')
p(r''' \ \
  \ \
   \/
''')

Comments

यदि आपको लूप वेरिएबल की आवश्यकता नहीं है, तो आप पुनरावृत्तियों [0]*(n-1)को प्राप्त करने के लिए गर्त को पुन: व्यवस्थित कर सकते हैं n-1। तुम भी लिख सकते हैं (n-1)के रूप में ~-n।

— रैंडम

आप को बदलने के द्वारा एक बाइट बचा सकते हैं i in [0]करने के लिए i in[0]।

— mbomb007

स्वागत हे! लूप में एक सिंगल लाइन प्रिंट भी छोटा होता है for i in[0]*~-n:p(' \\ \\\n__\\ \\\n\\ __\\'):।

— रैंडम

Answer 19

पायथन 2, 76 बाइट्स

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

बस पहले तीन लाइनों को प्रिंट करें, फिर अगली तीन लाइनों को n-1प्रिंट करें, और फिर अंतिम 2 लाइनों को प्रिंट करें। सभी एक बार में।

और यहाँ एक विकल्प पर एक अच्छी कोशिश है कि (दुर्भाग्य से) बिल्कुल उसी बाइट्स का उपयोग करता है:

print('__\n| |'+'__|\  __\\\n |'*~-input()+'  |   \/').replace('|','\ \\\n')

Comments

क्या आपने मध्य भाग के लिए% s स्वरूपण का उपयोग करने की कोशिश की है?

— Sp3000

@ Sp3000 मुझे इसके साथ काम करने के लिए ब्रेसिज़ की आवश्यकता है *, जो मुझे 77 बाइट्स देता है - या इसे इनलाइन नहीं करता है, लेकिन इसकी लागत 79 बाइट्स है। :(

— मत्ती

Answer 20

एफ #, 98 वर्ण, 105 बाइट्स

let l n=(@"__♪◙\z"+String.replicate(n-1)@" \z__\z\  __\♪◙"+ @" \z  \z   \/").Replace("z"," \\\n")

Answer 21

CJam 54 शुल्क

सबसे छोटा नहीं है, लेकिन जब से मैंने आज सीजाम शुरू किया है, इससे खुश हूं।

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

कोशिश करो

Answer 22

पास्कल: 149 142 141 137 अक्षर

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

आखिरकार, पास्कल की एकमात्र गोल्फ ताकत यह है कि बैकस्लैश को भागने की आवश्यकता नहीं है ...

Comments

for n:=2 to n doभी काम करता है।

— 23

साभार, @randomra मुझे लगता है कि ~ 18 साल पहले जब मुझे इस संभावना के बारे में पता था ... इसे याद करके अच्छा लगा।

— मैनटवर्क

Answer 23

Google शीट, 60 बाइट्स

बेनामी वर्कशीट फ़ंक्शन जो इनपुट से रेंज [A1]और आउटपुट को कॉलिंग सेल तक ले जाता है।

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

Answer 24

पर्ल 5 , 58 + 1 ( -n) = 59 बाइट्स

say'__
\ \
 \ \ 
'.'__\ \
\  __\
 \ \
'x--$_.'  \ \
   \/'

इसे ऑनलाइन आज़माएं!

Answer 25

SpecBAS - 135 104 बाइट्स

PRINT स्टेटमेंट में एपोस्ट्रोफ कर्सर को एक नई लाइन में ले जाता है।

SpecBAS आपको एक मार्ग के माध्यम से ASCII वर्णों को एक स्ट्रिंग में शामिल करने देता है #n, इसलिए कुछ गाड़ी रिटर्न (ASCII 13) में बनाया गया है।

कैरिज रिटर्न और अन्य पात्रों का उपयोग करके एक स्ट्रिंग का निर्माण किया REP$गया , फिर इसे आवश्यक संख्या को दोहराने के लिए उपयोग किया गया।

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

Answer 26

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";

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;

Comments

आपके कोड में और सुधार किया जा सकता है, इसे 121 बाइट्स तक घटा दिया गया है। echo$l=PHP_EOL,"__$l";$g="\\ \\$l";for($i=0;$i<$argv[1];$i++){echo($i?"__$g\\ __\\$l":$g)," $g";}echo" $g",' \\/',$l;

— Octfx

इसके अलावा: हटा $i=0; forलूप के लिए कोष्ठक हटा दें ; लूप के अंदर काउंटर बढ़ाएँ ( echo($i++?"…)।

— ब्लैकहोल

Answer 27

जावा, 183 180 बाइट्स

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

लुआ, 110 बाइट्स

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

Answer 28

रेटिना , 46 बाइट्स

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

1
__r\  __\# r
r
\ \#   

इनपुट को एकरी के रूप में लेता है।

प्रत्येक पंक्ति को अपनी स्वयं की फ़ाइल पर #जाना चाहिए और उसे फ़ाइलों में नई रेखा में बदलना चाहिए। यह अव्यवहारिक है, लेकिन आप कोड को चिह्न के रूप में -sध्वज के साथ, एक फ़ाइल के रूप में चला सकते हैं #। #यदि आप चाहें, तो आप पठनीयता के लिए आउटपुट में newlines को बदल सकते हैं । उदाहरण के लिए:

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

एल्गोरिथ्म बहुत सरल है। लाइनों के जोड़े (regex - स्थानापन्न जोड़े) निम्नलिखित प्रतिस्थापन चरण करते हैं:

• बिजली के ऊपर और नीचे के साथ चारों ओर इनपुट।
• 1यूनिक इनपुट से घटाएं ।
• हर एक अंक को बिजली के मध्य भाग में बदलें।
• \ \वांछित उत्पादन प्राप्त करने के लिए बिजली के संपीड़ित भागों को डीकंप्रेस करें ।

Comments

इसे ऑनलाइन आज़माएं! (दशमलव रूपांतरण शामिल है), लेकिन मैं इसे 45 बाइट्स में करने में सक्षम था: इसे ऑनलाइन आज़माएं! (दशमलव रूपांतरण शामिल है)।

— नील

Answer 29

पॉवरशेल, 59 बाइट्स

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

टेस्ट स्क्रिप्ट:

$f = {

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

}

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

आउटपुट:

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

स्पष्टीकरण:

यह स्क्रिप्ट पारंपरिक है top+ middle+ bottom। केवल एक स्मार्ट चीज है: एक स्ट्रिंग तत्व के बजाय एक स्ट्रिंग तत्व को दोहराने के लिए मध्य स्ट्रिंग बल से पहले अल्पविराम। इसलिए, प्रत्येक middleको एक नई लाइन पर प्रदर्शित किया जाता है।