Сделай мне одеяло!

16

Я хочу одеяло, которое выглядит так. Каждая полоса переходит, под, над, под. Вы можете распечатать это?

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

Конечные пробелы в конце каждой строки и конечные символы новой строки являются приемлемыми.

Помните, это код-гольф , поэтому выигрывает код с наименьшим количеством байтов.

Leaderboards

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш счет равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

# Perl, 43 + 2 (-p flag) = 45 bytes

Вы также можете сделать название языка ссылкой, которая затем будет отображаться в фрагменте списка лидеров:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

code-golf ascii-art kolmogorov-complexity Оливер Ни
источник
Правый край кажется смещенным.
Волшебная Урна Осьминога
Левый край не перекрывается?
xnor
@xnor Извините, мой плохой.
Оливер Ни
@carusocomputing Исправлено.
Оливер Ни
10
Если бы вы использовали Песочницу, этих проблем можно было бы избежать до того, как это станет основным.
Мего

Ответы:

8

Python 2, 84 байта

R=range(24)
for i in R:print''.join(" \// \/\\"[i+~j>>2&1^i+j>>1&2^i&4]for j in R*2)

Благодаря Sp3000 за 6 байтов от превращения арифметических операций в побитовые.

XNOR
источник
Вау ... как ????
Оливер Ни
1
i+~j>>2&1^i+j>>1&2^i&4возможно?
Sp3000
@ Sp3000 Это хороший побитовый приоритет. Я должен помнить это при объединении арифметически производных логических выражений в индекс.
xnor
5

Pyth, 36 байт

V24sm@" \// \/\\"im<3%k8++BNdt-NdT48

Попробуйте онлайн: демонстрация

Объяснение:

Мы можем определить символ, проверив 3 условия:

A := row % 8 > 3
B := (row + column) % 8 > 3
C := (row - column - 1) % 8 > 3

Если мы интерпретируем [A,B,C]как двоичное число, мы получаем следующее отображение:

01234567
 \// \/\

Мы также можем интерпретировать [A,B,C]как десятичное число и выполнить модульный индексированный поиск в строке. Это не имеет значения, потому что 10 mod 8 = 2.

Теперь к коду:

V24повторяется N(row-idx) [0, 1, ..., 23].

sm...48сопоставляет числа d(column-idx) [0, 1, ..., 47]с символами и печатает объединенную строку.

++BNdгенерирует список [N, N+d], +...t-Ndдобавляет N-d-1. Итак, мы получили список [N, N+d, N-d-1]. m<3%k8проверяет каждое вычисленное число k, если 3 < k % 8, так что это дает список с условиями [A, B, C].

i...Tобъединяет это в десятичное число, а затем @" \// \/\\"выполняет поиск в строке.

Более или менее тот же код в Python2: 98 байт :

R=range(8)
for r in R*3:print''.join(" \// \/\\"[4*(r>3)+2*((r+c)%8>3)+((r-c-1)%8>3)]for c in R*6)
Jakube
источник
Просто пытаюсь разобраться с Пифом, чтобы любой достойный ответ с хорошим объяснением получил от меня отклик. собирался попробовать Pyth после моего эксперимента с базой 3 :)
ElPedro
Вы также должны опубликовать ответ Python2 ...
Джерри Иеремия
3

Perl, 209 + 17 = 226 байт

Запуск с -mList::Util=max -M5.010(второй флаг свободен). Он не выигрывает соревнования по подсчету байтов, но вот мое решение.

for(0..7){@b=(1)x8;@b[$_+3..$_+7]=(3)x4;@b[7-$_..10-$_]=(2)x4;for$c(0..2){$b[$c+8]=max$b[$c+8],$b[$c];$b[5-$c]=max$b[5-$c],$b[13-$c];}push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6;}say for@a,@a,@a

Удобочитаемый:

for(0..7){
    @b=(1)x8;
    @b[$_+3..$_+7]=(3)x4;
    @b[7-$_..10-$_]=(2)x4;
    for$c(0..2){
        $b[$c+8]=max$b[$c+8],$b[$c];
        $b[5-$c]=max$b[5-$c],$b[13-$c];
    }
    push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6
}
say for@a,@a,@a

Процедурно генерирует каждый сегмент, затем повторяет шаблон 6 раз, а затем выводит общий результат 3 раза.

Габриэль Бенами
источник
Вау, я больше не самый длинный ответ :) +1 за то, что делаю это в Perl.
ElPedro
Я мог бы сделать это так же, как и все остальные (просто напечатать несколько строк), но я решил сделать это алгоритмически, а не явно, потому что я чувствовал, что это круче.
Габриэль Бенами
Круто по моим меркам. Я выбрал подход, который никогда раньше не пробовал, потому что это был интересный вызов. Как я уже сказал, +1. Никаких оскорблений, предусмотренных моим комментарием. Вот почему я проголосовал.
ElPedro
3

Python 3, 174 172 138 байт

print("\n".join(o*6for o in("bbbb////"," bb//// ","  ////  "," ////bb ","////bbbb","b//  bbb","bb    bb","bbb  //b")*3).replace("b","\\"))

Нашел наименьший шаблон, который я смог найти в одеяле (шаблон «under» и «over»), вставил его в список и добавил некоторое понимание списка и манипуляции со строками, чтобы распаковать все это. Заменил все экранированные обратные слэши на «b» и заменил их позже, чтобы сэкономить несколько байтов.

Спасибо Оливеру за игру в 2 байта!

Сменив 34 байта, изменив шаблон - весь шаблон для одеяла теперь находится в одном списке, поэтому для развертывания шаблона нужен только один цикл for.

TheCrazyInventor
источник
1
Добро пожаловать в PPCG! хороший первый пост! Вы можете побрить байт в Python 2, я думаю, вам не нужны деньги для печати.
Rɪᴋᴇʀ
1
Спасибо, Истерли Ирк, я слишком долго слоняюсь в код-гольфе, поэтому решил принять участие. :)
TheCrazyInventor
1
Вы можете сохранить два байта, удалив пробел после 0*6иu*6
Оливер Ни
1
Вы можете сэкономить 4 байта, используя «b» для двойной обратной косой черты, и где бы вам ни понадобилась одиночная обратная косая черта, просто используйте экранирование:print((("\n".join(o*6 for o in("bb////"," b//// "," //// "," ////b ",""))+"\n".join(u*6 for u in("////bb","\\// b\\","b b","b\\ //\\","")))*3).replace("b","\\\\"))
dzaima
dzaima: кажется, ваш код не генерирует правильное одеяло.
TheCrazyInventor
3

Python 2, 171 170 168 байт

a,b,c=r"\\","/"*4," "
f,g=c*2,c+a+b+c
d=(a*2+b)*6,g*6,(f+b+f)*6,g[::-1]*6,(b+a*2)*6,('\\//'+f+a+"\\")*6,(a+f*2+a)*6,(a+"\\"+f+'//\\')*6
for e in 0,1,2:print'\n'.join(d)

Не красиво и не умно. Просто устанавливает переменные для наиболее часто используемых групп строк, затем объединяет их и печатает результат 3 раза. Возможно, попробую сыграть в гольф позже, если я не найду лучшего подхода.

1 байт сохранен с использованием необработанного ввода в назначении. Спасибо @ nedla2004

-2, назначив пару переменных, но все еще не серьезный конкурент

ElPedro
источник
1
Вы можете определить как r "\\"
nedla2004
Спасибо @ nedla2004 Хороший вопрос. Собрал это довольно быстро и собирался посмотреть на это позже. Это хорошее начало :)
ElPedro
Больше всего интересно найти способ обойти *6каждый элемент кортежа. Есть идеи?
ElPedro
1
Я не знаю, как ты мог это сделать, но последняя строка может быть exec r"print'\n'.join(d);"*3.
nedla2004
Я только что опубликовал альтернативу просто из интереса. Буду признателен за ваши комментарии по этому вопросу.
ElPedro
2

СОМЛ , 106 байт

3{"\\\\////”6*p" \\//// ”6*p"  ////  ”6*p" ////\\ ”6*p"////\\\\”6*p"\//  \\\”6*p"\\    \\”6*p"\\\  //\”6*p

неконкурентная версия, использующая функцию, которую я только недавно добавил: ( 83 67 66 байт)

объяснение:

  →$\\→#////→@”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~”
  →$                                                                in the further code replace "$" with "  "
    \\→#                                                            replace "#" with "\\"
        ////→@                                                      replace "@" with "////"
              ”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~” the code to exchange stuff in

so that results in:
”6*p"→~3{"\\\\////~ \\//// ~  ////  ~ ////\\ ~////\\\\~\//  \\\~\\    \\~\\\  //\~”
”6*p"→~3{"A~B~C~D~E~F~G~H~”  modified version of the program (removing "/","\" and " " and replaced with A,B,C,ect.)
”6*p"→~                      replace in the further program "~" with ”6*p" which is:
”                            end string
 6*                          repeat the last thing in stack 6 times
   p                         output the result
    "                        start a string
resulting program: 
3{"A”6*p"B”6*p"C”6*p"D”6*p"E”6*p"F”6*p"G”6*p"H”6*p"”
shortened example:
3{"A”6*p"B”6*p"H”6*p"”
3{                      repeat 3 times
  "A”                   push "A" (original: "\\\\////")
     6*p                output it multiplied by 6
        "B”             push "B" (original: " \\//// ")
           6*p          output it multiplied by 6
              "H”       push "H" (original: "\\\  //\")
                 6*p    output it multiplied by 6
                    "”  push an empty string (shorter to do ~” than ”6*p)
dzaima
источник
2

Рубин, 75 байтов

1152.times{|i|$><<"\\/ /\\\\ /"[(i+j=i/48)/4&1|(i-j)/2&2|j&4]+$/*(i%48/47)}

Лучше играть в гольф, используя одиночный 8-байтовый поиск строки, проиндексированный j & 4 в дополнение к другим параметрам, а не модифицируемую 4-байтовую строку.

Рубин, 81 байт

1152.times{|i|j=i/48%8;$><<"\\#{'/\\'[j/4]} /"[(i+j)/4&1|(i-j)/2&2]+$/*(i%48/47)}

Печатает диагональные полосы символ за символом. Правильный символ выбирается из строки из 4 символов в зависимости от наличия / отсутствия каждой цепи. Символ перекрытия варьируется в зависимости от того, какая нить находится сверху.

комментарии

1152.times{|i|j=i/48%8;        #Iterate through all printable chars. j is line number.
  $><<"\\#{'/\\'[j/4]} /"[     #Print a char from "\/ /" if j/4 even or "\\ /" if odd. character changes depending which strand on top.
   (i+j)/4&1|(i-j)/2&2]+       #Print \ if (i+j)/4==0, / if (i-j)/2&2 >0, space if both false. As above if both true. 
   $/*(i%48/47)                #If on column 47, print a newline.
}
Уровень реки St
источник
2

Perl 132 131 113 байтов

@a=((0)x4,1..4);map{say+(map$a[7-$_]?$a[$_]*$r?'/':'\\':$a[$_]?'/':$",0..7)x6;push@a,shift@a;$_%4||($r=!$r)}0..23

Ungolfed:

use strict;
use warnings;
use feature 'say';

my @a = ((1) x 4, (0) x 4);  # print '\' if true
my @b = ((0) x 4, (1) x 4);  # print '/' if true
my $r = 0;                   # print '\' over '/' if true

for (0 .. 23) {
    say((map { $a[$_] ? ($b[$_] * $r ? '/' : '\\') : ($b[$_] ? '/' : ' ') } 0 .. 7) x 6);
    unshift(@a, pop(@a));    # circular shift to left
    push(@b, shift(@b));     # circular shift to right
    $r = !$r if !($_ % 4);   # change print priority
}
Денис Ибаев
источник
2

05AB1E , 37 байт

Использует кодировку CP-1252 .

24FNU48FXXN+XN-<)8%3›J" \// \/\"è?}¶?

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

объяснение

Использует трюк мод-8, мастерски объясненный в ответе Якуба .

24F                                    # for N in [0 ... 23] do:
   NU                                  # save N in X
     48F                               # for N in [0 ... 48] do:
        XXN+XN-<)                      # push [X,X+N,X-N-1]
                 8%                    # mod each by 8
                   3›                  # compare with 3
                     J                 # join
                      " \// \/\"è?     # index into string and print
                                  }    # end inner loop
                                   ¶?  # print newline
Emigna
источник
2

Python, 245 236 234 233 230 216 212 198 195 байт

Хорошо, дольше, чем мой последний (и любой другой) ответ, но был бы заинтересован в обратной связи о подходе.

for a in(40,4496,6200,5456,3240,1188,720,228)*3:print((`a%6561/2178`+`a%2178/729`+`a%729/243`+`a%243/81`+`a%81/27`+`a%27/9`+`a%9/3`+`a%3/1`)*6).replace('0','\\').replace('1','/').replace('2',' ')

редактировать

-9 из-за того, что @ nedla2004 больше, чем я

-2, взяв лямбду за пределы цикла и потеряв 2 отступа

-1 с помощью in' '*3вместо, in 0,1,2так как я все hравно не использую . это просто счетчик.

-3 Почему, почему, почему я оставил перевод строки и 2 отступа между вторым и для печати ??? Уже поздно. Вернусь завтра.

-14 На самом деле может полностью потерять лямбду и просто включить декодер base 3 сразу после оператора print. Выглядит грязно, но в конце концов, это код гольф :)

-4 Нет смысла устанавливать переменную для целочисленного списка. Просто используйте его непосредственно во втором цикле for.

-14 и нет смысла использовать внешний цикл. Просто умножьте целочисленный кортеж на 3 (бессовестно украденный у @ nedla2004, чтобы получить меньше 200 :))

-3 Сохранено 3, сделав \ = 0, / = 1 и пробел = 2. Это делает список целых чисел короче, так как три из трех основных чисел теперь имеют начальные 0

Как это работает (и это делает)

Поскольку используются только 3 символа:

  1. l представляет собой список из 8 повторяющихся шаблонов как целочисленных эквивалентов их представления в виде базы 3, предполагая, что "" = 0, "\" = 1 и "/" = 2

  2. Лямбда Первый код после оператора print представляет собой упрощенный преобразователь целочисленных значений в строку из 3 базовых чисел.

  3. Первый цикл повторяется 3 раза, а вторая печатает каждую строку с базовыми 3 символами, умноженными на 6 и замененными на /, \ или пробел.

Я уверен, что мог бы использовать регулярное выражение вместо вложенного replace (), но я слишком устал, чтобы пытаться прямо сейчас. Это был всего лишь эксперимент, и он длился дольше, чем мои предыдущие работы с Python, но он был опубликован только для комментариев по этому подходу (а также потому, что я никогда раньше не работал в базе 3 и мне очень понравилось работать с конвертером).

ElPedro
источник
1
Вы можете просто удалить первое деление в конверсии базы 3.
Недла2004
По какой-то причине это раньше вызывало у меня проблемы, но я просто попытался, и теперь это работает. Большое спасибо за то, что проснулся больше, чем я. Я заново отредактирую свой ответ (а вы только что спасли мне 9 байтов :))
ElPedro
1
Я переписал преобразование base 3, оно больше не является лямбда, мне пришлось сделать его функцией, но его можно было бы преобразовать обратно в лямбду. Вы можете найти функцию здесь .
Недла2004
Благодарю. Я думаю, что комбинация двух может сработать, но это, вероятно, работа на завтрашний вечер :) Еще раз спасибо за ваши комментарии.
ElPedro
1
Я получил это до 169, здесь .
Недла2004
2

Рубин, 135 байт

puts [3320,1212,720,2172,6520,4144,2920,3184].map{|e|(e.to_s(3).rjust(8,"0").gsub("0"," ").gsub("1","\\").gsub("2","/"))*6+"\n"}.join*3

Числовой массив соответствует каждому компоненту каждой строки, переведенный в основание 3: = 0, \= 1, /= 2, затем преобразованный в десятичную. Однако вызовы gsub () слишком велики.

И только сейчас я увидел ответ @ ElPedro. :-( Просто совпадение.

jose_castro_arnaud
источник
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". Вы также можете сохранить байт, разделив все числа в массиве на 4 и заменив их eна (e*4).
Иордания
Ой, я думаю, так и должно быть tr("021"," /\\").
Иордания
90 байт: tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/…
Иордания,
2

PHP 157 126 байт

Принимая изменения @Titus списков в комментариях ... Я раздражен, я пропустил пункт 1, который я должен был поймать, но я не знал, что существует strtr (), где большинство сбережений приходит - хорошая работа Титус!

NEW:

while($i<32)echo$b=strtr([3322,' 322 ','0220',' 223 ',2233,12013,3003,13021][$i++%8],['  ','\\','//','\\\\']),"$b$b$b$b$b\n";

OLD:

<?$a=[zzyy,' zyy ',syys,' yyz ',yyzz,xysxz,zssz,xzsyx];while($i<32){$b=$a[$i++%8];$b=str_replace([z,x,y,s],['\\\\','\\','//','  '],$b);echo"$b$b$b$b$b$b
";}

Поскольку все обратные косые черты необходимо экранировать, это экономит довольно много места, чтобы упаковать их в другой символ и заменить их для вывода, а затем, когда я вызываю str_replace (), имеет смысл использовать его как можно чаще.

Toxik-Йогурт
источник
1
Вы можете удалить открытый тег, если вы используете -r. Используйте эти пять шагов для сохранения еще 30 байтов: ideone.com/wt4HGB 1) используйте $a[...]непосредственно в качестве str_replaceпараметра вместо его назначения. 2) strtrвместо str_replace. 3) Используйте цифры вместо букв. 4) Включите назначение в эхо. 5) Не назначайте $a, просто используйте его.
Тит
1

Python 2, 169 161 165 160 155 154 152

Основано на ответе @ ElPedro, с небольшими улучшениями. Чтобы увидеть объяснение, посмотрите их ответ . Это Python 2, хотя рядом с ним есть круглые скобки print.

Сохранено 8 байт с помощью переменной для replace. Это работает только для строк, и использование функции для этого будет дольше.

Сэкономили 4 байта, увидев, что @ElPedro понял, что им не нужен l, а я тоже нет.

Сохранено 5 байтов, не переворачивая range(8), и вместо использования +=для добавления к r, добавляя r в конец новой цифры. Попробуйте, используя repl.it

Сохранение 5 байтов путем кражи нового списка значений @ ElPedro.

Сохраняется 1 байт, удаляя пробел между inи (.

Сохранено 2 байта путем удаления переменной a.

for x in(40,4496,6200,5456,3240,1188,720,228)*3:
 r=''
 for i in range(8):r=`x/3**i%3`+r
 print(r*6).replace('0','\\').replace('1','/').replace('2',' ')
nedla2004
источник
Вы можете сохранить 1, удалив пробел между inи (в первом для
ElPedro
Также я потерял три байта, переупорядочив последовательность чисел, представляющих каждый символ в базовом списке 3. Смотрите мой ответ для объяснения. не стесняйтесь копировать. Что касается меня, то это совместная работа, и я рад видеть, что у моей первоначальной идеи был хоть какой-то потенциал :)
ElPedro
Вам не нужно a=3**i. Просто используйте for i in range(8):r=x / 3 ** i% 3, +rчтобы сохранить пару. Приоритет оператора позаботится обо всем остальном :)
ElPedro
Не уверен, как разделить символы преобразования строки. Парсер удалил их в моем последнем комментарии, так что не просто скопируйте и вставьте из моего предложения, иначе оно сломается :)
ElPedro
Хороший вопрос, я понял.
nedla2004
1

PHP, 184 байта

<?$p=['1111////',' 11//// ','  ////  ',' ////11 ','////1111','1//  111','11    11','111  //1'];for($j=0;$j<3;$j++)for($i=0;$i<8;$i++)echo str_replace(1,'\\',str_repeat($p[$i],6))."\n";

Выход:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
Марио
источник
0

Пакетный, 152 байта

@call:l
@call:l
:l
@for %%s in (\\\\//// " \\//// " "  ////  " " ////\\ " ////\\\\ "\//  \\\" "\\    \\" "\\\  //\")do @echo %%~s%%~s%%~s%%~s%%~s%%~s

Обработка строк в пакетном отстой, так что это, вероятно, лучший подход. Вызов и падение очень немного короче, чем вложенная forпетля. По крайней мере, мне не нужно цитировать мои обратные слеши!

Нил
источник
0

APL, 110 байт

Я новичок в APL, так что это упрощенное решение.

A←48⍴'\\\\////'⋄B←48⍴' \\//// '⋄C←48⍴'  ////  '⋄F←48⍴'\//  \\\'⋄G←48⍴'\\    \\'⋄24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

Вот мой подход: обратите внимание, что после первых 8 строк одеяла шаблон повторяется. Поэтому мне нужно только определить первые 8 строк, а затем я могу повторить их 3 раза. Также обратите внимание, что каждая строка повторяется после первых 8 символов. Поэтому для определения одной строки мне нужно только определить первые 8 символов, а затем повторить их 8 раз.

Вот решение для безвкусицы:

A←48⍴'\\\\////'⋄ ⍝ set A to a 48 element vector (48⍴) of repeated '\\\\////'s
B←48⍴' \\//// '⋄ ⍝ set B to a 48 element vector (48⍴) of repeated ' \\//// 's
C←48⍴'  ////  '⋄ ⍝ ...
D←48⍴' ////\\ '⋄ ⍝ Note that this is actually the reverse of vector B
E←48⍴'////\\\\'⋄ ⍝ Note that this is actually the reverse of vector A
F←48⍴'\//  \\\'⋄
G←48⍴'\\    \\'⋄
H←48⍴'\\\  //\'⋄ ⍝ Note that this is actually the reverse of vector F

24 48 ⍴ A,B,C,D,E,F,G,H ⍝ Make a 24 by 48 character matrix (24 48⍴) by concatenating A,B...H
                        ⍝ and repeating the string until the matrix is full

Выше я отмечал, что D - обратная сторона B, E - обратная сторона A, а H - обратная сторона F. В моем фактическом коде я использую это преимущество, не определяя D, F или H и используя функцию реверса. ⊖:

24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

жэнь
источник
0

Рубин, 132 байта

puts Zlib.inflate Base64.decode64 "eJzt0bENADAMAsGeKdggC/3+cyQRC+A2ipuT3RgJgHWGUjm6VXb2Vjn/3KpJ/qtIPlp1v+XSKZKPVk3y/x5+D6/3sAEUXQ+Q"

очень простой ответ.

dkudriavtsev
источник
0

Haskell, 96 байт

f n=n`mod`8`div`4
putStr$unlines[["\\ //\\ \\/"!!(f(x-y)+2*f(x+y)+4*f y)|x<-[0..47]]|y<-[0..23]]
Angs
источник