Giới thiệu

Lấy cảm hứng một phần từ câu hỏi StackOverflow này , chúng ta hãy vẽ Tia chớp ASCII.

Viết chương trình lấy Số nguyên dương nqua STDIN hoặc dòng lệnh và xuất ra Tia chớp ASCII bên dưới.

Đầu vào

Số nguyên dương nbiểu thị số lượng các tia sét ngoằn ngoèo cần vẽ.

Ví dụ đầu ra

n = 1

__
\ \
 \ \
  \ \
   \/

n = 2

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

n = 3

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

n = 4

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

. . . v.v.

Ghi chú bổ sung

• Bạn có thể viết một hàm lấy tham nsố duy nhất và in hoặc trả về chuỗi.
• Không gian lưu trữ và dòng mới là được.
• Không có không gian hàng đầu trừ khi thích hợp cho mẫu được chỉ định.
• Mã ngắn nhất trong byte thắng.

Java, 201 196 189 186 182 byte

Rõ ràng không phải là tốt nhất, nhưng nó là trong 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"));}}

CJam, 41 byte

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

Tôi có thể có thể vắt thêm một vài byte, nhưng đây là một số nén. Tôi đã chọn một cơ sở sẽ dẫn đến không có dấu vết.

Hãy thử trực tuyến .

Tia chớp được chia thành top + middle * (input-1) + bottom, nơi top, middle, bottom(nén sử dụng chuyển đổi cơ sở) là

__
\. 

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

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

(Dấu cách được đánh dấu bằng .s)

40 byte

Cảm ơn Trình tối ưu hóa

"¹Ñ³Û- + ÎDx ^ áĐ" 254b6b "
_ \ 0 / "f =) / ~ ri (* \

JavaScript ( ES6 ) 76

Sử dụng chuỗi mẫu, 3 dòng mới có ý nghĩa và được tính.

Kiểm tra chạy đoạn trích (chỉ dành cho 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>

PowerShell, 72 63 byte

Windows ngu ngốc và \ r \ n ... Cái này có thể là 67 59 byte!

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

PHP - 84 79 78 byte

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

Xem nguồn kết quả hoặc bọc <pre />để kiểm tra kết quả. Các dòng mới được yêu cầu trong mã.
-1 có thể được chuyển sang define, nhưng tôi coi đó là một mánh gian lận.

Cải tiến thứ 1: thay thế \nbằng các dòng mới thực tế
Thứ 2: Vì tôi có thể xác định một var, tôi đã sử dụng một NỘI DUNG, két sắt $. + một không gian không cần thiết trong str numpeat
3: Vô tình xóa -1, nhưng đã lưu một byte bằng cách sử dụng <?=thay vì echo.

Pyth, 60 54 byte (Cảm ơn @isaacg)

Nỗ lực đầu tiên của tôi tại Pyth, có lẽ rất tệ.

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

Xác nhận nó ở đây .

CJam, 50 byte

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

Hãy thử nó ở đây

Brainfuck, 164 byte

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

Với nhận xét:

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

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

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

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

Được rồi, làm thế nào câu trả lời Brainfuck này đánh bại Java và C #?

> <> (Cá), 409 byte

Chạy theo fish.py bolt.fish --value nđâu bolt.fishlà tên chương trình và nlà đầu vào số nguyên dương của bạn.

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

Nó không ngắn, nhưng nó trông rất tuyệt. Nỗ lực của tôi là cố gắng làm cho nó trông giống như một tia sét. Ngoài ra, nó luôn luôn lỗi khi hoàn thành.

Perl, 69 + 1

69 ký tự, cộng với 1 cho -nchuyển đổi dòng lệnh để tìm nạp đầu vào từ stdin.

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

Ví dụ sử dụng:

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

Javascript (ES6), 86

Không chiến thắng, nhưng tôi yêu giải pháp 1 dòng và tôi ghét những nhát chém.

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

C, 101 byte

Tôi không thực hiện ban đầu trong c

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

C #, 221 byte

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

Đây không phải là câu trả lời hay nhất, hay câu trả lời nhỏ nhất, nhưng tôi đoán tôi sẽ thử. Câu trả lời của Fsacer ngắn hơn nhiều và tôi nghĩ bạn nên kiểm tra nó. Tôi chỉ quyết định làm điều này giống như một phương pháp thay thế thực sự.

C #, 166 byte

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: đã cải thiện kết quả từ 186B lên 173B
EDIT 2: đã lưu 1B bằng cách sử dụng PadLeftthay vì PadRight
EDIT 3: đã lưu 8B bằng cách bỏ PadLefttham số thứ hai và sử dụng chuỗi ký tự nguyên văn

Awk, 101 + 8 byte

101 ký tự, cộng với 8 -v n=$1để lấy số nguyên từ shell.

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

Mới đối với trang SE này, chưa rõ liệu những thông số đó có được tính không.

Ung dung

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

Ví dụ sử dụng:

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

Python 97 82 78ar:

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

Đây là mã golf đầu tiên của tôi

@ (^ _ ^) @

Kiểm tra tại đây

C, 119 108 byte

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

Lần thử đầu tiên, 150 byte

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đang chấp nhận một đối số int, vì vậy hãy chạy như thế này: ./lightning . . .để chuyển 4thành đối số.

Python 3, 126 118 117 byte

Chỉ cần một cái gì đó để chúng ta bắt đầu với.

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

Python 2, 76 byte

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

Chỉ cần in ba dòng đầu tiên, sau đó in ba dòng tiếp theo n-1 , sau đó in 2 dòng cuối cùng. Tất cả trong một đi.

Và đây là một thử nghiệm tuyệt vời ở một giải pháp thay thế (không may) sử dụng chính xác cùng số byte:

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

F #, 98 ký tự, 105 byte

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

Chòi 54

không phải là ngắn nhất, nhưng kể từ khi tôi bắt đầu CJam ngày hôm nay, tôi hài lòng với nó.

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

Thử nó

Pascal: 149 142 141 137 ký tự

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

Rốt cuộc, điểm mạnh duy nhất của môn đánh gôn là Pash không cần phải thoát khỏi

Google Sheets, 60 byte

Hàm bảng tính ẩn danh nhận đầu vào từ phạm vi [A1]và đầu ra đến ô gọi.

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

Perl 5 , 58 + 1 ( -n) = 59 byte

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

Hãy thử trực tuyến!

SpecBAS - 135 104 byte

Dấu nháy đơn trong các câu lệnh PRINT di chuyển con trỏ đến một dòng mới.

SpecBAS cho phép bạn kết hợp các ký tự ASCII trong một chuỗi thông qua cách #n , do đó, đã được tích hợp trong một số lợi nhuận vận chuyển (ASCII 13).

Xây dựng một chuỗi lên bằng cách sử dụng trả về vận chuyển và các ký tự khác, sau đó được sử dụng REP$để lặp lại nó với số lần cần thiết.

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

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

Phiên bản 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;

Java, 183 180 byte

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 byte

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

Võng mạc , 46 byte

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

1
__r\  __\# r
r
\ \#   

Đưa đầu vào là unary.

Mỗi dòng nên đi đến tệp riêng của nó và #nên được thay đổi thành dòng mới trong các tệp. Điều này là không thực tế nhưng bạn có thể chạy mã như một tệp, với -scờ, giữ các #điểm đánh dấu. Bạn có thể thay đổi các #dòng mới thành đầu ra để dễ đọc nếu muốn. Ví dụ:

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

Thuật toán rất đơn giản. Các cặp dòng (regex - cặp thay thế) thực hiện các bước thay thế sau:

• Đầu vào xung quanh với đỉnh và đáy của sét.
• Trừ đi 1từ đầu vào unary.
• Thay đổi mọi chữ số unary thành phần giữa của sét.
• Giải nén \ \các phần nén của sét để có được đầu ra mong muốn.

Powershell, 59 byte

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

Kịch bản thử nghiệm:

$f = {

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

}

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

Đầu ra:

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

Giải trình:

Kịch bản này là truyền thống top+ middle+ bottom. Chỉ có một điều thông minh: dấu phẩy trước chuỗi giữa buộc lặp lại một phần tử mảng chứ không phải là chuỗi. Do đó, mỗi middleđược hiển thị trên một dòng mới.