Partizionare un n X nquadrato in più rettangoli a lato intero non congruenti. a(n)è la minima differenza possibile tra l'area più grande e quella più piccola.

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

Il rettangolo più grande ( L) ha un'area di 2 * 4 = 8e il rettangolo più piccolo ( S) ha un'area di 1 * 3 = 3. Pertanto, la differenza è 8 - 3 = 5.

Dato un numero intero n>2, genera la differenza il meno possibile.

Tutti i valori noti della sequenza al momento della pubblicazione:

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

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

OEIS A276523

Correlata : questa sfida correlata consente soluzioni non ottimali, ha vincoli di tempo e non è golf di codice.

Per ulteriori informazioni, guarda questo video di 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<

Provalo online . È molto lento però, non consiglierei di andare sopra i 6.

Per verificare che stia davvero facendo il lavoro, puoi controllare questo programma leggermente modificato che stampa tutte le possibili partizioni (ogni partizione viene mostrata come una matrice di coppie di dimensioni rettangolari).

Befunge, 708 byte

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\!^

Provalo online!

Questo ovviamente non vincerà alcun premio in termini di dimensioni, ma in realtà è ragionevolmente veloce considerando che è un'implementazione di base della forza bruce in un linguaggio esoterico. Sull'interprete di riferimento Befunge può gestire fino a n = 6 in un paio di secondi. Con un compilatore può gestire fino a n = 8 prima che inizi a diventare lento; n = 9 richiede un paio di minuti e n = 10 è vicino per 2 ore.

In teoria il limite superiore è n = 11 prima di esaurire la memoria (ovvero non c'è abbastanza spazio nel campo di gioco per adattarsi a un quadrato più grande). Tuttavia, a quel punto, il tempo impiegato per calcolare la soluzione ottimale è probabilmente più lungo di quanto chiunque sia disposto ad aspettare, anche se compilato.

Il modo migliore per vedere come funziona l'algoritmo è eseguirlo in uno dei "debugger visivi" di Befunge. In questo modo puoi guardare mentre tenta di adattare le varie dimensioni del rettangolo allo spazio disponibile. Se vuoi "avanzare rapidamente" fino al punto in cui ha una buona corrispondenza, puoi mettere un punto di interruzione 4nella sequenza$_40p vicino al centro della decima riga (9 se in base zero). Il valore nella parte superiore della pila in quel punto è la differenza di area corrente.

Di seguito è un'animazione che mostra i primi pochi fotogrammi di questo processo per n = 5:

Ogni rettangolo distinto è rappresentato da una diversa lettera dell'alfabeto. Tuttavia, tieni presente che il rettangolo finale non viene mai scritto, quindi la sezione del quadrato sarà vuota.

Ho anche scritto una versione di debug del codice che genera il layout corrente ogni volta che trova una nuova migliore corrispondenza ( Provalo online! ). Per le dimensioni più piccole, la prima corrispondenza è spesso la soluzione ottimale, ma una volta superati n = 6 probabilmente vedrai diversi layout validi ma non ottimali prima che si stabilizzi sulla soluzione finale.

Il miglior layout trovato per n = 10 è simile al seguente:

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