Die Borromäischen Ringe sind ein merkwürdiger Satz von drei Kreisen, die so verbunden sind, dass durch das Entfernen eines der Kreise die beiden anderen Kreise voneinander getrennt werden:

Mit ein paar Gummibändern und einem Bindering können Sie sich ein Set zusammenstellen . Mit mehr Gummibändern ist es einfach, eine brunnische Verbindung herzustellen .

Schreiben Sie ein Programm oder eine Funktion, die diese ASCII-Darstellung von Borromäischen Ringen ausgibt (druckt oder zurückgibt):

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

Die Zeilen können abschließende Leerzeichen enthalten, und es kann eine abschließende neue Zeile geben.

Der kürzeste Code in Bytes gewinnt.

CJam, 53 51 50 49 Bytes

Einfache alte Basisumwandlung ...

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

Alle Zeichen liegen im erweiterten ASCII-Bereich (ASCII-Code 1 bis 255), also Anzahl der Zeichen == Anzahl der Bytes.

Probieren Sie es hier online aus und erhalten Sie den Originalcode hier

Pyth - 51 Bytes

Ich bin mir sicher, dass jemand so schnell schlagen wird, aber nur eine Antwort auf die Basiskomprimierung, weil ich mich faul fühle. Ich werde versuchen, bald eine ernsthafte Antwort zu schreiben.

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

Probieren Sie es hier 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

Pyth, 49 Bytes

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

Demonstration.

Hierbei wird die Basis-4-Codierung verwendet, und die Zeichenfolge wird in elfte Teile zerlegt und dann in Zeilenumbrüchen wieder zusammengefügt.

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

Etwas anderes als eine Konvertierung mit gerader Basis.

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.

Ruby, 117 Bytes

Nicht zu gewinnen, aber ich fand es eine nette Herangehensweise:

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

BrainFuck, 361 Bytes

Hier ist ein kleines BrainFuck-Programm, das nur Zeichen für Zeichen druckt.

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

Staq , 109 Zeichen

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

Ausgabe:

Executing D:\codegolf\Staq borromean rings.txt

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

Execution complete.
>

Python 3, 139 Bytes

Dies ist der nächste Punkt, an dem ich ihn direkt ausdrucken kann (das wären 134 Byte), ohne dies tatsächlich zu tun. Ich bin nicht sicher, wie ich ihn weiter kürzen soll.

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')