Stampa il quadrato quadrato perfetto più piccolo

16

Squaring the Square è un processo di piastrellatura di un quadrato usando solo altri quadrati. Se questa piastrellatura utilizza solo quadrati di dimensioni diverse, è considerata perfetta . Il quadrato quadrato perfetto più piccolo possibile è un quadrato quadrato di 112x112 che utilizza 21 quadrati diversi.

Ho creato la versione in arte ascii di questo quadrato qui sotto:

################################################################################################################
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ############################
#                                                ##                                 ############################
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                #############################################                 #
#                                                #############################################                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ###############################
#                                                ##             ##               ###############################
#                                                ##             ##               ##    ##                      #
#                                                ##             ##               ##    ##                      #
##################################################################               ##    ##                      #
##################################################################               ##    ##                      #
#                           ##                       ##       ###########################                      #
#                           ##                       ##       ###########################                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##################                ##                      #
#                           ##                       ##################                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ###########################################
#                           ##                       ##              ###########################################
#                           ##                       ##              ##                                        #
#                           ##                       ##              ##                                        #
#                           ##                       ##              ##                                        #
#                           ###########################################                                        #
#                           ###########################################                                        #
#                           ##  ##                                   ##                                        #
#                           ##  ##                                   ##                                        #
##################################                                   ##                                        #
##################################                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
################################################################################################################

Il tuo invio dovrebbe stampare il quadrato sopra. Se lo desideri, puoi stampare un riflesso e / o una rotazione del quadrato sopra. È consentita una nuova riga finale sull'ultima riga. Questo è un codice-golf , quindi vince il più piccolo invio!

code-golf  kolmogorov-complexity 
— Nathan Merrill
fonte
@Optimizer Secondo la domanda e Wikipedia, tutti i quadratini devono avere dimensioni completamente diverse.
— Level River St
Nathan, la mia presentazione è conforme alle regole? Ho usato uno spessore uniforme per tutte le linee.
— DavidC,
@DavidCarraher Ho delineato ciascun lato del quadrato (quindi i lati interni hanno più segni di cancelletto). Inoltre, è necessario utilizzare #invece diX
— Nathan Merrill il
1
Nathan, Nel piano, i bordi non sono bordi. Sono segmenti di linea monodimensionali. Dove due tessere si avvicinano, dovremmo vedere una sola linea, non due. Altrimenti, stiamo trasmettendo l'idea che ci sia uno spazio tra le tessere.
— DavidC
@DavidCarraher mentre questo è vero, penso che abbia più senso rappresentarlo in ASCII in questo modo.
— Nathan Merrill,

Risposte:

4

CJam, 88 84 83 byte

'p:Ci_C*a*"2#   *%!"{i_S*a*{3af.|W%z}4*1$0=C#C*f{\+}..e<{_C&{oNo}|}%}/

Provalo qui.

Spiegazione

Ecco l'idea di base: iniziare con un quadrato "vuoto" 112x112. Ora passa attraverso i quadrati in ordine di lettura (da sinistra a destra, dall'alto verso il basso). Aggiungi ogni quadrato nella prima posizione disponibile. Successivamente, stampa tutte le righe completate - questo ci assicura che dobbiamo solo controllare la prima (rimanente) riga per capire dove va il quadrato successivo.

La griglia vuota viene inizializzata su ps, perché avevo bisogno di un carattere con un codice carattere più grande dello spazio e #, e perché potevo riutilizzare il proprio codice carattere 112per la dimensione della griglia iniziale. Ho usato alcuni dei trucchi per l'arte ASCII di Dennis qui per riempire i quadratini nella griglia.

'p:C        e# Store the character 'p' in C.
i           e# Convert to its character code 112.
_C*a*       e# Generate a 112x112 array of p's.
"2#   *%!"  e# The 21 characters in this string correspond to the side lengths of
            e# the squares in the solution in reading order.
{           e# For each character in that string...
  i         e#   Convert to its character code (the current square's side length N).
  _S*a*     e#   Generate an NxN array of spaces.
  {         e#   Run this block 4 times. Each iteration turns the leading column into #'s
            e#   and then rotates the square by 90 degrees.
    3af.|   e#     For the first character in each row, take the bitwise OR with 3. 
            e#     This turns spaces into #'s and leaves #'s unchanged.
    W%z     e#     Reverse and transpose, which rotates by 90 degrees.
  }4*
  1$0=      e#   Copy the remaining grid and fetch the top row.
  C#        e#   Find the index of the first 'p'.
  C*        e#   Get a string of that many p's.
  f{\+}     e#   Prepend this string to each row of the small square, which gives the
            e#   square the correct horizontal position.
  ..e<      e#   Take the pairwise minimum of the square and the remaining grid. The p's
            e#   prepended to the square will leave the grid unchanged, but the spaces
            e#   and #'s in the square will overwrite the p's in the grid.
  {         e#   Map this block onto each row of the grid.
    _C&     e#     Copy the row and check if any p's are left.
    {oNo}|  e#     If NOT, the row is complete and we print it together with a newline.
            e#     This also removes the row from the grid, such that the top row for
            e#     the next iteration will have space for the next square left.
  }%
}/
— Martin Ender
fonte
9

matematica 360 426

Il codice funziona disegnando prima il quadrato perfetto dei quadrati, rasterizzando e binarizzando l'immagine, quindi convertendo 0 in "#" e 1 in "".

L'output viene restituito come normali caratteri ASCII in una tabella.

f@{n_,x_,y_}:=Rectangle[{x,y},{x+n,y+n}];t=Transpose;
Flatten[i=Rasterize[Graphics[{EdgeForm[{(*Thickness[.015],*)Black}],White,
f/@ Partition[{33,0,0,29,0,33,50,0,62,37,33,0,25,29,37,42,70,0,18,70,42,24,88,42,9,54,53,7,63,53,15,50,62,17,65,60,
11,82,66,19,93,66,35,50,77,27,85,85},3]
},ImageSize->70
],RasterSize->70]//Binarize//ImageData,1]/.{0:> "#",1:> " "};
GraphicsGrid@t@Most@Most@Rest@t[Most@Most[Rest[ArrayReshape[%,Dimensions[i]]]]]

pic1

Preferisco questo rendering, ottenuto eliminando Thickness[.015]

pic2

— DavidC
fonte
Lo spessore della linea non varia, il quadrato 50x50 è composto da 48 caratteri spaziali e 48 caratteri spaziali verso il basso, con un bordo di #'s. Si raduna contro altri quadrati a destra e in basso, che sono disegnati in modo simile. Quando due quadrati che sono #tutt'intorno all'esterno si incontrano, ottieni quindi un doppio #per le linee interne, E i quadrati sono effettivamente quadrati, hanno lo stesso numero di caratteri in verticale e in orizzontale, Il problema è il carattere. Questa risposta non è conforme alle specifiche. Se venisse accettata, la domanda verrebbe chiusa per una vittoria non obiettiva.
— Level River St
Le linee sono concepite come monodimensionali, non bidimensionali. Non devono essere interpretati come bordi con spessore. Dopotutto, stiamo partizionando una regione quadrata in sottoregioni quadrate. I confini non dovrebbero occupare alcuna area.
— DavidC,
Questo è un po 'il punto. Le linee vanno tra i quadrati e OP ha scelto di rappresentare i quadrati con bordi interni. Potrebbe essere stato più chiaro se avesse scelto di usare un simbolo diverso per ogni quadrato (e possibilmente anche riempirli.) In ogni caso, come puoi vedere dalle recenti domande sulla bandiera, la comprensione normale (e l'intero punto della complessità di Komolgorov tag) è riprodurre fedelmente la rappresentazione artistica di Ascii fornita dall'OP, non fare la tua interpretazione. Sebbene interessante, questa non è una risposta valida. Molti quadrati hanno ancora diversi numeri di caratteri in altezza e larghezza.
— Level River St
Mi ricorda Von Karman Streets
— Beta Decay
3

Rubino, 180 byte

Versione golfizzata basata sulla versione non golf di seguito. Approfittiamo del fatto che in genere ci sono 2 o 3 quadrati con lo stessoy coordinate per l'angolo in alto a sinistra.

La prima stringa magica contiene codici ASCII per square sidelength+70e y increment +40. Quando incontriamo una sidelength quadrata (codice Ascii> 67) assumiamo che il quadrato successivo sia alla stessa coordinata y, e la coordinata x può essere ottenuta incrementando la coordinata x corrente di sidelength+2. Quando incontriamo un incremento (codice Ascii <67) incrementiamo di conseguenza la coordinata y e ripristiniamo la coordinata x sulla figura codificata nella seconda stringa magica.

a=Array.new(112){?#*112}
x=y=1
j=9
'vg_CLW0SUO3J\,a]M*KV/T3n-Hi,e'.each_byte{|i|i>67?(s=i-70;(y..y+s-1).map{|i|a[i][x,s]=" "*s};x+=s+2):(x=')Fo_h){[~'[j-=1].ord-40;y+=i-40)}
puts a

Versione originale

Questa soluzione (completamente non archiviata) contiene 315 byte, escluse righe e rientri non necessari. Crea semplicemente una matrice di 112 stringhe di 112# , quindi sostituisce gli spazi interni dei quadrati.

$a=Array.new(112){"#"*112}
def f(x,y,s)
  (y..y+s-1).map{|i|$a[i][x,s]=" "*s}
end

f(1,1,48)
f(51,1,33)
f(86,1,25)

f(86,28,6)
f(94,28,17)

f(51,36,13)
f(66,36,15)
f(83,36,9)

f(83,47,4)
f(89,47,22)

f(1,51,27)
f(30,51,23)
f(55,51,7)

f(64,53,5)
f(71,53,16)

f(55,60,14)

f(71,71,40)

f(30,76,2)
f(34,76,35)

f(1,80,31)

puts $a
— Level River St
fonte
3

C, 198 byte

char*i="bSK8C?A;6HMI927B@Z4UQ",o[112][113],x,y,p,q,n;main(){for(;y<112;puts(o[y]),y++)for(x=-1;++x<112;)if(!o[y][x]){n=*i++-48;for(p=-1;++p<n;)for(q=-1;++q<n;)o[q+y][p+x]=p&&n-1-p&&q&&n-1-q?32:35;}}

(Ungolfed)

char *i="bSK8C?A;6HMI927B@Z4UQ", o[112][113], x, y, p, q, n;
main() {
  for ( ; y<112; puts(o[y]),y++) {
    for (x=-1; ++x<112; ) {
      if (!o[y][x]) {
        n = *i++ - 48;
        for (p=-1; ++p<n; ) {
          for(q=-1; ++q<n; ) {
            o[q+y][p+x] = (p && n-1-p && q && n-1-q) ? ' ' : '#';
          }
        }
      }
    }
  }
}

Tutto ciò che fa è scansionare un array di 112 × 112 byte (inizializzato su zero). Ogni volta che incontra un byte zero, recupera un valore dall'array ie aggiunge una casella della dimensione corrispondente. Il byte extra in ogni riga funge da terminatore di stringa, quindi possiamo usare puts()per emettere intere linee invece di usareputchar() per emettere caratteri singolarmente.

Probabilmente questo può essere giocato un po 'di più, ma non credo che abbia molte probabilità di battere la risposta di Steveverrill .

(collegamento ideone)

— ossifrage schizzinoso
fonte
+1 Questo è un concetto eccellente, molto meglio del mio, in un linguaggio meno golfistico. Credo che potrebbe essere in grado di battere la mia risposta. Nota che devi stampare un #quando !(p%(n-1)&&q%(n-1))vorrei anche cercare di ridurre il numero di forloop da quattro a due, usando x=i%113e y = i/113 etc.
— Level River St
3

R, 293 291 287 282 byte

a=array('#',112:113)
a[,113]='
'
for(g in list(c(0,0,49,34,26),c(27,85,7,18),c(35,50,14,16,10),c(46,82,5,23),c(50,0,28,24,8,1),c(52,63,6,17),c(59,54,15),c(70,70,41),c(75,29,3,36),c(79,0,32))){y=g[1];x=g[2]
for(b in g[0:1-2]){a[(y+2):(y+b),(x+2):(x+b)]=' '
x=x+b+1}}
cat(t(a),sep='')

Dopo averlo fatto, mi sono reso conto di aver fatto quasi lo stesso processo di @steveverrill. Una serie di '#' e oscura gli interni quadrati. Probabilmente può spremere un po 'di più da questo. Il ritorno a capo per la 3a riga è significativo. Grazie ad AlexA per alcuni.

— MickyT
fonte
sFai riferimento solo una volta, quindi non potresti fare for(g in list(...))piuttosto che specificare sseparatamente prima? Penso che ti farebbe risparmiare 2-3 byte.
— Alex A.
@AlexA. Grazie, ovvio che mi mancava totalmente
— MickyT
2

Binario MS-DOS, 137

Il seguente codice verrà eseguito in MS-DOS se lo si scrive in un file chiamato square.com, non è necessaria alcuna ulteriore compilazione (ma dato che è dato in esadecimale, è necessario "unhex" prima):

fcba8f01b82370e83000bd1400bb4d018b1743438a27b02043e81e004d75
f1b97000ba8f3289d7b00daab00aaab82409aa83ea70cd214975ecc331c9
88e189ce89d788e1f3aa83c2704e75f4c3201d30e223218527190524063d
1f11521d0d811c0f321f09921c04b8141670101b4d12176619076f1905a6
141066120e4602288d100221022300021f

L'output sarà irriconoscibile nella maggior parte dei terminali, ma è possibile reindirizzarlo a un file ( square.com > output.txt) e guardarlo in un editor di testo. Se vuoi qualcosa di più leggibile, il seguente codice produrrà un square.com funzionante se immesso in debug.exe ( debug.exe < square.asm):

a
cld
mov dx,18f
mov ax,7023
call 13a
mov bp,14
mov bx,14d
mov dx,[bx]
inc bx
inc bx
mov ah,[bx]
mov al,20
inc bx
call 13a
dec bp
jnz 110
mov cx,70
mov dx,328f
mov di,dx
mov al,d
stosb
mov al,a
stosb
mov ax,924
stosb
sub dx,70
int 21
dec cx
jnz 125
ret
xor cx,cx
mov cl,ah
mov si,cx
mov di,dx
mov cl,ah
rep stosb
add dx,70
dec si
jnz 140
ret
db 20,1d,30,e2,23,21
db 85,27,19,05,24,6
db 3d,1f,11,52,1d,d
db 81,1c,f,32,1f,9
db 92,1c,4,b8,14,16
db 70,10,1b,4d,12,17
db 66,19,7,6f,19,5
db a6,14,10,66,12,e
db 46,02,28,8d,10,2
db 21,02,23,00,02,1f

n square.com
rcx
89
w
q
— user2845840
fonte
1

Matlab / Octave, 258

Come sempre, le matrici. Ho hardcoded la riga e gli indici di colonna di ogni quadrato e le dimensioni. Posso usarli per riempire un grande quadrato 'vuoto' di #s.

r=[2,2,2,29,29,37,37,37,48,48,52,52,52,54,54,61,72,77,77,81];
c=[2,52,87,87,95,52,67,84,84,90,2,31,56,65,72,56,72,31,35,2];
s=[47,32,24,5,16,12,14,8,3,21,26,22,6,4,15,13,39,1,34,30];
z=ones(112)*35;
for i=1:20;
    z(r(i)+(0:s(i)),c(i)+(0:s(i)))=32;
end;disp([z,''])
— flawr
fonte
0

Bash, 252

Ogni codegolfer dovrebbe essere in grado di battere un algoritmo di compressione generico:

base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip

Grazie a Toby Speight per il suggerimento di usare input più brevi (mi ha usato sciocco gzipinvece che gzip -9per compressione) e una stringa qui.

— user2845840
fonte
2 più corto con qui-stringa:base64 -d<<<H4sIAP9YuVUAA+3XQQrDIBAF0H1PUfD+d+yq0FA7GirGie/vdEZfkCy0lLl5lOfJlPaKoAUIBAKBQCAQCLwzOP3mfdFVv9IKBM4BTyQpGA0PE0AgcB8wzC3A6vS7egH4d5YH64WPtVGh/zvygj8agcCvQuufzA+2GoFA4AZgd9KCwS7Hzu3B7qQFO09rbXDEaa0NjtgLCAQCgUAgEAgEAoHz34dj8wLKvMUNbzEAAA==|gunzip
— Toby Speight
E un input più breve ci porta a 251 :base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip
— Toby Speight,
Sei sicuro che funzioni? Ho solo gunzip: command not found. Posso farlo funzionare usando una subshell:, (base64 -d|gunzip)<<<...ma che utilizza ancora 258 byte.
— user2845840
Strano, @ user284584 - qualcosa di strano nel tuo percorso? Ho testato quello che ho scritto (in una shell interattiva, se questo fa la differenza)
— Toby Speight
oddio ... prova a copiare il tuo commento e incollalo nuovamente nella shell. Stackexchange "utile" ha inserito 6 caratteri invisibili, 3 ciascuno di u + 200c & u + 200b. Dopo averli rimossi, funziona.
— user2845840
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.