Это моя подушка

66

... ты поможешь мне увековечить это?

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

У меня была эта подушка несколько лет, и, видимо, пришло время избавиться от нее. Можете ли вы написать функцию или программу, которую я могу взять с собой и использовать для воссоздания этой подушки, когда захочу немного вспомнить.

Он должен работать без входных аргументов.

Вывод должен выглядеть точно так (завершающие символы новой строки и пробелы в порядке).

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

Это код гольф, поэтому выигрывает самый короткий код в байтах!

Leaderboard

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

code-golf  ascii-art  kolmogorov-complexity 
— Стьюи Гриффин
источник
7
Я несколько разочарован тем, что рисунок не немного сложнее, чтобы представить различные толщины линий подушки.
— Спарр
4
@Sparr Я пытался, но мне не удалось заставить его выглядеть хорошо, используя только символы ASCII. Понял, что это было достаточно близко :)
— Стьюи Гриффин
3
Я бы только добавил пробелы
— Спарр
1
«по-видимому»: P
— Пизис
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. Я думаю, что это не может быть дальше в гольфе.

— Эрик Outgolfer
источник
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 байт

Рекурсивная функция. Несколько оптимизаций, вдохновленных ответом chocochaos .

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

демонстрация

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

— Arnauld
источник
Я думаю, что вы можете опустить первый &1и сохранить два байта
— Хенрик Кристенсен
@HenrikChristensen Это будет работать только для n < 480. Для n >= 480, мы должны были бы круглые скобки: (n/240^n/5)&1.
— Арно
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]]
— Angs
источник
6

Brainfuck, 140 байт

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

:-D

— 0WJYxW9FMN
источник
3
О, посмотри! Решение для мозгового удара на восемь байт короче, чем решение Java. Пора Java-кодерам переключиться на брейкфук ...
— 0WJYxW9FMN
Ява наносит ответный удар
— Cliffroot
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 с использованием одной строки, а затем наоборот

Спасибо @Аднан. Прошлой ночью прошлой ночью и до сих пор не совсем проснулся: p

-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, /и \, соответственно.

— Эрик Outgolfer
источник
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 байтов

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

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

Редактировать: Я должен был сделать ошибку при копировании. Эта версия должна работать

— Аксель Матстомс
источник
Добро пожаловать на сайт!
— DJMcMayhem
Не работает для меня Браузер зависает с этим интерпретатором , а персональный выводит неожиданный вывод из 5 строк: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ четыре раза, затем бесконечный \ .
— aluriak
Да, это работает :)
— 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

Pyth, 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)

Извините, если объяснение немного сложно понять, но это было довольно сложно.

— RK.
источник
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
— statox
источник
Здорово видеть кого-то еще использующего V! До недавнего времени это был только я. Если вам когда-нибудь понадобится помощь, не стесняйтесь пинговать меня в девятнадцатом байте
— DJMcMayhem
@DrMcMoylex Да, ваш язык кажется забавным в использовании :-) У меня была проблема с этим: изначально я хотел использовать, 5á\5á/05ä$5Ä5x$p4Ä3äGт.е. заменить Y4Pна, 4Äно по причине, которую я не понимаю, копирует дополнительную пустую строку ... Если вы можете просветите меня на этом, было бы хорошо. Также, если я найду немного свободного времени, я с удовольствием внесу вклад в язык (особенно выпуск № 4 )
— statox
Ах, да, это беспокоило меня много раз. Это известная проблема. Проблема в том, что Äэто синоним dd, а не Y. Обычно это не проблема, но это вызывает некоторые проблемы, если буфер имеет только одну строку или если вы находитесь на последней строке.
— DJMcMayhem
На самом деле, я просто понял, что такой подход будет по- прежнему работать , если вы заменили 3äGс , 3ä}так как он не будет дергать эту последнюю строку. v.tryitonline.net/…
— DJMcMayhem
Хорошо, я понимаю, почему это не сработало. И хороший способ выиграть 1 байт, спасибо!
— statox
4

Желе , 17 16 байт

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

Попробуйте онлайн!

Спасибо 6710 (миль) за -1 байт.

— Эрик Outgolfer
источник
1
Я думаю, что вы можете сохранить байт с⁾/\ẋ6Wẋ4;U$ẋ3x5Y
— миль
@ Майлз Спасибо, кажется, я пока не могу эффективно использовать квики :) И я знал, что мне не нужны две пары Y!
— Эрик Outgolfer
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 Отличная идея!
— Mego
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]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Уровень реки St
источник
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)
— Ren
источник
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();}
— Уровень реки St
источник
61 байт: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@ или спасибо, я знал, что должен быть лучший способ, i--но у меня не было времени его искать.
— Уровень Река St
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))
— Эрик Outgolfer
источник
1
Это использует тот же метод, что и мой ответ желе .
— Эрик Outgolfer
Более эффективный метод, чем мой, чтобы начать с
— 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при запуске!
— Тасос Папастилиану
@TasosPapastylianou ans()- дескриптор вызываемой функции, поэтому вам не нужно присваивать его чему-либо, например a=@..., потому что он неявно назначается ansкак дескриптор. Также он не печатается ans=при запуске, если вы специально не попросите об этом, ничего не делая с возвращенным значением и не добавляя a ;. Если вы это сделаете, вы получите 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

— chocochaos
источник
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 в троичной форме.
— Progrock
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;}

Сложил все в одну петлю. Beats Brainfuck, миссия выполнена.

Смотрите это онлайн: https://ideone.com/pZjma3

— cliffroot
источник
3

Vim, 44 27 байтов

РЕДАКТИРОВАТЬ Лот байтов выиграл благодаря @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
— statox
источник
О, эй, статокс, добро пожаловать на сайт! Это полностью соответствует правилам. Я играю в гольф в основном в VIM. Просто чтобы вы знали, вы могли бы сделать 5i/<esc>5a\<esc>0y$5Pв начале, чтобы сохранить 9 байтов.
— DJMcMayhem
Привет DrMcMoylex (новое имя? :-)) рад видеть вас здесь и что мой ответ подходит. Также спасибо за подсказку, я отредактирую свой ответ
— statox
2
Ха-ха, да, я временно изменил свое имя из-за этого вызова , смеется. Я изменю это назад через 30 дней
— DJMcMayhem
3

Brainfuck, 168 байт

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