¿Cuántos rectángulos se pueden formar usando N cuadrados de longitud unitaria?

Answer 1

Ya se ha discutido una solución que usa programación. Intentaría proporcionar una solución matemática al problema.

Vamos a contar el número de posibles rectángulos de ancho 1 unidad.

Número total de rectángulos que tienen ancho = [matemática] N [/ matemática]

Ahora, considere ancho = 2.

Donde [math] x [/ math] representa el cuadrado de unidad adicional que se agrega.

El número total de unidades cuadradas en cualquier etapa debe ser [math] \ leq N. [/ Math]

[matemáticas] 2 ^ 2 + 2x \ leq N [/ matemáticas]

[matemáticas] x \ leq \ dfrac {N-2 ^ 2} {2} [/ matemáticas]

Por lo tanto, el número total de posibles rectángulos de ancho 2 [matemática] = \ dfrac {N-2 ^ 2} {2} +1 [/ matemática]

proporcionado [matemáticas] N \ geq 2 ^ 2. [/ matemáticas]

Deje [math] T (n, N) [/ math] representa el total de rectángulos posibles de ancho [math] n [/ math] dados [math] N [/ math] cuadrados cuadrados.

Es fácil observar que:

[matemáticas] T (n, N) = \ dfrac {Nn ^ 2} {n} +1 [/ matemáticas]

Por lo tanto, los rectángulos formados usando [math] N [/ math] unidades cuadradas = [math] \ sum_ {n = 1} ^ {\ sqrt {N}} T (n, N) [/ math]

Tenga en cuenta que el límite superior es [math] \ sqrt {N} [/ math] porque el ancho máximo que puede alcanzar es [math] \ sqrt {N}. [/ Math]

Nota: Puede usar la misma lógica para escribir un programa optimizado que será de complejidad [matemática] O (\ sqrt {N}) [/ matemática].

Answer 2

Es hora de jugar con algunos azulejos cuadrados 🙂

Primero, recordemos una cosa elemental …

¡Cada cuadrado es un rectángulo, pero no todos los rectángulos son cuadrados!

Tenga en cuenta que debemos considerar este hecho para resolver este problema.

Lo haré escribiendo un código C ++. ¡¡Vamos a rockear!!

---

#include
usando el espacio de nombres estándar;
int main ()
{
int n;
cout << "Ingrese el número de mosaicos cuadrados:";
cin >> n;
int s = n;
si (n> 3)
{
para (int i = 2; i {
para (int j = i; j {
si (i * j <= n || n * n-1 == 0)
{
s ++;
}
}
}
}
cout << "Puedes formar" << s << "Rectángulos!" << endl;
devuelve 0;
}

Veamos ahora algunos casos de prueba …

---

Supongamos que tenemos 3 azulejos cuadrados. Entonces estos son los posibles rectángulos que se pueden hacer usando 3 mosaicos cuadrados …

Entonces vemos que hay 3 rectángulos posibles. Esto es lo que obtendrás al ejecutar mi código …

---

Ahora veamos las posibilidades si tenemos 5 fichas cuadradas …

Como puede ver, hay 6 posibilidades. Y aquí está la salida de mi código …

---

Ahora te mostraré todas las posibilidades si tenemos 9 fichas cuadradas …

Si cuentas, ¡hay 13 de ellos! ¿¿¿Y adivina qué???

---

Con esto fuera del camino, veamos algunos casos de prueba más grandes …

Y eso, amigo mío, es el poder de una computadora 😉

Answer 3

Suponiendo que es una pregunta de codificación (que significa 3/2 = 1).

Digamos que el número de cuadrados unitarios dados es N.

Entonces, el número de rectángulos de “unidad” de ancho = [matemática] (digamos [/ matemática] [matemática] T (1)) = N [/ matemática]

(Teniendo en cuenta el hecho de que cada cuadrado es un rectángulo).

Ahora el número de rectángulos de ancho “2 unidades” [matemática] (digamos [/ matemática] [matemática] T (2)) = N / 2–1 [/ matemática]

(aquí 1 se resta porque el rectángulo con dimensiones 1 × 2 ya existía en caso de ancho igual a la unidad).

Del mismo modo, número de rectángulos de ancho “3 unidades” [matemática] (digamos [/ matemática] [matemática] T (3)) = N / 3 -2 [/ matemática]

(aquí se resta 2 porque los rectángulos con dimensiones 1 × 3 y 2 × 3 ya existían en el caso del ancho equivalente a 1 y 2 unidades respectivamente)

Si sigue el mismo patrón, se puede derivar una fórmula general que es

número de rectángulos de ancho “n unidades” [matemática] T (n) = N / n- (n-1) [/ matemática]

Su respuesta será [matemáticas] T (1) + T (2) + T (3) +. . . . . . . . . + T (n) [/ matemáticas]

Implementación de código simple en C ++:

#include
usando el espacio de nombres estándar;
int main ()
{
largo largo int N, n = 1, ans = 0;
cin >> N;
while (((N / n) – (n-1))> 0)
{
ans = ans + ((N / n) – (n-1));
n ++;
}

cout << ans;
devuelve 0;
}