24

Os anéis borromeanos são um curioso conjunto de três círculos, ligados de tal forma que a remoção de qualquer um deles desvinculará os outros dois:

Você pode fazer um conjunto para si mesmo com alguns elásticos e um anel de encadernação . Com mais tiras de borracha, é fácil criar qualquer link brunniano .

Escreva um programa ou função que produza (imprima ou retorne) essa representação artística dos anéis borromeanos:

    +-----+
    |     |
+-----+   |
|   | |   |
| +-|---+ |
| | | | | |
| | +-|---+
| |   | |
+-|---+ |
  |     |
  +-----+

As linhas podem ter espaços à direita e pode haver uma nova linha à direita.

O código mais curto em bytes vence.

code-golf ascii-art kolmogorov-complexity

— Passatempos de Calvin
fonte

2

Eu tenho que dizer que este é um desafio bastante difícil por causa de quão simples é a saída esperada

— Beta Decay

3

Estou um pouco decepcionado. Pensei que o desafio seria usar um tamanho inteiro e anéis de saída desse tamanho.

— Blacklight Shining

Sim, eu também pensava (o programa toma int como uma entrada e depois desenha o Brunnian Link com tantos componentes, mas isso não é único, talvez um número de cruzamentos?). Esse tipo de programa teria que realmente pesquisar (ou pelo menos tentativa e erro - esses anéis se entrelaçam e, se eu remover um, é liberado?) Em vez de apenas desenhar uma imagem fixa ...

— alexey

7

CJam, 53 51 50 49 bytes

Conversão de base antiga simples ...

"FÓîÞ¤ÛYËB[¢O²êÍÓ
}²|äG"299b4b"+ -|"f=B/N*

Todos os caracteres estão bem no intervalo ASCII estendido (código ASCII 1 a 255), portanto, número de caracteres == número de bytes.

Experimente online aqui e obtenha o código original aqui

— Optimizer
fonte

Apenas curioso, onde está a nova linha em sua pesquisa?

— Maltysen

@ Maltysen eu não tenho isso. B/N*splits por 11 caracteres e se junta a nova linha seja

— Optimizer

isso é coooool.

— Maltysen

6

Pitão - 51 bytes

Tenho certeza de que alguém vai bater tão rápido, mas apenas uma resposta básica de compressão porque estou me sentindo preguiçoso. Vou tentar escrever uma resposta séria em breve.

s@L"
 +-|"jC" zB²;¶Ê ¿ïÁ»#-ÌClHõy%|ap"5

Experimente aqui online .

s              Reduce on string concatenation
 @L            Map second arg to index first arg
  "..."        String of all chars (Pyth allows literal newlines)
  j            Base conversion to list
   C           Base conversion 256 -> 10
    "..."      Base 256 string
   5           To Base 5

— Maltysen
fonte

4

Pitão, 49 bytes

jbc11s@L"+ -|"jC"Tª]UÊ¨WÕÝ_K¨}ÝÝ÷K¨Ý]Òê]UÕ*¡"4

Demonstração.

Isso usa a codificação base 4 e divide a string em décimos primeiro, depois as une em novas linhas.

— isaacg
fonte

3

Ruby, 110

-2.upto(8){|i|s=" "*(i%6)+"+-----+"*(1-i%2)+" "*9
6.times{|j|"@d me?K[RR@"[i+2].ord>>j&1>0&&s[j*2]=?|}
puts s}

Algo diferente da conversão de base direta.

Ungolfed:

-2.upto(8){|i|                                           #for each line
  s=" "*(i%6)+"+-----+"*(1-i%2)+" "*9                    #load s with "+-----+" (if required!) padded appropriately with leading spaces and with nine trailing spaces.   
  6.times{|j|"@d me?K[RR@"[i+2].ord>>j&1>0&&s[j*2]=?|}   #replace characters with | as necessary, according to the 6-bit number encoded by each character in the magic string.
  puts s}                                                #print the line.

— Level River St
fonte

3

Ruby, 117 bytes

Não ganhei, mas achei uma abordagem atraente:

puts'    --
    |     |
--  |
|   | |   |
| -||
| | | | | |
| | -|
| |   | |
-||
  |     |
  --'.gsub /-./,'+\0---+ '

— Lynn
fonte

2

BrainFuck, 361 bytes

Aqui está um pequeno programa do BrainFuck, apenas imprimindo char por char.

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

— AboveFire
fonte

1

Staq , 109 caracteres

&iiiqi{1" "}{211}{c"| "}{fcc}{o"+-|"}{p"+--"}{r"---+"}{ec;}22pr;22c22epr21ec2f2ecor1effcefor;f2ceor1e2c22e2pr

saída:

Executing D:\codegolf\Staq borromean rings.txt

    +-----+
    |     |
+-----+   |
|   | |   |
| +-|---+ |
| | | | | |
| | +-|---+
| |   | |
+-|---+ |
  |     |
  +-----+

Execution complete.
>

— ML
fonte

0

Python 3, 139 bytes

É o mais próximo que posso chegar de imprimi-lo diretamente (que seria 134 bytes) sem realmente fazê-lo ... Não tenho mais certeza de como encurtá-lo.

a='+-----+'
b='+-|---+'
c=' '*4
d='| '
e=c+d
print(c+a,e*2,a+e[1:],"|   | "*2,d+b+" |",d*6,d+d+b,"| |   "*2,b+" |",e[2:]+e,"  "+a,sep='\n')

— mbomb007
fonte

Anéis Borromeanos ASCII