Partitionnez un n X ncarré en plusieurs rectangles à côtés entiers non congruents. a(n)est la plus petite différence possible entre la plus grande et la plus petite zone.

 ___________
| |S|_______|
| | |   L   |
| |_|_______|
| |     |   |
| |_____|___|
|_|_________| (fig. I)

Le plus grand rectangle ( L) a une aire de 2 * 4 = 8et le plus petit rectangle ( S) a une aire de 1 * 3 = 3. Par conséquent, la différence est 8 - 3 = 5.

Étant donné un entier n>2, affichez la différence la moins possible.

Toutes les valeurs connues de la séquence au moment de la publication:

2, 4, 4, 5, 5, 6, 6, 8, 6, 7, 8, 6, 8, 8, 8, 8, 8, 9, 9, 9, 8, 9, 10, 9, 10, 9, 9, 11, 11, 10, 12, 12, 11, 12, 11, 10, 11, 12, 13, 12, 12, 12

Alors a(3)=2, a(4)=4...

OEIS A276523

Liés - ce défi connexe permet des solutions non optimales, a des contraintes de temps et n'est pas du code-golf.

Pour plus d'informations, regardez cette vidéo de Numberphile

CJam, 178

ri_1a*a*L{_:+1&{_[3{_\zW%}*]{_z}%:e<_@={:A0=_1#:X0<{;A1>j}{X>0+0#AzX=0+0#,\,m*1ff+{[_$\~1a*0aX*\+a*A\..-_])s'-&{;}&}%{~j\:X;{Xa&!},Xaf+:$~}%_&}?}{j}?}{;La}?}j{,(},{::*$)\0=-}%:e<

Essayez-le en ligne . C'est très lent cependant, je ne recommanderais pas d'aller au-dessus de 6.

Pour vérifier qu'il fait vraiment le travail, vous pouvez vérifier ce programme légèrement modifié qui imprime toutes les partitions possibles (chaque partition est affichée sous la forme d'un tableau de paires de dimensions rectangulaires).

Befunge, 708 octets

p&>:10p1-:>20p10g:20g\`v`\g02:-1\p00+1g<>g-#v_10g:*30p"~":40p50p060p070p$>^
1#+\#1<\1_^# !`0::-1$  _:00g3p\:00g2p00^^00:>#:


>>:2-#v_$30p50p60p70g1-70p
^<<<<<:#<<<<<<$$$_v#:!g87g78g79$  _v#!\-1:g88$<_ 98p87g97g*00 v:+!\`*84g++7<
^>$1-:77p1g:2g\3g1>78p97p87p10g97g->88p10g87g-0^!\-1:g89_v#-!\_$1-:v>/88g+7^
^|!-3$<   >\87g/88g+77++p:#v_$
^>:5->v   ^+g89%g78:\g77:-1<>98g88g48*577g387g97g98g88v ^>77g87g97v:^g78\+g<
^ v-4:_$77p88p98p:97p\:87p*^^g79g7>#8\#$_40pv5+"A"g77g< ^14g88g89g<>:87g%98^
^v_$88p98p97p87p:77p60g50g-:40g\`#^_$$>>>>>>>
 >#4!_::80p2g\3g*:90p30g`!v>>>#@>#.>#g^#0
^v:g06p03:-g09\2:g03g05g06_^^_7#<0#<g#<3#<1#<<`g04_$00g1->:#-8#10#\g#1`#:_>$
^>90g\-:0`*+:60p50g:90g-:0`*-:50p-80g70g:1+70p1p\!^

Essayez-le en ligne!

Cela ne va évidemment pas gagner de prix pour la taille, mais c'est en fait assez rapide étant donné qu'il s'agit d'une implémentation de base de force bruce dans un langage ésotérique. Sur l'interpréteur de référence Befunge, il peut gérer jusqu'à n = 6 en quelques secondes. Avec un compilateur, il peut gérer jusqu'à n = 8 avant de commencer à devenir lent; n = 9 prend quelques minutes et n = 10 est proche de 2 heures.

En théorie, la limite supérieure est n = 11 avant de manquer de mémoire (c'est-à-dire qu'il n'y a pas assez d'espace laissé dans le champ de jeu pour s'adapter à un carré plus grand). Cependant, à ce stade, le temps nécessaire pour calculer la solution optimale est probablement plus long que quiconque serait prêt à attendre, même lors de la compilation.

La meilleure façon de voir comment fonctionne l'algorithme est de l'exécuter dans l'un des "débogueurs visuels" Befunge. De cette façon, vous pouvez regarder pendant qu'il tente d'adapter les différentes tailles de rectangle dans l'espace disponible. Si vous voulez "avancer rapidement" au point où il a une bonne correspondance, vous pouvez placer un point d'arrêt sur le 4dans la séquence $_40pprès du milieu de la dixième ligne (9 s'il est basé sur zéro). La valeur en haut de la pile à ce point est la différence de zone actuelle.

Ci-dessous, une animation montrant les premières images de ce processus pour n = 5:

Chaque rectangle distinct est représenté par une lettre différente de l'alphabet. Cependant, notez que le rectangle final n'est jamais écrit, de sorte que la section du carré sera simplement vide.

J'ai également écrit une version de débogage du code qui génère la disposition actuelle chaque fois qu'il trouve une nouvelle meilleure correspondance ( essayez-le en ligne! ). Pour les tailles plus petites, la première correspondance est souvent la solution optimale, mais une fois que vous aurez dépassé n = 6, vous aurez probablement la possibilité de voir plusieurs dispositions valides mais non optimales avant de se fixer sur la solution finale.

La meilleure disposition trouvée pour n = 10 ressemble à ceci:

H F F F A A A C C I
H F F F A A A C C I
H J G G A A A C C I
H J G G A A A C C I
H J D D D D D C C I
H J D D D D D C C I
H J K K K K K K K I
H J B B B E E E E I
H J B B B E E E E I
H J B B B L L L L L

12 - 4 = 8