Drucken Sie das kleinste quadratische Quadrat aus

16

Beim Quadrieren des Quadrats werden nur andere Quadrate nebeneinander angeordnet. Wenn für diese Kacheln nur Quadrate unterschiedlicher Größe verwendet werden, gilt dies als perfekt . Das kleinstmögliche Quadrat mit den perfekten Quadraten ist ein 112 x 112-Quadrat, das aus 21 verschiedenen Quadraten zusammengesetzt ist.

Ich habe die ASCII-Kunstversion dieses Quadrats unten erstellt:

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

Ihr Beitrag sollte das obige Quadrat ausdrucken. Sie können eine Reflexion und / oder Drehung des obigen Quadrats drucken, wenn Sie möchten. Ein abschließender Zeilenumbruch in der letzten Zeile ist zulässig. Dies ist ein Code-Golf , also gewinnt die kleinste Einreichung!

code-golf  kolmogorov-complexity 
— Nathan Merrill
quelle
@Optimizer Entsprechend der Frage und der Wikipedia müssen alle kleinen Quadrate völlig unterschiedliche Größen haben.
— Level River St
Nathan, stimmt meine Einreichung mit den Regeln überein? Ich habe für alle Linien eine einheitliche Stärke verwendet.
— DavidC
@ DavidCarraher Ich habe jede Seite des Quadrats umrissen (so haben Innenseiten mehrere Pfund-Zeichen). Außerdem müssen Sie #anstelle von verwendenX
— Nathan Merrill
1
Nathan, In der Ebene sind Kanten keine Grenzen. Sie sind eindimensionale Liniensegmente. Wo zwei Kacheln aneinander stoßen, sollten wir eine einzige Linie sehen, nicht zwei. Ansonsten vermitteln wir die Idee, dass es eine Lücke zwischen den Fliesen gibt.
— DavidC
@ DavidCarraher während das wahr ist, denke ich, dass es sinnvoller ist, es auf diese Weise in ASCII darzustellen.
— Nathan Merrill

Antworten:

4

CJam, 88 84 83 Bytes

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

Teste es hier.

Erläuterung

Hier ist die Grundidee: Beginnen Sie mit einem "leeren" 112x112-Quadrat. Gehen Sie nun die Quadrate in Lesereihenfolge durch (von links nach rechts, von oben nach unten). Addiere jedes Quadrat zu der ersten verfügbaren Position. Drucken Sie anschließend alle ausgefüllten Zeilen aus - dies stellt sicher, dass wir nur die erste (verbleibende) Zeile überprüfen müssen, um herauszufinden, wohin das nächste Quadrat führt.

Das leere Gitter wird mit ps initialisiert , weil ich ein Zeichen mit einem Zeichencode benötige, der größer als Leerzeichen ist #, und weil ich einen eigenen Zeichencode 112für die Größe des anfänglichen Gitters wiederverwenden kann . Ich habe hier einige von Dennis 'ASCII-Kunsttricks verwendet , um die kleinen Quadrate in das Raster zu füllen.

'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
quelle
9

Mathematica 360 426

Der Code zeichnet zunächst das perfekte Quadrat aus Quadraten, rastert und digitalisiert das Bild und konvertiert dann 0 in "#" und 1 in "".

Die Ausgabe wird als normale ASCII-Zeichen in einer Tabelle zurückgegeben.

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

Ich bevorzuge dieses Rendering, das durch Löschen erhalten wird Thickness[.015]

pic2

— DavidC
quelle
Die Linienstärke ändert sich nicht. Das 50x50-Quadrat ist 48 Leerzeichen breit und 48 Leerzeichen tief, mit einem Rand von #'s. Es stößt rechts und unten an andere Quadrate, die auf ähnliche Weise gezeichnet sind. Wenn sich zwei Quadrate #treffen, die sich ringsum treffen, erhalten Sie also ein Doppel #für Innenlinien. Und die Quadrate sind in der Tat quadratisch, sie haben die gleiche Anzahl von Zeichen vertikal und horizontal. Das Problem ist die Schriftart. Diese Antwort entspricht nicht der Spezifikation. Wenn sie akzeptiert wird, wird die Frage für einen nicht objektiven Gewinn geschlossen.
— Level River St
Die Linien sind eindimensional und nicht zweidimensional. Sie sind nicht als dicke Ränder zu interpretieren. Schließlich unterteilen wir eine quadratische Region in quadratische Teilregionen. Die Grenzen sollten keinen Bereich einnehmen.
— DavidC
Das ist irgendwie der Punkt. Die Linien verlaufen zwischen den Quadraten , und OP hat ausgewählt, die Quadrate mit Innenrändern darzustellen. Es wäre vielleicht klarer gewesen, wenn er für jedes Quadrat ein anderes Symbol verwendet hätte (und möglicherweise auch ausgefüllt hätte). Wie Sie aus den letzten Fragen zur Flagge ersehen können, ist das übliche Verständnis (und der ganze Sinn der Komolgorov-Komplexität) auf jeden Fall klar Tag) ist die originalgetreue Reproduktion der vom OP gelieferten ASCII-Kunstdarstellung, nicht Ihre eigene Interpretation. Dies ist zwar interessant, aber keine gültige Antwort. Viele Quadrate haben immer noch eine unterschiedliche Anzahl von Zeichen in Höhe und Breite.
— Level River St
Erinnert mich an Von Karman Streets
— Beta Decay
3

Ruby, 180 Bytes

Golf-Version basierend auf der ungolfed Version unten. Wir machen uns die Tatsache zunutze, dass es yfür die linke obere Ecke normalerweise zwei oder drei Quadrate mit der gleichen Koordinate gibt.

Die erste magische Zeichenfolge enthält ASCII-Codes für square sidelength+70und y increment +40. Bei einer quadratischen Seitenlänge (ASCII-Code> 67) wird angenommen, dass sich das nächste Quadrat auf derselben y-Koordinate befindet und die x-Koordinate durch Inkrementieren der aktuellen x-Koordinate um erhalten werden kann sidelength+2. Bei einem y-Inkrement (ASCII-Code <67) erhöhen wir die y-Koordinate entsprechend und setzen die x-Koordinate auf die in der zweiten magischen Zeichenfolge codierte Zahl zurück.

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

Originalfassung

Diese (vollständig ungolfed) Lösung enthält 315 Bytes ohne unnötige Leerzeilen und Einrückungen. Es erstellt einfach ein Array von 112 Zeichenfolgen mit 112 #Zeichen und ersetzt dann die Innenseiten der Quadrate durch Leerzeichen.

$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
quelle
3

C 198 Bytes

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) ? ' ' : '#';
          }
        }
      }
    }
  }
}

Alles, was dies tut, ist das Durchsuchen eines Arrays von 112 × 112 Bytes (initialisiert auf Null). Immer wenn es auf ein Null-Byte stößt, ruft es einen Wert aus dem Array ab iund fügt eine Box der entsprechenden Größe hinzu. Das zusätzliche Byte in jeder Zeile fungiert als Zeichenfolgenabschluss, sodass wir puts()ganze Zeilen ausgeben können, anstatt putchar()Zeichen einzeln auszugeben.

Dies kann wahrscheinlich ein wenig mehr Golf gespielt werden, aber ich glaube nicht, dass es eine große Chance gibt, Steveverrills Antwort zu schlagen .

(ideone link)

— zimperliches Ossifrage
quelle
+1 Dies ist ein exzellentes Konzept, weitaus besser als meins, in einer weniger Golfsprache. Ich glaube, es könnte meine Antwort übertreffen. Beachten Sie, dass Sie ein ausgeben müssen, #wenn !(p%(n-1)&&q%(n-1))ich auch die Anzahl der forSchleifen mit x=i%113und y = von vier auf zwei reduzieren möchte i/113 etc.
— Level River St
3

R 293 291 287 282 Bytes

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

Nachdem ich dies getan hatte, stellte ich fest, dass ich fast den gleichen Prozess wie @steveverrill durchgeführt hatte. Eine Reihe von '#' und leer die quadratischen Innenräume. Kann wahrscheinlich noch mehr herausholen. Der Wagenrücklauf für die 3. Zeile ist signifikant. Vielen Dank an AlexA für ein paar.

— MickyT
quelle
Sie referenzieren nur seinmal, können Sie es also nicht tun, for(g in list(...))anstatt es svorher separat zu spezifizieren ? Ich denke, das würde Ihnen 2-3 Bytes sparen.
— Alex A.
@AlexA. Vielen Dank, eine offensichtliche, die ich völlig vermisst habe
— MickyT
2

MS-DOS Binary, 137

Der folgende Code wird unter MS-DOS ausgeführt, wenn Sie ihn in eine Datei mit dem Namen square.com schreiben. Eine weitere Kompilierung ist nicht erforderlich.

fcba8f01b82370e83000bd1400bb4d018b1743438a27b02043e81e004d75
f1b97000ba8f3289d7b00daab00aaab82409aa83ea70cd214975ecc331c9
88e189ce89d788e1f3aa83c2704e75f4c3201d30e223218527190524063d
1f11521d0d811c0f321f09921c04b8141670101b4d12176619076f1905a6
141066120e4602288d100221022300021f

Die Ausgabe ist in den meisten Terminals nicht erkennbar, Sie können sie jedoch in eine Datei umleiten ( square.com > output.txt) und in einem Texteditor anzeigen. Wenn Sie etwas besser lesbares wollen, erzeugt der folgende Code eine funktionierende square.com, wenn er in debug.exe ( debug.exe < square.asm) eingegeben wird :

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
quelle
1

Matlab / Octave, 258

Wie immer Matrizen. Ich habe die Zeilen- und Spaltenindizes jedes Quadrats und die Größe fest codiert. Ich kann diese verwenden, um ein großes 'leeres' Quadrat von #s auszufüllen .

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,''])
— fehlerhaft
quelle
0

Bash, 252

Jeder Codegolfer sollte in der Lage sein, einen allgemeinen Komprimierungsalgorithmus zu übertreffen:

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

Vielen Dank an Toby Speight für den Hinweis, dass er kürzere Eingaben (dummes Ich gzipanstelle von gzip -9Komprimierung) und einen Here-String verwendet.

— user2845840
quelle
2 kürzer mit Here-String:base64 -d<<<H4sIAP9YuVUAA+3XQQrDIBAF0H1PUfD+d+yq0FA7GirGie/vdEZfkCy0lLl5lOfJlPaKoAUIBAKBQCAQCLwzOP3mfdFVv9IKBM4BTyQpGA0PE0AgcB8wzC3A6vS7egH4d5YH64WPtVGh/zvygj8agcCvQuufzA+2GoFA4AZgd9KCwS7Hzu3B7qQFO09rbXDEaa0NjtgLCAQCgUAgEAgEAoHz34dj8wLKvMUNbzEAAA==|gunzip
— Toby Speight
Und eine kürzere Eingabe bringt uns auf 251 :base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip
— Toby Speight
Sind Sie sicher, dass das funktioniert? Ich verstehe nur gunzip: command not found. Ich kann es mit einer Subshell zum Laufen bringen:, (base64 -d|gunzip)<<<...aber das verbraucht immer noch 258 Bytes.
— User2845840
Seltsam, @ user284584 - etwas seltsames mit Ihrem Weg? Ich habe getestet, was ich geschrieben habe (in einer interaktiven Shell, wenn das einen Unterschied macht)
— Toby Speight
Oh Gott ... versuchen Sie, Ihren Kommentar zu kopieren und wieder in die Shell einzufügen. Stackexchange fügte "hilfreich" 6 unsichtbare Zeichen ein, je 3 von u + 200c & u + 200b. Nach dem Entfernen funktioniert es.
— User2845840
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.