Спеціальний День незалежності (США) тематичний виклик для вас сьогодні. Ви повинні написати програму, яка надрукує це художнє зображення американського прапора.

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

Додаткові пробіли на кожному рядку, а також одна кінцева нова лінія.

Зауважте, що це не зовсім так, як повинен виглядати прапор, але це найближче, що я міг би отримати з ASCII.

Як завжди, це код-гольф, тому застосовуються стандартні лазівки і найкоротша відповідь у байтових виграшів!

CJam, 184 120 109 101 76 74 69 67 64 62 58 байт

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

Спробуйте його в Інтернеті в інтерпретаторі CJam .

Ідея

Найцікавіша частина прапора - візерунок зірок і смуг.

Якщо ми повторимо два пробіли і знак числа 56 разів і додамо до кожного вертикальну смугу, отримаємо

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

Повторивши цей візерунок 7 разів і відкинувши перші два рядки, ми отримаємо смужки:

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

Тепер, якщо ми повторимо рядок " * "50 разів і розділимо результат на шматки довжиною 22, отримаємо зірки:

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

Пробіл трохи відключений, але ми можемо це виправити, усунувши останній шматок і додавши пробіл до решти.

Тепер, якщо ми накладаємо смужки та зірки, ми отримуємо

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

Залишилося лише додати два рядки з 57 тире, додати стовпчик з 37 вертикальних брусків і покласти вишню зверху.

Код

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 байт

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)

Нарізка рядків і модуль перевіряє багатство.

Brainf ** k, 3355 3113 1598 1178 782 байт

Що це за мова?

Ось оптимізована вручну версія з 28 петлями. Я думаю, я взяв це про те, наскільки це піде.

Ось пробіг на ideone.com :

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

Як це працює?

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

Ця програма використовує 10 локацій пам'яті:

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

Рядок 1

• Цей рядок встановлює символи ASCII в регістри 2 - 7 (в основному). Деякі налаштування робляться пізніше.
• Цей код перші 3 ставить в регістрі 0, а потім 3 рази петля збільшення регістр 1 в чотири рази кожного циклу: +++[>++++<-]. Потім кінцевим результатом є те, що регістр 0 дорівнює 0, а регістр 1 - 12.
• 12 використовується як лічильник циклу для наступного циклу. За 12 разів через цикл регістри 2, 3 і 4 збільшуються 3 рази, регістр 5 збільшується в 10 разів, регістр 6 збільшується 1 раз, а регістр 7 збільшується в 4 рази. В кінці цієї петлі вони містять: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Після того як регістр циклу 2 збільшується в 6 разів, регістр 3 зменшується в 4 рази, а регістр 4 зменшується один раз. У цей момент значення становлять: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Усі, крім регістрів 5 і 6, містять свої початкові значення ASCII.
• Наступний реєстр 7 виводиться, "0"вгорі прапора!
• Наступний регістр 6 зменшується вдвічі до 10 (новий рядок ASCII) та виводиться. Зробив перший рядок прапора!

Рядок 2

• Спочатку він збільшує регістр 5 на 4, що робить його "|"(ASCII 124) і виводить його.
• Потім декременти реєструють 7, три змінивши його з "0"(ASCII 48) на "-"(ASCII 45) і виводячи його.
• Далі він ставить 7 у цикл лічильника 3 (регістр 8) і петлі 7 разів, виписуючи 8 тире кожного разу загалом 7 * 8 = 56 тире.
• Нарешті він закінчується виведенням нового рядка.

Рядок 3

• Цей рядок містить дві петлі.
• Перший цикл пише " * "5 разів.
• Потім " * "пишеться
• Друга петля петлі 4 рази записує 8 "#"на загальну кількість 32.
• Потім "#", "|"і "\n"пишуться.

Рядки 4 - 11

• Ці рядки використовують ту саму техніку, що і рядок 3, щоб виписати зірки та смуги прапора.

Рядок 12

• Цей рядок починає цикл, який працює 3 рази.
• Петля закінчується в рядку 17.

Рядок 13

• Пише смужку, яка йде через прапор.
• Використовує цикл, який 7 разів виконує запис "#"8 разів кожен цикл через цикл.

Рядок 14

• Початок циклу, який працює 2 рази.

Рядок 15

• Пише смужку, яка йде через прапор.
• Використовує цикл, який 7 разів виконує запис " "8 разів кожен цикл через цикл.

Рядок 16

• Кінець внутрішньої петлі, що починався з лінії 14.

Рядок 17

• Кінець зовнішньої петлі, що починався з лінії 13.

Рядок 18

• Малює нижню смугу прапора.

Рядок 19

• Малює нижню межу прапора.

Рядок 20

• Малює флагшток.
• Петлі 8 разів, написання "|"та новий рядок двічі кожен раз через цикл.

/// : 225 символів

/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

Використовуючи рядок шаблону, є 1 новий рядок, який є значущим і рахується

Тест запуску фрагмента нижче (це лише EcmaScript 6, 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>

Щоб бути ще патріотичнішим, ось версія 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 байти

Використання ідей з відповіді Ruby від ManAtWork з дозволу.

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

Рубі, 127 121 112 байт

Змінені лапки на ?використаний масив замість умовного кольору смужки. використовуються умовні замість формули для довжини смуги.

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

Хитрість тут полягає в тому, щоб намалювати смуги (і червоні / #і білі / space) до правильної довжини, а потім правильно виправдати їх, оббиваючи зірками. Ruby's rjustдозволяє нам вказати рядок прокладки, який чергується між " * "і " *".

Оригінальна версія, 127 байт

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 байт

У мові французького походження, який є свого роду фитинга

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]).

Результат дивіться тут

C, 235 211 208 205 203 198 197 186 байт

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

редагувати: додав кілька пропозицій Cool Guy і використав?: для заміни деяких, якщо заяви.

edit: видалено запобігання переповненню \ 0 та замість цього використовується обмежувач довжини рядка у printf.

редагувати: переробили обидва умовні умови.

редагувати: перемістив ставить ("0") всередині заголовка, щоб видалити його крапку з комою.

редагувати: незначне рефакторинг, щоб отримати ще 11 байт.