Triángulo de Pascal: fórmula, patrones y ejemplos
sarah chen
¿Qué es el triángulo de Pascal?
El Triángulo de Pascal es una matriz triangular de números seguida de un patrón particular y una conexión con la fila anterior. Fue inventado por Blaise Pascal. Este triángulo comienza con un elemento en la primera fila. Después de eso, cada fila comienza y termina con "1".
Historia del triángulo de Pascal
El libro chino "Los nueve capítulos del arte matemático" contiene uno de los primeros ejemplos del triángulo de Pascal. Además, contiene algunos de los mismos patrones y cualidades que se encuentran en los triángulos actuales.
Pascal fue una de las varias personas en Europa que estudiaron el triángulo. Otros matemáticos habían examinado conjuntos triangulares similares de números antes que él.
Construcción del Triángulo de Pascal
Construir el Triángulo de Pascal es sencillo. Lo único que debes recordar es que la Fila comienza y termina en 1. La regla para el resto de números es la siguiente:
Para cualquier fila r y columna c, el número será la suma de las columnas c-1 yc de la fila r-1.
Aquí,
- r = 3,4,5….
- n y c = 2,3,4,…r-1.
Estos son los pasos para construir el Triángulo de Pascal:
Paso 1) Comencemos llenando dos filas.
Paso 2) El segundo elemento de la tercera línea es la suma del primer y segundo número de la segunda fila.
Paso 3) La cuarta fila comenzará con “1”. El segundo número es 3, que es la suma de 1 y 2 (resaltado en azul).
La siguiente imagen muestra cómo llenar la cuarta fila:
Paso 4) La quinta fila constará de cinco números. Ya conocemos el patrón para completar las filas de los pasos anteriores.
Fórmula del triángulo de Pascal – Coeficiente binomial
Un coeficiente binomial es un número que expresa diferentes métodos para seleccionar un subconjunto de k elementos de una colección de n elementos. Con frecuencia, se escribe como “C(n,k)” o “n elige k”.
El coeficiente binomial se define como
El "!" denota el "factorial".
¡norte! = n.(n-1). (n-2)…3.2.1
Por ejemplo,
5! = 5.4.3.2.1
= 120
Entonces, digamos C(5,3) o 5, ¡elija 3 = 5! / 3!(5-3)!
= 120/(12)
= 10
Método 1: construir el triángulo de Pascal a partir de la fila anterior
Los pasos de este procedimiento son los mismos que los del triángulo de Pascal. Digamos que queremos crear el triángulo de Pascal hasta siete filas.
Los pasos para lograrlo son los siguientes:
Paso 1) Comience la fila superior con "1".
Paso 2) Para la fila “r”, el elemento “c” será el producto de “c-1” y “c” el número de la fila “r-1”.
Paso 3) El primer y último número de una fila siempre será “1”.
Debemos seguir estos tres sencillos pasos para crear el triángulo de Pascal.
C++ Código del Triángulo de Pascal por la fila anterior
#include <bits/stdc++.h>
using namespace std;
void printRow(int n)
{
int numbers[n][n];
for (int row = 0; row < n; row++)
{
for (int col = 0; col <= row; col++)
{
if (col == 0 || col == row)
{
numbers[row][col] = 1;
}
else
{
numbers[row][col] = numbers[row - 1][col - 1] + numbers[row - 1][col];
}
cout << numbers[row][col] << "\t";
}
cout << endl;
}
}
int main()
{
int n;
cout << "How many rows: ";
cin >> n;
printRow(n);
}
Salida:
How many rows: 7 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1
Python Código de la fórmula del triángulo de Pascal por la fila anterior
def printRow(n):
numbers = [[0 for row in range(n)]
for col in range(n)
]
for row in range(len(numbers)):
for col in range(0, row+1):
if row == col or col == 0:
numbers[row][col] = 1
else:
numbers[row][col] = numbers[row-1][col-1]+numbers[row-1][col]
print(numbers[row][col],end="\t")
print("\n")
n = int(input("How many rows: "))
printRow(n)
Resultado del ejemplo del triángulo de Pascal:
How many rows: 7 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1
Análisis de complejidad
A matriz bidimensional se utilizó en la implementación. Dado que N es el número de filas del triángulo de Pascal. Esto requerirá N2 espacios unitarios. Por lo tanto, O será la complejidad espacial (N2).
Tenemos dos bucles en la función y cada bucle se ejecuta “N” veces. Por lo tanto, la complejidad temporal también es EN2) o complejidad de tiempo al cuadrado.
Método 2: construir el triángulo de Pascal calculando el coeficiente binomial
Podemos derivar de manera sencilla los números del triángulo de Pascal utilizando el coeficiente binomial. Aquí está el diagrama:
Estos son los pasos para construir el Triángulo de Pascal calculando el Binomio:
Paso 1) La fila superior será C(0,0). Usando la fórmula anterior para el coeficiente binomial, C(0,0) = 1. ¡Porque 0! = 1.
Paso 2) Para la fila "i", habrá un total de elementos "i". Cada elemento se calculará C(n,r) donde n será i-1.
Paso 3) Repita el paso 2 para la cantidad de filas que desee para el triángulo de Pascal.
C++ Codificar el triángulo de Pascal mediante coeficiente binomial
#include <iostream>
using namespace std;
int factorial(int n)
{
int result = 1;
for (int i = 1; i <= n; i++)
{
result *= i;
}
return result;
}
int binomialCoefficient(int n, int r)
{
int result = 1;
if (r > n)
{
return -1;
}
result = factorial(n) / (factorial(r) * factorial(n - r));
return result;
}
void printPascalTriangle(int row)
{
for (int i = 0; i <= row; i++)
{
for (int j = 0; j <= i; j++)
{
cout << binomialCoefficient(i, j) << "\t";
}
cout << endl;
}
}
int main()
{
int n;
cout << "Enter row number: ";
cin >> n;
printPascalTriangle(n);
}
Salida:
Enter row number: 9 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1
Python Codificar el triángulo de Pascal mediante coeficiente binomial
def factorial(n):
result = 1
for i in range(1,n+1):
result*=i
return result
def binomialCoefficient(n,r):
result =1
if r>n:
return None
result = factorial(n) / (factorial(r) * factorial(n - r))
return int(result)
def printPascalTriangle(row):
for i in range(row+1):
for j in range(i+1):
print(binomialCoefficient(i, j), end="\t")
print()
# print(binomialCoefficient(3, 2))
n = int(input("Enter row number: "))
printPascalTriangle(n)
Resultado del ejemplo del triángulo de Pascal:
Enter row number: 8 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1
Análisis de complejidad
En la implementación se utilizaron tres bucles. Un bucle sirve para calcular el coeficiente binomial y los otros dos para crear números para todas las filas. En cuanto al número de filas, tenemos tres bucles que se ejecutan “n” veces. En consecuencia, la complejidad temporal total será 0(n3).
La complejidad espacial ahora es constante porque no guardamos ningún dato en el almacenamiento. El programa calcula el elemento y lo imprime en una fila. La complejidad espacial luego disminuye a 0(1).
Método 3: construir el triángulo de Pascal mediante el coeficiente binomial modificado
En la técnica anterior ya hemos visto cómo utilizar un coeficiente binomial para calcular cada elemento del triángulo de Pascal. Este enfoque determinará C(n,r) a partir de C. (n, r-1). Simplificará las cosas en un orden.
Estos son los pasos para construir el triángulo de Pascal mediante el coeficiente binomial modificado:
Paso 1) Inicie la primera fila con "1"
Paso 2) Calcule C (n, r), donde "n" es el número de fila y "r" es la columna o el elemento. Asigne el valor en una variable C.
Paso 3) Para calcular C(n,k), será C*(n-k)/k. Ahora, asigna este valor a C.
Paso 4) Continúe el paso 3 hasta que "k" llegue al final de la fila. Después de cada iteración, incremente el valor de K en uno.
C++ Código para el triángulo de Pascal por coeficiente binomial modificado
#include <bits/stdc++.h>
using namespace std;
void printpascalTriangle(int n)
{
for (int row = 1; row <= n; row++)
{
int previous_coef = 1;
for (int col = 1; col <= row; col++)
{
cout << previous_coef << "\t";
previous_coef = previous_coef * (row - col) / col;
}
cout << endl;
}
}
int main()
{
int n;
cout << "How many rows: ";
cin >> n;
printpascalTriangle(n);
}
Salida:
How many rows: 5 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1
Python código para el triángulo de Pascal por coeficiente binomial modificado
def printpascalTriangle(n):
for row in range(1, n+1):
previous_coef = 1
for col in range(1, row+1):
print(previous_coef, end="\t")
previous_coef = int(previous_coef*(row-col)/col)
print()
n = int(input("How many rows: "))
printpascalTriangle(n)
Resultado de los patrones de triángulos de Pascal:
How many rows: 5 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1
Análisis de complejidad
La implementación tiene dos bucles. Cada bucle se ejecuta un máximo de “n” veces, donde “n” significa el número de filas en el triángulo de Pascal. Por lo tanto, la complejidad temporal es En2), tiempo al cuadrado.
En cuanto a la complejidad espacial, no necesitamos ninguna matriz para almacenar. Solo usamos una variable para mantener el coeficiente binomial anterior. Por lo tanto, solo necesitamos un espacio adicional. La complejidad espacial se convirtió en O (1).
Aplicación del Triángulo de Pascal
A continuación se muestran algunas aplicaciones del Triángulo de Pascal:
Expansiones binomiales: Podemos determinar el coeficiente de las expansiones binomiales a partir del triángulo de Pascal. He aquí un ejemplo:
| (x+y)0 | 1 |
| (x+y)1 | 1.x+ 1.y |
| (x+y)2 | 1x2 + 2xy + 1y2 |
| (x+y)3 | 1x3 + 3x2y + 3xy2 + 1y3 |
| (x+y)4 | 1x4 + 4x3y + 6x2y2 + 4xy3 + 1y4 |
Calcular combinaciones: Hemos visto que los elementos del triángulo de Pascal son equivalentes a coeficientes binomiales. Por ejemplo, si tienes 6 bolas y te han pedido que elijas 3 bolas, será 6C3. O puede encontrar el número en el tercer elemento de la sexta fila del triángulo de Pascal.
Datos interesantes sobre el triángulo de Pascal
Aquí hay algunos datos que le resultarán interesantes sobre el triángulo de Pascal:
- La suma de todos los elementos seguidos es siempre la potencia de 2.
- La suma diagonal de los elementos de las filas genera la secuencia de Fibonacci.
Resumen
- El triángulo de Pascal da los coeficientes de las expansiones binomiales.
- Cada fila del triángulo de Pascal comienza y termina con "1". Los valores intermedios son la suma de dos elementos de la fila anterior.
- La suma diagonal de todos los elementos del triángulo de Pascal te dará la secuencia Fibonacci.
- El triángulo de Pascal también se puede generar con coeficientes binomiales.