JavaScript (ES6), 172 bytes
Sugerencia de versión más lenta pero más corta sugerida por @JonathanAllan (también guarda 4 bytes en la respuesta original):
f=(n,A,S=(n,c)=>n>=0?c(n)||S(n-1,c):0)=>S(A,w=>(F=(l,n)=>n?S(w-n,x=>S(A/w-n,y=>l.some(([X,Y,W])=>X<x+n&X+W>x&Y<y+n&Y+W>y)?0:F([...l,[x,y,n]],n-1))):A%w<1)([],n))?A:f(n,-~A)
Pruébalo en línea!
Respuesta original, 209183178174 bytes
Devuelve el norte º término de la secuencia, 1-indexados.
f=(n,A,S=(n,c)=>n>=0?c(n)||S(n-1,c):0)=>S(A,w=>A%w?0:(F=(l,n)=>n?S(w-n,x=>S(A/w-n,y=>l.some(([X,Y,W])=>X<x+n&X+W>x&Y<y+n&Y+W>y)?0:F([...l,[x,y,n]],n-1))):1)([],n))?A:f(n,-~A)
Pruébalo en línea!
Comentado
Función auxiliar
Primero definimos una función auxiliar S que invoca una función de devolución de llamada C para norte a 0 0 (ambos incluidos) y se detiene tan pronto como una llamada devuelve un valor verdadero.
S = (n, c) => // n = integer, c = callback function
n >= 0 ? // if n is greater than or equal to 0:
c(n) || // invoke c with n; stop if it's truthy
S(n - 1, c) // or go on with n - 1 if it's falsy
: // else:
0 // stop recursion and return 0
Función principal
Comenzamos con A = 1 .
Para cada par ( w , h ) tal que w × h = A , intentamos insertar todos los cuadrados de tamaño 1 × 1 a n × n (en realidad comenzando con el más grande) en el área correspondiente, de tal manera que No se superpongan entre sí.
Llevamos un registro de la lista de cuadrados con su posición ( X, Y) y su ancho W en l [ ] .
O devolvemos UN si se encontró un acuerdo válido, o lo intentamos nuevamente con A + 1 .
f = ( n, // n = input
A ) => // A = candidate area (initially undefined)
S(A, w => // for w = A to w = 0:
A % w ? // if w is not a divisor of A:
0 // do nothing
: ( // else:
F = (l, n) => // F = recursive function taking a list l[] and a size n
n ? // if n is not equal to 0:
S(w - n, x => // for x = w - n to x = 0
S(A / w - n, y => // for y = A / w - n to y = 0:
l.some( // for each square in l[]
([X, Y, W]) => // located at (X, Y) and of width W:
X < x + n & // test whether this square is overlapping
X + W > x & // with the new square of width n that we're
Y < y + n & // trying to insert at (x, y)
Y + W > y //
) ? // if some existing square does overlap:
0 // abort
: // else:
F([ ...l, // recursive call to F:
[x, y, n] // append the new square to l[]
], //
n - 1 // and decrement n
) // end of recursive call
) // end of iteration over y
) // end of iteration over x
: // else (n = 0):
1 // success: stop recursion and return 1
)([], n) // initial call to F with an empty list of squares
) ? // end of iteration over w; if it was successful:
A // return A
: // else:
f(n, -~A) // try again with A + 1
h
y mover la pruebaa%w<1
a la cola del TIO de recursión . Por supuesto que es mucho más lento. (* al menos, ¡no soy un experto en JavaScript!)