Imprimez le plus petit carré parfait

16

La quadrature du carré est un processus de pavage d'un carré en utilisant uniquement d'autres carrés. Si ce carrelage n'utilise que des carrés de tailles différentes, il est alors considéré comme parfait . Le carré carré parfait le plus petit possible est un carré de 112x112 carrelé utilisant 21 carrés différents.

J'ai créé la version art ascii de ce carré ci-dessous:

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

Votre soumission doit imprimer le carré ci-dessus. Vous pouvez imprimer une réflexion et / ou une rotation du carré ci-dessus si vous le souhaitez. Une nouvelle ligne de fin sur la dernière ligne est autorisée. Il s'agit d'un code-golf , donc la plus petite soumission gagne!

code-golf  kolmogorov-complexity 
— Nathan Merrill
source
@Optimizer Selon la question et Wikipedia, tous les petits carrés doivent être de tailles complètement différentes.
— Level River St
Nathan, ma soumission est-elle conforme aux règles? J'ai utilisé une épaisseur uniforme pour toutes les lignes.
— DavidC
@DavidCarraher J'ai chaque côté du carré décrit (donc les côtés intérieurs ont plusieurs signes de livre). En outre, vous devez utiliser à la #place deX
— Nathan Merrill
1
Nathan, Dans l'avion, les bords ne sont pas des bordures. Ce sont des segments de ligne unidimensionnels. Lorsque deux tuiles aboutent, nous devrions voir une seule ligne, pas deux. Sinon, nous véhiculons l'idée qu'il y a un écart entre les carreaux.
— DavidC
@DavidCarraher bien que cela soit vrai, je pense qu'il est plus logique de le représenter en ascii de cette façon.
— Nathan Merrill

Réponses:

4

CJam, 88 84 83 octets

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

Testez-le ici.

Explication

Voici l'idée de base: commencer avec un carré 112x112 "vide". Parcourez maintenant les carrés dans l'ordre de lecture (de gauche à droite, de haut en bas). Ajoutez chaque carré dans la première position disponible. Ensuite, imprimez toutes les lignes terminées - cela garantit que nous n'avons qu'à vérifier la première ligne (restante) pour déterminer où va le carré suivant.

La grille vide est initialisée à ps, car j'avais besoin d'un caractère avec un code de caractère plus grand que l'espace et #, et parce que je pouvais réutiliser son propre code de caractère 112pour la taille de la grille initiale. J'ai utilisé certaines des astuces artistiques ASCII de Dennis ici pour remplir les petits carrés dans la grille.

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

Mathematica 360 426

Le code fonctionne en dessinant d'abord le carré parfait de carrés, en pixellisant et en binarisant l'image, puis en convertissant 0 en "#" et 1 en "".

La sortie est renvoyée sous forme de caractères ASCII ordinaires dans une table.

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

Je préfère ce rendu, obtenu en supprimant Thickness[.015]

pic2

— DavidC
source
L'épaisseur du trait ne varie pas, le carré 50x50 est composé de 48 caractères d'espace et 48 caractères d'espace vers le bas, avec une bordure de #. Il bute contre d'autres carrés à droite et en bas, qui sont dessinés de manière similaire. Lorsque deux carrés qui ont #tout autour de l'extérieur se rencontrent, vous obtenez donc un double #pour les lignes intérieures, Et les carrés sont en effet carrés, ils ont le même nombre de caractères verticalement et horizontalement, Le problème est la police. Cette réponse n'est pas conforme à la spécification. Si elle était acceptée, la question serait close pour un gain non objectif.
— Level River St
Les lignes sont conçues comme unidimensionnelles et non bidimensionnelles. Ils ne doivent pas être interprétés comme des bordures ayant une épaisseur. Après tout, nous divisons une région carrée en sous-régions carrées. Les frontières ne devraient occuper aucun domaine.
— DavidC
C'est un peu le point. Les lignes vont entre les carrés , et OP a choisi de représenter les carrés avec des bordures internes. Il aurait peut-être été plus clair s'il avait choisi d'utiliser un symbole différent pour chaque carré (et peut-être aussi de les remplir). tag) est de reproduire fidèlement la représentation artistique Ascii fournie par le PO, pas de faire votre propre interprétation. Bien qu'intéressant, ce n'est pas une réponse valable. De nombreux carrés ont toujours un nombre différent de caractères dans leur hauteur et leur largeur.
— Level River St
Me rappelle les rues Von Karman
— Beta Decay
3

Rubis, 180 octets

Version golfée basée sur la version non golfée ci-dessous. Nous profitons du fait qu'il y a généralement 2 ou 3 carrés avec le mêmey coordonnée pour le coin supérieur gauche.

La première chaîne magique contient des codes ASCII pour le square sidelength+70et y increment +40. Lorsque vous rencontrez une longueur latérale carrée (code Ascii> 67), nous supposons que le carré suivant est à la même coordonnée y, et la coordonnée x peut être obtenue en incrémentant la coordonnée x actuelle de sidelength+2. Lorsque vous rencontrez l'incrémentation ay (code Ascii <67), nous incrémentons la coordonnée y en conséquence et réinitialisons la coordonnée x sur le chiffre encodé dans la deuxième chaîne magique.

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

Version originale

Cette solution (totalement non gérée) contient 315 octets, à l'exclusion des lignes vierges et des retraits inutiles. Il crée simplement un tableau de 112 chaînes de 112 #, puis remplace l'intérieur des carrés par des espaces.

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

C, 198 octets

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

(Non golfé)

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

Il suffit de parcourir un tableau de 112 × 112 octets (initialisé à zéro). Chaque fois qu'il rencontre un octet zéro, il récupère une valeur du tableau iet ajoute une boîte de la taille correspondante. L'octet supplémentaire dans chaque ligne agit comme un terminateur de chaîne afin que nous puissions utiliser puts()pour produire des lignes entières au lieu d'utiliserputchar() pour générer des caractères individuellement.

Cela peut probablement être joué un peu plus, mais je ne pense pas que cela ait beaucoup de chances de battre la réponse de steveverrill .

(lien idéone)

— ossifrage délicat
source
+1 C'est un excellent concept, bien meilleur que le mien, dans une langue moins golfique. Je pense que cela pourrait battre ma réponse. Notez que vous devez imprimer un #lorsque !(p%(n-1)&&q%(n-1))je chercherais également à réduire le nombre de forboucles de quatre à deux, en utilisant x=i%113et y = i/113 etc.
— Level River St
3

R, 293 291 287 282 octets

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

Après avoir fait cela, j'ai réalisé que j'avais fait presque le même processus que @steveverrill. Un tableau de '#' et videz les intérieurs carrés. Peut probablement en tirer un peu plus. Le retour chariot pour la 3ème ligne est significatif. Merci à AlexA pour quelques-uns.

— MickyT
source
Vous ne sfaites référence qu'une seule fois, alors ne pourriez-vous pas faire for(g in list(...))plutôt que de spécifier sséparément à l'avance? Je pense que cela vous ferait économiser 2-3 octets.
— Alex A.
@AlexA. Merci, une évidence qui m'a totalement manqué
— MickyT
2

Binaire MS-DOS, 137

Le code suivant s'exécutera dans MS-DOS si vous l'écrivez dans un fichier appelé square.com, aucune autre compilation n'est requise (mais comme il est donné en hexadécimal, vous devez d'abord le "décocher"):

fcba8f01b82370e83000bd1400bb4d018b1743438a27b02043e81e004d75
f1b97000ba8f3289d7b00daab00aaab82409aa83ea70cd214975ecc331c9
88e189ce89d788e1f3aa83c2704e75f4c3201d30e223218527190524063d
1f11521d0d811c0f321f09921c04b8141670101b4d12176619076f1905a6
141066120e4602288d100221022300021f

La sortie sera méconnaissable dans la plupart des terminaux, mais vous pouvez la rediriger vers un fichier ( square.com > output.txt) et la regarder dans un éditeur de texte. Si vous voulez quelque chose de plus lisible, le code suivant produira un square.com fonctionnel s'il est introduit dans 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
source
1

Matlab / Octave, 258

Comme toujours, Matrices. J'ai codé en dur la ligne et les indices de colonne de chaque carré ainsi que la taille. Je peux les utiliser pour remplir un grand carré «vide» de #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
source
0

Bash, 252

Chaque codegolfer devrait être capable de battre un algorithme de compression à usage général:

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

Merci à Toby Speight pour le conseil d'utiliser une entrée plus courte (idiot, j'ai utilisé à la gzipplace de la gzip -9compression) et une chaîne ici.

— user2845840
source
2 plus court avec ici-string:base64 -d<<<H4sIAP9YuVUAA+3XQQrDIBAF0H1PUfD+d+yq0FA7GirGie/vdEZfkCy0lLl5lOfJlPaKoAUIBAKBQCAQCLwzOP3mfdFVv9IKBM4BTyQpGA0PE0AgcB8wzC3A6vS7egH4d5YH64WPtVGh/zvygj8agcCvQuufzA+2GoFA4AZgd9KCwS7Hzu3B7qQFO09rbXDEaa0NjtgLCAQCgUAgEAgEAoHz34dj8wLKvMUNbzEAAA==|gunzip
— Toby Speight
Et une entrée plus courte nous ramène à 251 :base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip
— Toby Speight
Êtes-vous sûr que cela fonctionne? Je reçois seulement gunzip: command not found. Je peux le faire fonctionner en utilisant un sous-shell:, (base64 -d|gunzip)<<<...mais cela utilise toujours 258 octets.
— user2845840
Étrange, @ user284584 - quelque chose d'étrange avec votre chemin? J'ai testé ce que j'ai écrit (dans un shell interactif, si cela fait une différence)
— Toby Speight
oh mon dieu ... essayez de copier votre commentaire et de le coller dans la coquille. Stackexchange a inséré "utilement" 6 caractères invisibles, 3 chacun de u + 200c et u + 200b. Après les avoir retirés, cela fonctionne.
— user2845840
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.