Saída uma caixa bonita

17

Seu desafio é gerar exatamente a seguinte caixa:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................

A caixa tem altura e largura 50, os espaços são dois largos.

Você deve escrever uma função ou programa que emita ou retorne uma string e não aceite nenhuma entrada.

Menos bytes ganha!

code-golf ascii-art kolmogorov-complexity Pavel
fonte
4
Alguma razão para a +caixa mais interna ter apenas 1 camada na parte superior e inferior? Isso tornará as respostas baseadas em algoritmos um pouco mais longas, pois significa que as duas camadas mais internas não são exatamente quadradas.
ETHproductions
@Pavel OK. Voto fechado retirado :)
Digital Trauma
4
Por que a restrição de um programa completo?
Rɪᴋᴇʀ
11
@Pavel porque? Não acrescenta realmente nada ao desafio.
Rɪᴋᴇʀ
11
@Pavel ..... não. Quero dizer, sim, alguns têm isso, mas não é de longe um requisito / padrão para os desafios da KG.
Rɪᴋᴇʀ

Respostas:

14

J , 25 bytes

echo'. + '{~4|>./~2#|i:12

Experimente online!

Explicação

echo'. + '{~4|>./~2#|i:12
                     i:12  Range from -12 to 12.
                    |      Take absolute values,
                  2#       duplicate every element,
                /~         compute "multiplication table"
              >.           using maximum,
            4|             take mod 4 of every element,
    '. + '{~               index into this string,
echo                       print char matrix for everyone to see.
Zgarb
fonte
Eu acho que você pode deixar o eco.
Conor O'Brien
@ ConorO'Brien Oh, a regra de saída mudou. ... Hmm, mas se eu remover echo, não será nem uma função, apenas um valor. Embora J não tenha funções de argumento zero de qualquer maneira.
Zgarb 13/01/19
Eu acho que é permitido de acordo com a natureza de substituição de J. Em qualquer caso, funções constantes podem ser consideradas como argumento zero.
Conor O'Brien
11

C, 115 bytes

#define M(x,y)x<(y)?x:y
f(i){for(i=2549;i;i--)putchar(i%51?". + "[(M(i%51-1,M(50-i%51,M(i/51,49-i/51))))/2%4]:10);}

Define uma função f(chamada como f();) que imprime a sequência em STDOUT.

Lynn
fonte
9

C, 535 478 477 bytes

Agora isso é muito golfe: - /

i;main(j){for(;++i<51;puts(""))for(j=0;++j<51;)putchar(i<3|i>48?46:j<3|j>48?46:i>4&i<47&j>4&j<47?i<7|(i>44&i<47)|(j>2&j<7)|(j>44&j<47)?43:j>8&j<43&((i>8&i<11)|(i>40&i<43))?46:i>9&i<41&((j>8&j<11)|(j>40&j<43))?46:i>13&i<37&((j>12&j<15)|(j>36&j<39))?43:((i>12&i<15)|(i>36&i<39))&j>12&j<39?43:i>17&i<33&((j>16&j<19)|(j>32&j<35))?46:((i>16&i<19)|(i>32&i<35))&j>16&j<35?46:i>21&i<29&((j>20&j<23)|(j>28&j<31))?43:((i>20&i<23)|(i>28&i<31))&j>20&j<31?43:i>24&i<27&j>24&j<27?46:32:32);}

Aqui está a saída;

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
cleblanc
fonte
2
Puta merda. Eu admiro sua dedicação.
Rɪᴋᴇʀ
Eu mudei a restrição, funções que retornam uma string são permitidas agora.
Pavel
Eu só percebi que pode golfe alguns bytes fora re-escrever os laços for(;i++<51;e agora eu estou fora por um todos os lugares: - /
cleblanc
@cleblanc++i
dkudriavtsev
MFW Comecei a tentar entender isso: i.imgur.com/TLV9gJ4.png +1
Magic Octopus Urn
6

Haskell, 72 bytes

q=(\n->[n,n]).abs=<<[-12..12]
unlines[[". + "!!mod(max x y)4|y<-q]|x<-q]

@ A solução da Zgarb em Haskell. Eu também tentei construir a caixa adicionando camadas ao redor do núcleo ["..",".."], mas ele é 9 bytes mais longo (81 bytes).

e!b=e:e:b++[e,e];s#c=(c!)<$>(c<$s!!0)!s
unlines$foldl(#)["..",".."]" + . + . + ."
nimi
fonte
5

Empilhados, não concorrentes, 35 bytes

Experimente aqui!

ε'.'3$' + .'2*tostr*+$surroundfold

Ungolfed:

'' '.  ++  ..  ++  ..  ++  ..' $surround fold

Bem simples. surroundé uma função que envolve uma entidade com uma entidade de preenchimento. Por exemplo, (0) 1 surroundé ((1 1 1) (1 0 1) (1 1 1)). $surroundé surrounduma função, não avaliada. foldpega um valor inicial, depois algo para dobrar e depois uma função. Nesse caso, surroundé folded, envolvendo a cadeia inicialmente vazia ''(equiv. ε) Com cada caractere da cadeia.

'.'3$' + .'2*tostr*+

Isso é criar uma cadeia de caracteres $' + .'que, quando multiplicada por um número, repete cada caractere. Isso nos deixa com: ++ ... Isso é então convertido em uma string. Em seguida, repetimos essa sequência três vezes e, finalmente, acrescentamos a ., fornecendo a sequência desejada.

Uma abordagem diferente para 39 bytes:

' .'3$' + .'2*tostr*+toarr$surround#\out

#\é insert e pega o caractere inicial da string como o valor inicial. Também funciona apenas em matrizes.

Conor O'Brien
fonte
Como isso não é competitivo, o desafio surgiu há apenas algumas horas.
Pavel
@Pavel Estou sempre trabalhando nisso
Conor O'Brien
4

JavaScript (ES6), 117 bytes

f=(n=12,c=`. + `[n%4],t=c.repeat(n*4+2))=>n?t+`
${t}
${f(n-1).replace(/^|$/gm,c+c)}
${t}
`+t:`..
..`
console.log(f())
Expandir snippet

A solução não-recursiva levou-me 128 bytes:

console.log([...Array(100)].map((_,i,a)=>a.map((_,j)=>`. + `[j=j>50?j-50:51-j,(i>j?i:j)%8>>1],i=i>50?i-50:51-i).join``).join`\n`)

Onde \nrepresenta o caractere literal de nova linha.

Neil
fonte
4

C, 97 bytes

i,x,y;main(){for(;i<2550;putchar(++i%51?". + "[(x*x<y*y?y:x)&3]:10))x=i%51/2-12,y=i/102-12;}
orlp
fonte
3

Geléia , 18 bytes

12ŒRAx2»þ`ị“ + .”Y

Experimente online!

A mesma abordagem da resposta J de Zgarb: 12ŒRAé abs([-12 … 12]), x2repete cada elemento duas vezes, »þ`cria uma tabela de máximos, ị“ + .”indexa ciclicamente em uma string e Yjunta - se por novas linhas.

Lynn
fonte
3

05AB1E , 39 35 33 bytes

•â3fM~•3B…012… .+‡.pvyD¤sg25s-׫«})«»

Experimente online!

•â3fM~•3B                               # Push 1100220011002200110022001
         …012… .+‡                      # Push ..  ++  ..  ++  ..  ++  .
                  .p                    # All prefixes of the above string.
                    vy            }     # For each prefix.
                      D¤sg25s-×         # Repeat the last letter until length is 25.
                               «Â«      # Concat, bifurcate, concat.
                                   )«» # Wrap to array, bifurcate, concat, print.

Versão de 33 bytes que é mais legal agora porque Emigna comentou, poupando-me 2 bytes:

". + "DøJ3×'.«.pvy¤25yg-׫«})«»

Experimente online!

Urna de polvo mágico
fonte
11
". + "DøJ3×'.«.pvy¤25yg-׫«})«»para 33 bytes.
Emigna
… .+•â3fM~•3BSè.pvy¤25yg-׫«})«»por 34 bytes na "versão mais fria".
Emigna
Legal não era a escolha correta da palavra haha. "Menos gueto", talvez?
Magic Octopus Urn
Eu amo o uso do comando prefix. Brilhante!
Emigna
11
@Emigna, os prefixos formam um triângulo, se você o transpuser e girar, em seguida, combine-o com os prefixos originais que você poderá cortar bytes. Esse era o plano principal que eu não conseguia alcançar.
Magic Octopus Urn
2

MATL , 21 bytes

'. + '[]25:"TTYaQ]2/)

Experimente online!

'. + '    % Push this string
[]        % Push empty array. This will be used as "seed"
25:"      % Do the following 25 times
  TTYa    %   Extend the array with a frame of zeros
  Q       %   Add 1 to each entry
]         % End
2/        % Divide by 2
)         % Index modularly into the string. Non-integer indices are rounded
          % Implicitly display
Luis Mendo
fonte
2

Ruby, 77 bytes

-623.upto(676){|i|print i%26>0?". + "[[(i%26-13).abs,(i/52).abs].max%4]*2:$/}
Level River St
fonte
Eu acho que você pode substituir a expressão de índice com [i%26-13,i/52].map(&:abs).max%4(salva um byte)
Conor O'Brien
2

Carvão , 25 bytes

Ｆ…¹¦²⁶⁺×ι§. + ÷鲶‖Ｏ↗‖Ｃ↑←

Experimente online! O link contém o modo detalhado para explicação

Somente ASCII
fonte
2

Python 3 , 89 bytes

r=range(-24,26)
for i in r:print("".join([". + "[max(abs(i//2),abs(j//2))%4]for j in r]))

Experimente online!

Freira Furada
fonte
1

Haskell, 385 bytes 

    b 0 = ["..", ".."]
b n = f:f:s:s:m (b (n - 1)) ++s:s:f:f:[]
    where f = replicate (8*n+2) $ d
          s = l++replicate ((8*n)-6) ' ' ++r
          m (x:xs) = map (\x -> l ++ x ++ r ) $ t
          l = d:d:' ':' ':[]
          r = reverse l
          t = b (n - 1)
          d :: Char
          d | n `mod` 2 == 0 = '.'
            | n `mod` 2 == 1 = '+'
main = mapM_ putStrLn $ b 6

Primeira rodada de código de golfe aqui ... ansioso para ver como os outros lidam com este.

Resultado:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
brander
fonte
3
1) Você tem toneladas de espaço em branco desnecessário. 2) coloque todas as definições de função dentro do whereem uma única linha e use ;para separação. 3) f:f:[]é f:[f] and d: '': '': [] `éd:" " . 4) mpega um parâmetro, mas não o usa. Inline me t. 5) defina uma nova função #para substituir replicate: c#x=c<$[1..8*n+x]e chame-a como d#2e ' '#(-6). 6) mod 2 == 0pode ser substituído com even, ou inverter o teste e uso odde o jogador de golfe de otherwise: 1<2. ...
nimi
2
... tudo em todos: b n=f:f:s:s:map(\x->l++x++r)(b$n-1)++s:s:f:[f]where f=d#2;s=l++' '#(-6)++r;l=d:d:" ";r=reverse l;d|odd n='+'|1<2='.';c#x=c<$[1..8*n+x].
N
1

Oitava, 53 bytes

 '.  ++  .'(mod(bsxfun(@max,x=[24:-1:0 0:24],x'),8)+1)

Gere um padrão de repetição de 1 a 8 do centro para fora e use-o como índice para extração de elementos de . ++ .

Experimente Online!

rahnema1
fonte
1

Bash, 191 bytes

echo H4sIAGUcgFgAA73VOw7AIAyD4b2n6F6J+x+v6k5CnPy1F6ZPAvNaS80li4/cUvrkKWdGapOak3O5DDmVS5G8XI5k5ZIkLpclUbk02ZfLk125f5B4JIljLY59cZwxx31x3H3HO5aFIo7/pZIpqWZClHSJmg55AeBhTxb2CQAA|base64 -d|gunzip

Provavelmente pode ficar menor, mas foi menor do que minhas tentativas algorítmicas.

throx
fonte
1

C #, 203 bytes

Programa completo e legível:

using System;
public class P
{
    public static void Main(string[] a)
    {
        Func<string> f = () =>
        {
            var z = 25;
            var t = "";
            Func<int, string> c = (q) => q % 4 == 0 ? ".." : (q % 4 != 2 ? "  " : "++");
            for (var y = 0; y < z; y++)
            {
                var l = "";
                for (var x = 0; x < z; x++)
                        l += ((y > z / 2) ? (x >= y | x < z - y) : (x < y | x >= z - y)) ? c(x):c(y);
                l += "\n";
                t += l + l;
            }
            return t;
        };

        Console.Write(f());
        Console.ReadKey();
    }
}

Função Golfed :

()=>{var z=25;var t="";Func<int,string>c=(q)=>q%4==0?"..":(q%4!=2?"  ":"++");for(var y=0;y<z;y++){var l="";for(var x=0;x<z;x++)l+=((y>z/2)?(x>=y|x<z-y):(x<y|x>=z-y))?c(x):c(y);l+="\n";t+=l+l;}return t;};
CSharpie
fonte
1

05AB1E , 33 bytes

14G" . +"NL¤¸13N-.׫€D¨Â«èD})¨Â«»

Experimente online!

Explicação

14G                               # for N in [1 ... 13]
   " . +"                         # push this string
         NL                       # push range [1 ... N]
           ¤¸13N-.×               # push a list of 13-N repetitions 
                                  # of the last element of the above range
                   «              # concatenate the two ranges
                    €D            # duplicate each element
                      ¨           # remove the last element
                       «         # concatenate a reversed copy to the list
                         è        # use the elements of the list to index into the string
                          D       # duplicate the resulting string
                           }      # end loop
                            )     # wrap the strings in a list
                             ¨    # remove the last element
                              «  # concatenate a reversed copy
                                » # join the list on newlines
Emigna
fonte
Explicação por vir?
Pavel
@ Pavel: é claro! :)
Emigna
1

PowerShell , 171 151 bytes

($x=(1..12|%{' . +'[$_%4]}|%{($a+=$_+$_)})+"$a."|%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}|%{,($_+-join$_[25..0])*2});$x[23..0]

Experimente online!

Resposta Ho-hum. Tenho certeza de que há uma maneira mais curta (dado o tamanho das outras respostas, estou confiante), mas isso mostra alguns truques legais.

Explicação:

1..12|%{' . +'[$_%4]} gera uma matriz de strings (de um caractere de comprimento), no padrão correto que precisamos. Experimente online!

Em seguida, adicionamos |%{($a+=$_+$_)})+"$a."qual pega a matriz e a expande lateralmente com base na linha anterior. Experimente online!

Essas strings são então enviadas para um loop |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)},. A cada iteração, escolhemos o caractere correto (um sinal de mais, um ponto ou um espaço) e, em seguida, usamos a .PadRightfunção para preencher o número apropriado de caracteres. Experimente online!

Agora, temos a base do canto superior direito. Precisamos reverter cada string |%{,($_+-join$_[($z=25..0)])*2}e anexá-las para que possamos chegar ao topo do bloco. Isso é feito com o -joincomando e a indexação para trás 25..0. Além disso, encapsulamos as seqüências de caracteres em uma matriz ,(...)e as fazemos dobrar *2para obter o topo inteiro.Experimente online!

Tudo isso é armazenado $xe encapsulado em parênteses, para colocar as seqüências no pipeline. Por fim, revertemos $x(certificando-se de cortar a linha do meio duplicada-duplicada, caso contrário, teríamos quatro.. no meio) e as deixamos no pipeline. Um implícito Write-Outputcoloca uma nova linha entre as strings, então obtemos isso de graça.

AdmBorkBork
fonte