24

Los anillos borromeos son un curioso conjunto de tres círculos, unidos de tal manera que la eliminación de cualquiera de ellos desenlazará los otros dos:

Puedes hacerte un set con un par de gomas y un anillo de carpeta . Con más bandas de goma, es fácil hacer cualquier enlace bruniano .

Escriba un programa o función que genere (imprima o devuelva) esta representación de arte asiatico de anillos borromeanos:

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

Las líneas pueden tener espacios finales y puede haber una nueva línea final.

El código más corto en bytes gana.

code-golf ascii-art kolmogorov-complexity

— Pasatiempos de Calvin
fuente

2

Tengo que decir que este es un desafío bastante difícil debido a lo simple que es el resultado esperado

— Decaimiento Beta

3

Estoy un poco decepcionado Pensé que el desafío sería tomar un tamaño entero y generar anillos de ese tamaño.

— Blacklight Shining

sí, yo también lo pensé (el programa toma int como entrada y luego dibuja Brunnian Link con tantos componentes, pero eso no es único, ¿tal vez una serie de cruces?). Ese tipo de programa tendría que hacer una búsqueda (o al menos prueba y error: ¿se enclavan estos anillos y, si elimino uno, se libera?) En lugar de simplemente dibujar una imagen fija ...

— alexey

7

CJam, 53 51 50 49 bytes

Conversión de base antigua simple ...

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

Todos los caracteres están dentro del rango ASCII extendido (código ASCII 1 a 255), por lo que el número de caracteres == número de bytes.

Pruébelo en línea aquí y obtenga el código original aquí

— Optimizador
fuente

Por curiosidad, ¿dónde está la nueva línea en tu búsqueda?

— Maltysen

@Maltysen No lo tengo. B/N*se divide por 11 caracteres y se une a la nueva línea

— Optimizer

Eso es genial.

— Maltysen

6

Pyth - 51 bytes

Estoy seguro de que alguien superará esto rápido, pero solo una respuesta de compresión base porque me siento flojo. Intentaré escribir una respuesta seria pronto.

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

Pruébalo aquí en línea .

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
fuente

4

Pyth, 49 bytes

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

Demostración.

Utiliza la codificación de base 4 y corta la cadena en undécimos, luego los une en líneas nuevas.

— isaacg
fuente

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 de la conversión de base recta.

Sin golf:

-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
fuente

3

Rubí, 117 bytes

No ganar, pero pensé que era un enfoque lindo:

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

— Lynn
fuente

2

BrainFuck, 361 bytes

Aquí hay un pequeño programa BrainFuck, que solo imprime char por char.

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

— Por encima de fuego
fuente

1

Staq , 109 caracteres

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

salida:

Executing D:\codegolf\Staq borromean rings.txt

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

Execution complete.
>

— ML
fuente

0

Python 3, 139 bytes

Esto es lo más cerca que puedo llegar a imprimirlo directamente (que sería 134 bytes) sin hacerlo realmente ... No estoy seguro de cómo acortarlo más.

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
fuente

Anillos Borromeo ASCII