Ngày quốc khánh đặc biệt (Mỹ) thách thức chủ đề dành cho bạn hôm nay. Bạn phải viết một chương trình in đại diện nghệ thuật này của Cờ Mỹ.

0
|---------------------------------------------------------
| *   *   *   *   *   * #################################|
|   *   *   *   *   *                                    |
| *   *   *   *   *   *                                  |
|   *   *   *   *   *   #################################|
| *   *   *   *   *   *                                  |
|   *   *   *   *   *                                    |
| *   *   *   *   *   * #################################|
|   *   *   *   *   *                                    |
| *   *   *   *   *   *                                  |
|########################################################|
|                                                        |
|                                                        |
|########################################################|
|                                                        |
|                                                        |
|########################################################|
|                                                        |
|                                                        |
|########################################################|
|---------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

Không gian lưu trữ trên mỗi dòng, cũng như một dòng mới, được phép.

Lưu ý rằng đây không hoàn toàn giống với cờ, nhưng đó là cách gần nhất tôi có thể nhận được với ASCII.

Như thường lệ, đây là môn đánh gôn để áp dụng sơ hở tiêu chuẩn và câu trả lời ngắn nhất tính theo byte!

CJam, 184 120 109 101 76 74 69 67 64 62 58 byte

0'-57*"  #"56f*'|f+7*2>" *  "50*22/W<Sf+..e&~J$]N'|+a37*.+

Hãy thử trực tuyến trong trình thông dịch CJam .

Ý kiến

Phần thú vị nhất của lá cờ là các ngôi sao và sọc họa tiết.

Nếu chúng ta lặp lại hai dấu cách và một số ký hiệu 56 lần và nối một thanh dọc cho mỗi thanh, chúng ta sẽ nhận được

                                                         |
                                                         |
#########################################################|

Lặp lại mẫu này 7 lần và loại bỏ hai dòng đầu tiên, chúng ta thu được các sọc:

#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|

Bây giờ, nếu chúng ta lặp lại chuỗi " * "50 lần và chia kết quả thành các đoạn có độ dài 22, chúng ta sẽ có được các ngôi sao:

 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   

Khoảng trắng là một chút, nhưng chúng ta có thể khắc phục điều đó bằng cách loại bỏ đoạn cuối cùng và nối thêm một khoảng trống cho các phần còn lại.

Bây giờ, nếu chúng ta xếp chồng các sọc và ngôi sao, chúng ta sẽ có

 *   *   *   *   *   * #################################|
   *   *   *   *   *                                    |
 *   *   *   *   *   *                                  |
   *   *   *   *   *   #################################|
 *   *   *   *   *   *                                  |
   *   *   *   *   *                                    |
 *   *   *   *   *   * #################################|
   *   *   *   *   *                                    |
 *   *   *   *   *   *                                  |
########################################################|
                                                        |
                                                        |
########################################################|
                                                        |
                                                        |
########################################################|
                                                        |
                                                        |
########################################################|

Tất cả những gì còn lại phải làm là thêm hai dòng 57 dấu gạch ngang, thêm một cột gồm 37 thanh dọc và đặt anh đào lên trên cùng.

Mã

0         e# Push a zero.
'-57*     e# Push a string of 57 dashes.
"  #"56f* e# Repeat each character in the string 56 times.
'|f+      e# Append a vertical bar to each resulting string.
7*        e# Repeat the resulting array of strings 7 times.
2>        e# Discard the first two strings.
" *  "50* e# Repeat the string 50 times.
22/       e# Split the result into chunks of length 22.
W<        e# Discard the last, partial chunk.
Sf*       e# Append a space to each chunk.
..e&      e# Twofold vectorized logical AND.
          e# Since all characters in the strings are truthy, this always selects
          e# the second character, painting the stars over the stripes.
~         e# Dump all resulting strings on the stack.
J$        e# Copy the string of dashes.

]         e# Wrap the entire stack in an array.
N'|+a37*  e# Repeat ["\n|"] 37 times.
.+        e# Perform vectorized concatenation.

Python 2, 113 byte

for i in range(38):print i and"|"+["-"*57,(" *  "*7)[i%2*2:][:(i<11)*23].ljust(56,"  #"[i%3])+"|"][1<i<21]*(i<22)

Cắt chuỗi và kiểm tra modulo galore.

Brainf ** k, 3355 3113 1598 1178 782 byte

Ngôn ngữ này là gì?

Đây là phiên bản tối ưu hóa tay gồm 28 vòng. Tôi nghĩ rằng tôi đã thực hiện điều này trong chừng mực nó sẽ đi.

Đây là hoạt động tại ideone.com :

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

Cái này hoạt động ra sao?

 1: +++[>++++<-]>[>+++>+++>+++>++++++++++>+>++++<<<<<<-]>++++++>---->->>>.<--.
 2: <++++.>>---.>+++++++[<........>-]<<.
 3: <.<<<<+++++[>>.<.>..<<-]>>.<.>.<<++++[>>>........<<<-]>>>.>.>.
 4: <.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
 5: <.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
 6: <.<<...<<+++++[>.>...<<-]++++[>>>........<<<-]>>>.>.>.
 7: <.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
 8: <.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
 9: <.<<<<+++++[>>.<.>..<<-]>>.<.>.<<++++[>>>........<<<-]>>>.>.>.
10: <.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
11: <.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
12: >>>+++[<<<
13: <.>>>+++++++[<<<<........>>>>-]<<<.>.
14: >>++[<<
15: <.<<<<+++++++[>>........<<-]>>>>.>.
16: >>-]<<
17: >>>-]<<<
18: <.>>>+++++++[<<<<........>>>>-]<<<.>.
19: <.>>.>+++++++[<........>-]<<.
20: >>++++++++[<<<.>.<.>.>>-]

Chương trình này sử dụng 10 vị trí bộ nhớ:

0: loop counter #1
1: loop counter #2
2: "*"  ASCII 42
3: spc  ASCII 32
4: "#"  ASCII 35
5: "|"  ASCII 124
6: "\n" ASCII 10
7: "0"  ASCII 48, "-"  ASCII 45
8: loop counter #3
9: loop counter #4

Dòng 1

• Dòng này thiết lập các ký tự ASCII trong các thanh ghi 2 đến 7 (hầu hết). Một số điều chỉnh được thực hiện sau.
• Mã này trước tiên đặt 3 vào thanh ghi 0, và sau đó lặp 3 lần tăng thanh ghi 1 bốn lần mỗi vòng lặp : +++[>++++<-]. Sau đó, kết quả cuối cùng là thanh ghi 0 là 0 và thanh ghi 1 là 12.
• Số 12 được sử dụng làm bộ đếm vòng lặp cho vòng lặp tiếp theo. Trong 12 lần qua vòng lặp, các thanh ghi 2, 3 và 4 được tăng 3 lần, thanh ghi 5 được tăng 10 lần, thanh ghi 6 được tăng 1 lần và đăng ký 7 được tăng 4 lần. Ở cuối vòng lặp này, chúng chứa: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Sau khi thanh ghi vòng 2 tăng 6 lần, thanh ghi 3 bị giảm 4 lần và thanh ghi 4 bị giảm một lần. Tại thời điểm này, các giá trị là: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Tất cả trừ các thanh ghi 5 và 6 đều chứa các giá trị ASCII ban đầu của chúng.
• Đăng ký tiếp theo 7 là đầu ra, "0"ở đầu cờ!
• Thanh ghi tiếp theo 6 được giảm hai lần xuống 10 (dòng mới ASCII) và đầu ra. Thực hiện với dòng đầu tiên của cờ!

Dòng 2

• Đầu tiên, nó tăng đăng ký 5 lên 4, làm cho nó "|"(ASCII 124) và xuất ra nó.
• Sau đó, nó giảm số đăng ký 7 bằng cách thay đổi nó từ "0"(ASCII 48) thành "-"(ASCII 45) và xuất ra nó.
• Tiếp theo, nó đặt 7 vào bộ đếm vòng 3 (đăng ký 8) và lặp lại 7 lần, viết ra 8 dấu gạch ngang mỗi lần với tổng số 7 * 8 = 56 dấu gạch ngang.
• Cuối cùng, nó kết thúc bằng cách xuất ra một dòng mới.

Dòng 3

• Dòng này chứa hai vòng.
• Vòng lặp đầu tiên viết " * "5 lần.
• Sau đó " * "được viết
• Vòng lặp thứ hai lặp 4 lần viết 8 "#"với tổng số 32.
• Sau đó "#", "|"và "\n"được viết.

Dòng 4 - 11

• Những dòng này sử dụng kỹ thuật tương tự như dòng 3 để viết ra các ngôi sao và sọc của lá cờ.

Dòng 12

• Dòng này bắt đầu một vòng lặp chạy 3 lần.
• Vòng lặp kết thúc ở dòng 17.

Dòng 13

• Viết một dải đi ngang qua lá cờ.
• Sử dụng một vòng lặp chạy 7 lần viết "#"8 lần mỗi lần thông qua vòng lặp.

Dòng 14

• Bắt đầu một vòng lặp chạy 2 lần.

Dòng 15

• Viết một dải đi ngang qua lá cờ.
• Sử dụng một vòng lặp chạy 7 lần viết " "8 lần mỗi lần thông qua vòng lặp.

Dòng 16

• Kết thúc vòng lặp bên trong bắt đầu từ dòng 14.

Dòng 17

• Kết thúc vòng lặp bên ngoài bắt đầu từ dòng 13.

Dòng 18

• Vẽ sọc dưới cùng của cờ.

Dòng 19

• Vẽ đường viền dưới cùng của cờ.

Dòng 20

• Vẽ cột cờ.
• Vòng lặp 8 lần, viết "|"và dòng mới hai lần mỗi lần qua vòng lặp.

/// : 225 ký tự

/D/ddd//d/--------//H/hhh//h/########//S/sss//s/        //A/aaaaa//a/ *  //b/|HHh|
|SSs|
|SSs|
//p/|
|
|
|
/0
|DDd-
|A * Hh#|
|  A Ss |
|A * Ss |
|  A Hh#|
|A * Ss |
|  A Ss |
|A * Hh#|
|  A Ss |
|A * Ss |
bbb|HHh|
|DDd-
pppp

JavaScript ( ES6 ), 153 156

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

Kiểm tra chạy đoạn mã bên dưới (chỉ là EcmaScript 6, chỉ dành cho Firefox)

// TEST - Just for testing purpose,redefine console.log

console.log = (...x) => O.innerHTML += x+'\n'

// SOLUTION

o=[0];for(o[r=1]=o[21]='-'[R='repeat'](57);++r<21;o[r]=" *  "[R](7).substr(r%2*2,r<11&&23)+'  #'[r%3][R](r<11?33:56)+'|')o[37]='';console.log(o.join`
|`)

<pre id=O></pre>

Để yêu nước hơn nữa, đây là phiên bản EcmaScript 5

// TEST - Just for testing purpose,redfine console.log

console.log = function(x){ O.innerHTML += x+'\n' }

// SOLUTION - 175 bytes

for(o=(A=Array)(38),o[0]=0,r=2;r<21;r++)o[r]=A(8)[J='join'](" *  ").substr((r&1)*2,r<11?23:0)+A(r<11?34:57)[J]('  #'[r%3])+'|';
o[1]=o[r]=A(58)[J]('-'),console.log(o[J]('\n|'))

<pre id=O></pre>

Ruby, 104 102 byte

Sử dụng ý tưởng từ câu trả lời Ruby của ManAtWork với sự cho phép.

puts 0,s=?|+?-*57,(0..18).map{|i|?|+("#  "[i%3]*(i>8?56:33)).rjust(56," *   *"[i%2*2,4])+?|},s,'|
'*16

Ruby, 127 121 112 byte

Thay đổi dấu ngoặc kép thành ?mảng được sử dụng thay vì có điều kiện cho màu sọc. được sử dụng có điều kiện thay vì công thức cho chiều dài sọc.

puts 0,s=?|+?-*57
19.times{|i|puts ?|+("#  "[i%3]*(i>8?56:33)).rjust(56,i%2>0?"   *":" *  ")+?|}
puts s,"|\n"*16

Mẹo ở đây là vẽ các sọc (cả đỏ / #và trắng / space) với độ dài chính xác, sau đó xác minh đúng, đệm bằng các ngôi sao. Ruby's rjustcho phép chúng ta chỉ định chuỗi đệm, xen kẽ giữa " * "và " *".

Phiên bản gốc, 127 byte

puts 0,s="|"+"-"*57
19.times{|i|puts("|"+((i%3>0?" ":"#")*((i+1)/10*23+33)).rjust(56,i%2>0?"   *":" *  ")+"|")}
puts s,"|\n"*16

SWI-Prolog, 275 byte

Trong một ngôn ngữ có nguồn gốc từ Pháp, đó là loại phù hợp

a:-put(48),nl,b,c(0).
b:-z,w(-,57).
c(I):-nl,I=36;J is I+1,(I=19,b,c(J);I>19,z,c(J);I>8,z,(I mod 3=:=0,w(#,56);tab(56)),z,c(J);z,(I mod 2=:=0,tab(1),w('*   ',5),put(42),tab(1);w('   *',5),tab(3)),(0=:=I mod 3,w(#,33);tab(33)),z,c(J)).
z:-put(124).
w(A,B):-writef('%r',[A,B]).

Xem kết quả tại đây

C, 235 211 208 205 203 198 197 186 byte

i;x(){for(puts("0");i<37;i++){char b[58]="";i<21?memset(b,i%20?i%3&1?35:32:45,56),i&&i<10?memcpy(b," *   *   *   *   *   *   "+(i%2?0:2),23):0,b[56]=i%20?124:45:0;printf("|%.57s\n",b);}}

chỉnh sửa: đã thêm một số đề xuất của Cool Guy và sử dụng?: để thay thế một số câu lệnh if.

chỉnh sửa: loại bỏ tràn \ 0 phòng ngừa và sử dụng bộ giới hạn độ dài chuỗi trong printf thay thế.

chỉnh sửa: làm lại cả hai điều kiện bộ nhớ.

chỉnh sửa: di chuyển đặt ("0") bên trong tiêu đề cho để loại bỏ dấu chấm phẩy của nó.

chỉnh sửa: tái cấu trúc nhẹ để có thêm 11 byte.