24

Les anneaux borroméens sont un curieux ensemble de trois cercles, liés de telle sorte que la suppression de l'un d'eux dissociera les deux autres:

Vous pouvez créer un ensemble pour vous-même avec quelques élastiques et un anneau de reliure . Avec plus d'élastiques, il est facile de créer n'importe quel lien brunnien .

Écrivez un programme ou une fonction qui produit (imprime ou renvoie) cette représentation ascii-art des anneaux Borroméens:

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

Les lignes peuvent avoir des espaces de fin et il peut y avoir une nouvelle ligne de fin.

Le code le plus court en octets gagne.

code-golf ascii-art kolmogorov-complexity

— Loisirs de Calvin
source

2

Je dois dire que c'est un défi assez difficile à cause de la simplicité de la sortie attendue

— Beta Decay

3

Je suis un peu déçu. Je pensais que le défi serait de prendre une taille entière et de produire des anneaux de cette taille.

— Blacklight Shining

oui, je le pensais aussi (le programme prend int comme entrée puis dessine Brunnian Link avec autant de composants, mais ce n'est pas unique, peut-être un certain nombre de croisements?). Ce genre de programme devrait en fait faire une recherche (ou au moins des essais et des erreurs - ces anneaux se verrouillent-ils et si j'en supprime un, faites-le gratuitement?) Au lieu de simplement dessiner une image fixe ...

— alexey

7

CJam, 53 51 50 49 octets

Conversion de base ancienne simple ...

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

Tous les caractères sont bien dans la plage ASCII étendue (code ASCII 1 à 255), donc nombre de caractères == nombre d'octets.

Essayez-le en ligne ici et obtenez le code original ici

— Optimiseur
source

Juste curieux, où est la nouvelle ligne dans votre recherche?

— Maltysen

@Maltysen Je ne l'ai pas. B/N*se divise par 11 caractères et rejoint be newline

— Optimizer

c'est coooool.

— Maltysen

6

Pyth - 51 octets

Je suis sûr que quelqu'un va battre aussi vite, mais juste une réponse de compression de base car je me sens paresseux. J'essaierai d'écrire une réponse sérieuse bientôt.

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

Essayez-le ici en ligne .

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
source

4

Pyth, 49 octets

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

Manifestation.

Celui-ci utilise l'encodage en base 4, et coupe la chaîne en onzièmes, puis les rejoint sur les nouvelles lignes.

— isaacg
source

3

Rubis, 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}

Quelque chose de différent de la conversion de base simple.

Non 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
source

3

Rubis, 117 octets

Pas gagnant, mais j'ai pensé que c'était une approche mignonne:

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

— Lynn
source

2

BrainFuck, 361 octets

Voici un petit programme BrainFuck, n'imprimant que char par char.

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

— AboveFire
source

1

Staq , 109 caractères

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

sortie:

Executing D:\codegolf\Staq borromean rings.txt

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

Execution complete.
>

— ML
source

0

Python 3, 139 octets

C'est le plus proche que je peux obtenir pour l'imprimer directement (ce qui serait de 134 octets) sans le faire ... Je ne sais plus comment le raccourcir plus.

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
source

Anneaux Borroméens ASCII