Це моя подушка

66

... ти допоможеш мені увічнити це?

введіть тут опис зображення

Я мав цю подушку вже кілька років, і, мабуть, пора її позбутися. Чи можете ви, будь ласка, написати функцію чи програму, яку я можу взяти з собою та використовувати для відтворення цієї подушки, коли я хочу трохи нагадати.

Він повинен працювати без вхідних аргументів.

Вихід повинен виглядати саме так (прорисовуються нові рядки та пробіли).

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

Це кодовий гольф, тому найкоротший код у байтах виграє!

Таблиця лідерів

Показати фрагмент коду

code-golf  ascii-art  kolmogorov-complexity 
— Стюі Гріффін
джерело
7
Я дещо розчарований, що візерунок не є трохи складнішим, щоб представити різні товщини лінії подушки.
— Спарр
4
@Sparr Я спробував, але мені не вдалося зробити так, щоб це виглядало добре, використовуючи лише символи ASCII. Зрозуміло, що це досить близько :)
— Стюі Гріффін
3
Я щойно додав пробіли
— Sparr
1
'очевидно': P
— Pysis
7
Тепер ви можете придбати порожню подушку і надрукувати на ній фрагмент переможця.
— coredump

Відповіді:

24

05AB1E , 18 15 байт

Код:

„/\5×{4Å6×»6F=R

Пояснення:

„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string

Використовує кодування CP-1252 . Спробуйте в Інтернеті!

— Аднан
джерело
2
Вау ... дві різні позиції, однаковий байт ...
— Олівер Ні
30

/// , 116 байт

/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD

Спробуйте в Інтернеті!

Редагувати : \\\\\\\\\\\\\\\/і \\\\\\\\\\\\\\\\є насправді одинарними / і \ відповідно.

Редагувати : -3, тому що я думав видалити i. Я думаю, що це не можна далі гольфувати.

— Ерік Аутгольфер
джерело
15

Python 2, 49 байт

b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6

Дякую Мітчу Шварцу за цей чистий метод, який економить байт. Ідея полягає у тому, щоб надрукувати чотири рядки ('\\'*5+'/'*5)*6, поміняти місцями ролі косою рисою та зворотною косою рисою, а потім виконати цей процес 6 разів. Два символи зберігаються у aта bта заміняються як a,b=b,a. Подвійний цикл подвійний, генеруючи наступний рядок коду, а потім виконуючи його exec:

print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;

50 байт:

s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6

Створює рядковий рядок, друкує його чотири рази, а потім перевертає його, потім робить це 6 разів. Це робиться шляхом створення наступного коду, а потім його виконання:

print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]

Ось кілька ітерацій мого гольфу:

for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6

for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6

for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6

for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6

for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6

for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6

for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6

for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6

print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3

for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6

a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6

s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6

s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6

a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6
— xnor
джерело
12

05AB1E, 15 байт

„/\5×{R6×6FR4F=

Спробуйте в Інтернеті!

Пояснення:

„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping

Використовує кодування CP-1252 .

— Олівер Ні
джерело
8

JavaScript (ES6), 68 60 58 байт

Рекурсивна функція. Кілька оптимізацій надихнули на відповідь шоколадних цукерок .

f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''

Демо

Показати фрагмент коду

— Арнольд
джерело
Я думаю, ви можете залишити перший &1і зберегти два байти
— Генрік Крістенсен
@HenrikChristensen Це працювало б лише n < 480. Для n >= 480, ми повинні були б круглі дужки: (n/240^n/5)&1.
— Арнольд
8

Bubblegum , 30 байт

00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......

Обов’язкова відповідь Bubblegum.

— LegionMammal978
джерело
О, боже, ця мова приголомшлива!
— Педро
7

Haskell, 77 70 57 байт

a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]

Нудні concats і replicates замість того, щоб грати з синусами. Старий був:

unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
— Ангги
джерело
6

Brainfuck, 140 байт

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

:-D

— 0WJYxW9FMN
джерело
3
О, дивись! Рішення brainfuck на вісім байтів коротше, ніж рішення Java. Час Java-кодерів перейти на мозковий ебать ...
— 0WJYxW9FMN
Ява завдає удару у відповідь
— скеля
6

Python 2, 86 80 76 74 73 байт

for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]

Можливо, можливо, гольф ще кілька, але це початок.

Редагувати

Збережено 6, видаливши кілька непотрібних дужок

Ще 4, використовуючи один рядок, а потім повернути його назад

Дякую @Adnan Вчора ввечері була пізня ніч і ще не повністю прокинулася: с

-1, перемістивши *24до змінної, а не два рази

— ElPedro
джерело
4
Я вважаю, що *6*4це те саме, що *24? : p
— Аднан
6

Brainfuck, 149 байт

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

Найкращий перекладач EVAR!

Тут використовується 6 комірок (без обгортання, без модуля). Ось вони:

0A 00 2F 00 5C 00

Ці 00клітини використовуються для лічильників циклів. Тут лічильники заповнюються початковими значеннями:

0A 06 2F 04 5C 03

Крайній лівий лічильник призначений для внутрішньої петлі (так, я використовую вкладені петлі глибиною 3). Зверніть увагу, що 4-та клітинка ( 04лічильник) використовується двічі, один /////\\\\\...раз і \\\\\/////...кожен раз.

0A, 2Fі 5Cє символами \n, /і \, відповідно.

— Ерік Аутгольфер
джерело
6

Python 2.7 66 -> 56 -> 55 байт

a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3

новий у коді гольф

a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3

Спасибі Стюі Гріффін

Забув дурний пробіл;)

— Івар Мастомс
джерело
2
Ласкаво просимо до PPCG! Приємна перша відповідь :) Чи можете ви пропустити деякі проміжні змінні? Принаймні dі e, може, більше. Я не перевіряв, але це повинно бути близько: print(4*c+4*(6*b+"\n"))*3. Це на 5 байт менше.
— Стюі Гріффін
3
55 байт:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Стюі Гріффін
6

Brainfuck, 179 байт

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

Я знаю, що це не найкращий результат у потоці, але я хотів випробувати мозковий ебать і спробувати це.

Редагувати: я повинен помилитися під час копіювання. Ця версія повинна працювати

— Axel Matstoms
джерело
Ласкаво просимо на сайт!
— DJMcMayhem
Не працює для мене. Веб-переглядач перестає працювати з цим інтерпретатором , а персонал показує не очікуваний 5-ти рядковий вихід: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ чотири рази, а потім нескінченний \ .
— алуряк
Так, це працює :)
— aluriak
5

MATL , 18 16 байт

'\/'6:&+thK5&Y")

Спробуйте в Інтернеті!

Пояснення

'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array
— Луїс Мендо
джерело
5

Піт, 22 байти

V6V4V12p*5?%+bN2\\\/)k

Спробуйте тут .

Пояснення:

V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)

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

— РК.
джерело
5

V , 22 21 байт

Редагуйте один байт виграв, дякую @DjMcMayhem:

5á\5á/05ä$4Ä5x$p4Ä3ä}

Зміни:

  • Y4P-> 4ÄВикористовуйте V дублікат рядка замість вбудованої команди Vim (це додасть порожній рядок у кінці абзацу)
  • 3äG-> 3ä}Скопіюйте абзац замість цілого буфера (щоб уникнути порожнього рядка, породженого попередньою зміною)

Оригінальна публікація

5á\5á/05ä$Y4P5x$p4Ä3äG

Спробуйте в Інтернеті

Розкладено так:

5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text
— статокс
джерело
Приємно бачити когось іншого за допомогою V! До недавнього часу це був лише я. Якщо вам коли-небудь потрібна допомога, не соромтесь
— надіслати
@DrMcMoylex Yup ваша мова здається цікавою для використання :-) У мене виникла проблема з цим: спочатку я хотів використовувати 5á\5á/05ä$5Ä5x$p4Ä3äGтобто замінити Y4P, 4Äале з тієї причини, що я не розумію, це копіює додатковий порожній рядок ... Якщо ви можете просвіти мене на цьому, було б добре. Крім того, якщо я знайду вільний час, я б із задоволенням
— працював
Ага, так, це мене багато разів турбувало. Це відоме питання. Проблема в тому, що Äце синонім dd, а не Y. Зазвичай це не проблема, але це викликає деякі проблеми, якщо в буфері є лише один рядок або якщо ви перебуваєте в останньому рядку.
— DJMcMayhem
На самом деле, я просто зрозумів, що такий підхід буде по- , як і раніше працювати , якщо ви замінили 3äGз , 3ä}так як він не буде смикати цю останній рядок. v.tryitonline.net/…
— DJMcMayhem
Гаразд, я розумію, чому це не спрацювало зараз. І приємний спосіб виграти 1 байт, дякую!
— statox
4

Желе , 17 16 байт

⁾/\ẋ6Wẋ4;U$ẋ3x5Y

Спробуйте в Інтернеті!

Завдяки 6710 миль за -1 байт.

— Ерік Аутгольфер
джерело
1
Я думаю, ви можете зберегти байт за допомогою⁾/\ẋ6Wẋ4;U$ẋ3x5Y
— миль
@miles Дякую, здається, я ще не можу ефективно використовувати квіки :) І я знав, що мені не потрібно два Yс!
— Ерік Аутгольфер
4

Власне , 21 байт

"/\"5*SR6*;4α@R4α+3αi

Спробуйте в Інтернеті!

-1 байт від Аднана

Пояснення:

"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print
— Мего
джерело
Чи можете ви зробити щось на кшталт "/\"5*Sстворення рядка косої риски?
— Аднан
@Adnan Чудова ідея!
— Мего
4

Рубін, 46 байт

Створюється наступний рядок (70 символів, один набір більше, ніж потрібно), а потім чергується між символами вибірки 0..59та 5..64з нього.

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\

код та вихід

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

цікава помилка (7 замість 5)

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Рівень річки Св
джерело
4

APL, 30 байт

A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A

Я досить новачок у APL (я використовую APLX, але це має працювати в більшості реалізацій APL), тому це досить спрощене рішення.

Пояснення:

A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation 
                          of A and the reverse of A (⊖A)
— рен
джерело
4

C, 66 61 байт

5 байт збережено завдяки orlp.

Прямий характер за допомогою друку символів. 61 символ у рядку, останній - новий рядок (ASCII 10), а інші чергуються між /47 та \92.

i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);‌​}

//call like this
main(){f();}
— Рівень річки Св
джерело
61 байт: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@orlp спасибі, я знав, що там повинен бути кращий спосіб, i--але я не встиг його шукати.
— Рівень р. Св.
3

Python 2, 63 байти

a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)

Для Python 3 зробіть це (65 байт):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Ерік Аутгольфер
джерело
1
Для цього використовується той же метод, що і моя відповідь на Jelly .
— Ерік Аутгольфер
Більш ефективний метод, ніж мій, для початку
— ElPedro
@ElPedro В основному, я просто робив маніпуляції з рядком / масивом. Хитрість полягає в тому, що я підготував більшу струну: /////\\\\\/////...чотири рази, розділені новими рядками,
— Ерік Вигнавець
3

J, 31 28 19 байт

4#_60]`|.\5#72$'/\'

Використання

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— миль
джерело
3

Октава, 50 48 байт

Анонімні функції:

@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)

Ви можете спробувати онлайн тут . Просто запустіть вищевказану команду, а потім запустіть функцію за допомогою ans().

По суті, це створює масив значення 47, який 4 високий і 5 ширини. Потім він створює другий масив значення 92, який має однаковий розмір.

Два масиви з'єднані в шахму [A B;B A]. Це ''також об'єднано, щоб примусити перетворити символьні рядки.

Нарешті, весь масив повторюється 3 рази вниз і 6 разів поперек, щоб утворити остаточний розмір.

  • Збережено 2 байти, дякую @StewieGriffin
— Том Карпентер
джерело
відсутність потреби в анонімній функції; зберегти 3 байти.
— Тасос Папастиліноу
@TasosPapastylianou є, інакше він надрукує ans=перед подушкою. Наявність його у функції обходить це, оскільки очікується повернення відповіді до змінної, а не відображення її.
— Том Карпентер
Це просто семантика. Я маю на увазі, якщо ви будете педантичні, я б більше хвилювався про трирядкові попереджувальні повідомлення, які з’являються замість цього: p Також звичайні правила вказують, що це повинен бути або вихід з прямої команди терміналу, або викликається функціональна ручка. Це означає, що ви повинні призначити анонімну функцію ручці (або додати ще 5 байт, щоб обліковувати необхідність переадресації ans()). Що безглуздо, оскільки ans() все-таки друкується ansпри запуску!
— Tasos Papastylianou
@TasosPapastylianou ans()- це функція, яку можна викликати , тому вам не потрібно призначати її чомусь, наприклад a=@..., тому що вона неявно призначена ansяк ручка. Крім того, він не друкується ans=під час запуску, якщо ви спеціально не попросите його, не роблячи нічого із поверненим значенням і не додаючи ;. Якщо ви disp(ans())це зробили, ви надрукували б тільки точний вихід (ні ans=). Але так, попередження дратує, однак цього раніше не було, тож це не конкретна мова, а скоріше специфічна для перекладача.
— Том Карпентер
Гаразд, ми погодимося не погодитися. Як я це бачу, якщо ви покладаєтесь на те, disp(ans())перш ніж отримати результат, вам потрібно додати 12 байтів у свою відповідь. Моя власна думка, що це лише те, як октава представляє свій результат, і це добре.
— Тасос Папастиліноу
3

PHP, 73 69 байт

for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];

Демо

http://ideone.com/z7N1Md

— шоколад
джерело
1
69 байт: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(замініть \nсправжній новий рядок). echoце не функція, тому їй не потрібні дужки. Також echoможна отримувати кілька значень, розділених комою. Це дійсно знімає потребу в цих дужках. І тоді, всередині вашого $s[...], самого зовнішнього обчислення також не потрібні круглі дужки, оскільки він міститься в системі []. Використання $s[($i/5+($i/240|0))%2]має той самий ефект і коротше.
— Ісмаїл Мігель
Дякую, оновлено! Я навіть не знав про ехо, що приймає кілька параметрів ^ _ ^
— chocochaos
echoі printприймати кілька параметрів. Але printпотрібні дужки з декількома параметрами, коли вони використовуються для збільшення, умови або призначення циклу.
— Ісмаїл Мігель
Можна відтерти це <1, перемикаючи вирази echo$i%60?'':' ',, новий рядок як вираз 3 у потрійному.
— Прогрок
3

Java 7, 120 байт

String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}

Зсунув все в одну петлю. Удари Brainfuck, місія виконана.

Дивіться це в Інтернеті: https://ideone.com/pZjma3

— скелі
джерело
3

Вім, 44 27 байт

EDIT Багато байтів виграно завдяки @DrMcMoylex:

5i\<esc>5a/<esc>0y$5PY4P5x$pY3PyGPP

Оригінальна відповідь:

Я не впевнений, що дійсно відповідає правилам цього сайту, але я вважав, що це було цікаво спробувати:

i\<esc>59.:s;\v(.{5})\1;\1/////;g<CR>Y4P5x$pY3PyGPP

Які можна розкласти так:

i\<esc>                       Insert a \
59.                           Repeat 59 time the insertion
:s;\v(.{5})\1;\1/////;g<CR>   Match 5 characters followed by the same 5 characters
                              And replace them by these 5 characters followed by 5 /
Y4P                           Copy the line and repeat it 4 times
5x$p                          On the current line delete 5 characters and put them 
                              at the end of the line
Y3P                           Copy the line and repeat it 3 times
yG                            Copy all the lines
PP                            Repeat them 2 times
— статокс
джерело
О, ей, статокс, ласкаво просимо на сайт! Це повністю відповідає правилам. Я гольфу здебільшого vim. Тільки щоб ви знали, ви могли зробити 5i/<esc>5a\<esc>0y$5Pна початку, щоб зберегти 9 байт.
— DJMcMayhem
Ей, DrMcMoylex (нове ім’я ?:-)) рада бачити вас тут, і моя відповідь підходить. Також дякую за вашу підказку, я відредагую свою відповідь
— statox
2
Ха-ха, так, я тимчасово змінив своє ім’я через цей виклик , lol. Я
— поміняю
3

Brainfuck, 168 байт

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Мітчелл Хамфрі
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.