Este é meu travesseiro

66

... você vai me ajudar a imortalizá-lo?

insira a descrição da imagem aqui

Eu tenho esse travesseiro há alguns anos e, aparentemente, é hora de me livrar dele. Você pode escrever uma função ou programa que eu possa trazer comigo e usar para recriar esse travesseiro sempre que eu quiser relembrar um pouco.

Ele deve funcionar sem argumentos de entrada.

A saída deve ser exatamente assim (novas linhas e espaços à direita estão corretos).

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

Este é o código golf, então o código mais curto em bytes vence!

Entre os melhores

Mostrar snippet de código

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
fonte
7
Estou um pouco decepcionado por o padrão não ser um pouco mais complexo, para representar as diferentes espessuras de linha do travesseiro.
— Sparr
4
@ Sparr Tentei, mas não consegui fazer com que parecesse bom usando apenas caracteres ASCII. Percebi isso estava perto o suficiente :)
— Stewie Griffin
3
Eu teria acabado de adicionar espaços
— Sparr
11
'aparentemente': P
— Pysis 07/11
7
Agora você pode comprar um travesseiro em branco e imprimir o trecho vencedor.
— Coredump #

Respostas:

24

05AB1E , 18 15 bytes

Código:

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

Explicação:

„/\               # 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

Usa a codificação CP-1252 . Experimente online!

— Adnan
fonte
2
Wow ... duas tomadas diferentes, mesma contagem de bytes ...
— Oliver Ni
30

/// , 116 bytes

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

Experimente online!

Edit : the \\\\\\\\\\\\\\\/e \\\\\\\\\\\\\\\\são realmente um único / e \, respectivamente.

Edit : -3 porque eu pensei em remover i. Eu acho que isso não pode ser mais jogado.

— Erik, o Outgolfer
fonte
15

Python 2, 49 bytes

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

Agradecemos a Mitch Schwartz por esse método limpo que economiza um byte. A idéia é imprimir quatro linhas ('\\'*5+'/'*5)*6, trocar os papéis de barra e barra invertida e, em seguida, fazer todo esse processo 6 vezes. Os dois caracteres são armazenados em ae b, e trocados como a,b=b,a. O loop duplo é duplo, gerando a seguinte sequência de códigos e executando-a com 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 bytes:

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

Cria a sequência de linhas, imprime-a quatro vezes e depois a inverte, e faz isso 6 vezes. Faz isso gerando o seguinte código e, em seguida, executando-o:

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]

Aqui estão algumas das iterações do meu golfe:

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
fonte
12

05AB1E, 15 bytes

„/\5×{R6×6FR4F=

Experimente online!

Explicação:

„/\             # 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

Usa a codificação CP-1252 .

— Oliver Ni
fonte
8

JavaScript (ES6), 68 60 58 bytes

Uma função recursiva. Várias otimizações inspiradas nos chocochaos respondem .

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

Demo

Mostrar snippet de código

— Arnauld
fonte
Eu acho que você pode deixar de fora o primeiro &1e salvar dois bytes
— Henrik Christensen
@HenrikChristensen Isso só funcionaria n < 480. Para n >= 480, precisaríamos parênteses: (n/240^n/5)&1.
— Arnauld #
8

Chiclete , 30 bytes

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

Resposta obrigatória do chiclete.

— LegionMammal978
fonte
Oh meu Deus, essa linguagem é incrível!
— Pedro A
7

Haskell, 77 70 57 bytes

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

Aborrecido se concates em replicatevez de brincar com os senos. Velho era:

unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
— Angs
fonte
6

Brainfuck, 140 bytes

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

:-D

— 0WJYxW9FMN
fonte
3
Veja! A solução brainfuck é oito bytes menor que a solução Java. Tempo para codificadores de Java para mudar para brainfuck ...
— 0WJYxW9FMN
O Java ataca novamente
— cliffroot 7/16
6

Python 2, 86 80 76 74 73 bytes

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

Provavelmente poderia jogar um pouco mais, mas é um começo.

Editar

Salvo 6, removendo alguns suportes desnecessários

Outros 4 usando uma única string e depois invertendo-a

Obrigado @Adnan. Teve uma madrugada de ontem à noite e ainda não estava totalmente acordado ainda: p

-1 movendo o *24para a variável em vez de usá-lo duas vezes

— ElPedro
fonte
4
Eu acredito que *6*4é o mesmo que *24? : p
— Adnan
6

Brainfuck, 149 bytes

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

O melhor intérprete EVAR!

Isso usa 6 células (sem quebra, sem módulo). Aqui estão eles:

0A 00 2F 00 5C 00

As 00células são usadas para os contadores de loop. Aqui, os contadores são preenchidos com valores iniciais:

0A 06 2F 04 5C 03

O contador mais à esquerda é para o loop mais interno (sim, eu uso loops aninhados de profundidade 3). Observe que a quarta célula ( 04contador) é usada duas vezes, uma /////\\\\\...vez e uma vez para \\\\\/////...sempre.

0A, 2FE 5Csão os caracteres \n, /e \, respectivamente.

— Erik, o Outgolfer
fonte
6

Python 2.7 66 -> 56 -> 55 bytes

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

novo no código de golfe

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

Obrigado Stewie Griffin

Esqueceu um espaço em branco bobo;)

— Ivar Matstoms
fonte
2
Bem-vindo ao PPCG! Ótima primeira resposta :) Você pode pular algumas das variáveis ​​intermediárias? Pelo menos de e, talvez mais. Eu não testei isso, mas deve ser próximo: print(4*c+4*(6*b+"\n"))*3. São 5 bytes a menos.
— Stewie Griffin
3
55 bytes:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin
6

Brainfuck, 179 bytes

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

Eu sei que essa não é a melhor pontuação do segmento, mas eu queria experimentar o cérebro e tentar fazer isso.

Edit: Eu devo ter cometido um erro ao copiar. Esta versão deve funcionar

— Axel Matstoms
fonte
Bem vindo ao site!
— DJMcMayhem
Nao funciona para mim. O navegador desliga com esse intérprete e o pessoal mostra uma saída de 5 linhas não esperada: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ quatro vezes e depois infinita \ .
— aluriak
Sim, ele funciona :)
— aluriak
5

Pyke, 16 bytes

"/\"6*5m*n+4*sD3

Após a atualização hoje, permitida "em literais de cadeia de caracteres, 17 bytes

"/\\"6*5m*n+4*sD3

Experimente aqui!

— Azul
fonte
5

MATL , 18 16 bytes

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

Experimente online!

Explicação

'\/'   % 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
— Luis Mendo
fonte
5

Pitão, 22 bytes

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

Experimente aqui .

Explicação:

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)

Desculpe se a explicação é um pouco difícil de entender, mas foi meio complicada.

— RK.
fonte
5

V , 22 21 bytes

Editar Um byte ganho, obrigado @DjMcMayhem:

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

As mudanças são:

  • Y4P-> 4ÄUse a linha duplicada V em vez do comando interno do Vim (isso adicionará uma linha em branco no final do parágrafo)
  • 3äG-> 3ä}Duplicar o parágrafo em vez de todo o buffer (para evitar a linha em branco gerada por alterações anteriores)

Postagem original

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

Experimente online

Decomposto como este:

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
fonte
É legal ver alguém usando o V! Até recentemente, era apenas eu. Se você precisar de ajuda com isso, sinta-se à vontade para me
— enviar um
@DrMcMoylex Sim, seu idioma parece divertido de usar :-) Eu tive um problema com este: inicialmente eu queria usar, 5á\5á/05ä$5Ä5x$p4Ä3äGou seja, substituir Y4Ppor, 4Ämas por um motivo que eu não entendo, copia uma linha em branco adicional ... Se você puder Esclareça-me sobre isso, seria bom. Além disso, se eu encontrar algum tempo livre eu ficaria feliz em contribuir para a linguagem (especialmente a edição # 4 )
— statox
Ah, sim, isso já me incomodou muitas vezes. É um problema conhecido. O problema é que isso Äé sinônimo dd, não Y. Isso geralmente não é um problema, mas causa alguns problemas se o buffer tiver apenas uma linha ou se você estiver na última linha.
— DJMcMayhem
Na verdade, eu só percebi, essa abordagem ainda iria funcionar se você substituiu 3äGcom 3ä}uma vez que não vai arrancar a última nova linha. v.tryitonline.net/…
— DJMcMayhem
Ok, acho que entendi por que não funcionou agora. E ótima maneira de ganhar 1 byte, obrigado!
— Statox
4

Na verdade , 21 bytes

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

Experimente online!

-1 byte de Adnan

Explicação:

"/\"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
— Mego
fonte
Você pode fazer algo como "/\"5*Spara criar a sequência de barras?
— 11306 Adnan
@Adnan Ótima idéia!
— Mego
4

Ruby, 46 bytes

Cria a seguinte sequência (70 caracteres, um conjunto a mais do que o necessário) e depois alterna entre os caracteres de amostra 0..59e a 5..64partir dela.

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

código e saída

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

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

erro interessante (um 7 em vez de um 5)

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

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
fonte
4

APL, 30 bytes

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

Sou bastante novo no APL (estou usando o APLX, mas isso deve funcionar na maioria das implementações do APL), portanto, essa é uma solução bastante simplista.

Explicação:

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
fonte
4

C, 66 bytes

5 bytes salvos graças ao orlp.

Caractere simples por impressão de caracteres. 61 caracteres por linha, o último é nova linha (ASCII 10) e os outros alternam entre /47 e \92.

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

//call like this
main(){f();}
— Level River St
fonte
61 bytes: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— Orlp
@orlp obrigado, eu sabia que tinha que haver uma maneira melhor com o, i--mas não tive tempo de procurar.
— Level River St
3

Python 2, 63 bytes

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

Para Python 3, faça o seguinte (65 bytes):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik, o Outgolfer
fonte
11
Isso usa o mesmo método da minha resposta Jelly .
— Erik the Outgolfer
Método mais eficiente do que a minha para começar
— ElPedro
@ ElPedro Basicamente, eu apenas fiz alguma manipulação de string / array. O truque é que eu preparei uma seqüência maior: /////\\\\\/////...quatro vezes, separados por novas linhas
— Erik as Outgolfer
3

J, 31 28 19 bytes

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

Uso

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— milhas
fonte
3

Oitava, 50 48 bytes

Função anônima:

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

Você pode tentar online aqui . Simplesmente execute o comando acima e, em seguida, execute a função com ans().

Essencialmente, isso cria uma matriz do valor 47, que é 4 de altura e 5 de largura. Em seguida, ele cria uma segunda matriz de valor 92, que é do mesmo tamanho.

As duas matrizes são concatenadas em um tabuleiro de damas de [A B;B A]. Também ''é concatenado para forçar a conversão em cadeias de caracteres.

Finalmente, toda a matriz é replicada 3 vezes para baixo e 6 vezes para formar o tamanho final.

  • Salvo 2 bytes, obrigado @StewieGriffin
— Tom Carpenter
fonte
não há necessidade de uma função anônima; economize 3 bytes.
— Tasos Papastylianou
@TasosPapastylianou, caso contrário, ele será impresso ans=antes do travesseiro. Tê-lo na função contorna isso, pois é esperado que você retorne a resposta a uma variável em vez de exibi-la.
— 9786 Tom Carpenter #
Isso é apenas semântica. Quero dizer, se você for pedante, eu me preocupo mais com as mensagens de aviso de três linhas que aparecem: p Também as regras usuais afirmam que ele precisa ser uma saída de um comando direto do terminal ou um chamador alça de função. Isso significa que você deve atribuir sua função anônima a um identificador (ou adicionar outros 5 bytes para explicar por ter que pressionar ans()). O que é inútil, pois ans() ainda imprime ansquando é executado!
— Tasos Papastylianou
@TasosPapastylianou ans()é um identificador de função que pode ser chamado , então você não precisa atribuí-lo a algo com, por exemplo a=@..., porque está implicitamente atribuído anscomo identificador. Também não é impresso ans=quando executado, a menos que você solicite especificamente, não fazendo nada com o valor retornado e não adicionando a ;. Se você o fizer disp(ans()), imprimirá apenas a saída exata (não ans=). Mas sim, o aviso é irritante, no entanto, isso não aconteceu anteriormente; portanto, não é específico do idioma, mas específico do intérprete.
— Tom Carpenter
Ok, vamos concordar em discordar. Do jeito que eu vejo, se você está confiando disp(ans())antes de obter sua saída, precisa adicionar 12 bytes à sua resposta. Minha opinião é que é assim que a oitava apresenta seu resultado, e isso é bom.
— Tasos Papastylianou
3

PHP, 73 69 bytes

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

Demo

http://ideone.com/z7N1Md

— chocochaos
fonte
11
69 bytes: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(substitua \npor uma nova linha real). echonão é uma função, portanto, não precisa de parênteses. Além disso, echopode receber vários valores, separados por vírgula. Isso realmente remove a necessidade desses parênteses. E então, dentro do seu $s[...], o cálculo mais externo também não precisa de parênteses, pois está contido nele []. Usar $s[($i/5+($i/240|0))%2]tem o mesmo efeito e é mais curto.
— Ismael Miguel
Obrigado, atualizado! Eu nem sequer saber sobre eco aceitar vários parâmetros ^ _ ^
— chocochaos
echoe printaceite vários parâmetros. Mas printrequer parênteses com vários parâmetros quando usado no incremento, condição ou atribuição de um loop.
— Ismael Miguel
Pode eliminar isso <1, alternando as expressões echo$i%60?'':' ',, nova linha como expressão 3 no ternário.
— Progrock
3

Java 7, 120 bytes

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

Empurrou tudo em um loop. Bate Brainfuck, missão cumprida.

Veja on-line: https://ideone.com/pZjma3

— cliffroot
fonte
3

Vim, 44 27 bytes

EDIT Muitos bytes ganhos graças a @DrMcMoylex:

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

Resposta original:

Não tenho certeza de que realmente se encaixa nas regras deste site, mas achei divertido experimentá-lo:

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

Que pode ser decomposto assim:

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
fonte
Oh, ei statox, bem-vindo ao site! Isso se encaixa totalmente nas regras. Eu jogo principalmente no vim. Só para você saber, você poderia fazer 5i/<esc>5a\<esc>0y$5Pno início para salvar 9 bytes.
— DJMcMayhem
Hey DrMcMoylex (novo nome? :-)) prazer em vê-lo aqui e que minha resposta se encaixa. Também obrigado pela sua dica, eu vou editar a minha resposta
— statox
2
Haha, sim, eu mudei temporariamente meu nome por causa desse desafio , lol. Vou mudar de volta em 30 dias
— DJMcMayhem
3

Brainfuck, 168 bytes

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.