24

Gli anelli borromei sono un curioso insieme di tre cerchi, collegati in modo tale che la rimozione di uno di essi scollegherà gli altri due:

Puoi creare un set per te stesso con un paio di elastici e un anello legante . Con più elastici, è facile creare qualsiasi collegamento brunniano .

Scrivi un programma o una funzione che emetta (stampa o ritorna) questa rappresentazione ascii-art degli anelli borromei:

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

Le linee possono avere spazi finali e potrebbe esserci una riga finale.

Vince il codice più breve in byte.

code-golf ascii-art kolmogorov-complexity

— Hobby di Calvin
fonte

2

Devo dire che questa è una sfida piuttosto difficile a causa di quanto sia semplice l'output previsto

— Decadimento beta

3

Sono un po 'deluso. Pensato che la sfida sarebbe quella di prendere una dimensione intera e produrre anelli di quella dimensione.

— Blacklight Shining,

sì, l'ho pensato anch'io (il programma prende int come input e quindi disegna Brunnian Link con così tanti componenti, ma non è univoco, forse un certo numero di incroci?). Quel tipo di programma dovrebbe effettivamente cercare (o almeno tentativi ed errori - fare questi interblocchi di anelli e se ne rimuovo uno, liberarsi?) Invece di disegnare un'immagine fissa ...

— alexey

7

CJam, 53 51 50 49 byte

Semplice conversione base vecchia ...

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

Tutti i caratteri rientrano nell'intervallo ASCII esteso (codice ASCII da 1 a 255), quindi numero di caratteri == numero di byte.

Provalo online qui e ottieni il codice originale qui

— Optimizer
fonte

Solo curioso, dov'è la newline nella tua ricerca?

— Maltysen,

@Maltysen Non ce l'ho. B/N*si divide per 11 caratteri e si unisce newline

— Optimizer

questo è coooool.

— Maltysen,

6

Pyth - 51 byte

Sono sicuro che qualcuno batterà così velocemente, ma solo una risposta di compressione di base perché mi sento pigro. Proverò presto a scrivere una risposta seria.

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

Provalo qui 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

Pyth, 49 byte

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

Dimostrazione.

Questo utilizza la codifica di base 4 e taglia la stringa in undicesimi, quindi li ricongiunge su newline.

— 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}

Qualcosa di diverso dalla conversione base diretta.

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

Rubino, 117 byte

Non vincere, ma ho pensato che fosse un approccio carino:

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

— Lynn
fonte

2

BrainFuck, 361 byte

Ecco un piccolo programma BrainFuck, che stampa solo char con char.

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

— AboveFire
fonte

1

Staq , 109 caratteri

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

produzione:

Executing D:\codegolf\Staq borromean rings.txt

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

Execution complete.
>

— ML
fonte

0

Python 3, 139 byte

Questo è il più vicino che posso arrivare a stamparlo direttamente (che sarebbe 134 byte) senza effettivamente farlo .... Non sono sicuro di come accorciarlo più.

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

ASCII Borromean Rings