Leyendo entre líneas, sospecho que también está interesado en cómo generar todos los subconjuntos únicos de 5 elementos de su lista / conjunto de 10 elementos. Como las respuestas anteriores le dieron la fórmula para calcular el número total de combinaciones (10C5 = 10! / ((10–5)! 5! = 252), le daré un algoritmo que puede usar para generar los 252 subconjuntos únicos. No incluye la fórmula de combinaciones, sin embargo, proporciona un recuento que puede usar como un control de la fórmula en términos del número total de subconjuntos que produce.
Generando las combinaciones cuando x elementos se eligen de y elementos
=============================================
1. Defina una matriz de almacenamiento (AR) y almacene los elementos y.
2. Defina x variables para los contadores de bucles. (Requerirá bucles anidados de 1 a x).
(p. ej., x = 6 podría tener variables de contador de bucle i, j, k, l, m, n)
3. Calcule el número de iteraciones necesarias para el primer bucle (más externo) como:
(yx) +1. (p. ej., 6 de 9 requeriría (9-6) +1 = 4 iteraciones del primer bucle).
- El producto de dos números es 392. El cociente de los dos números es 2. ¿Cuáles son los dos números?
- ¿Cómo se llama un gráfico con bordes ponderados no dirigidos y bordes no ponderados dirigidos?
- Cómo mostrar que f (n) + g (n) = O (max (f (n), g (n)))
- ¿Cómo determina un algoritmo el tono / nota de un solo sonido?
- Planeo cosas pero tengo problemas de dilación. ¿Como puedó resolver esté problema?
4. La segunda variable del ciclo iterará de 2 (1 + 1) a (yx) +2.
;
;
;
5. La variable del bucle xth iterará (bucle más interno) a partir del valor de
la (x-1) th variable +1 a y. (por ejemplo, para x = 6, y = 9 y contadores
i, j, k, l, m, n. La variable de contador x, n iteraría desde el valor
de m + 1 a 9 para el bucle más interno).
6. Genere las combinaciones en el bucle más interno utilizando los valores variables como índices de matriz (AR):
Imprima AR (primer contador), AR (segundo contador),… ..AR (x contador).
El total de iteraciones anidadas generará combinaciones y! / ((Yx)! X!).
Un pseudocódigo para generar las combinaciones cuando se eligen 6 elementos de valores enteros entre 9 de estos elementos podría tener este aspecto:
I. Defina la matriz AR del número entero y almacene los 9 números enteros.
matriz AR [1..9] (inicializar con los 9 elementos. Por ejemplo, AR (1) = 5, AR (2) = 10, .. etc.
II Defina 6 variables de bucle y una variable de contador.
int i, j, k, l, m, n, c
III. Iterar a través de los 6 bucles anidados:
empezar
c = 0 {inicializar c a 0}
para i = 1 a 4 {recuerde 9-6 + 1 = 4} hacer
para j = i + 1 a 5 {9-6 + 2} hacer
para k = j + 1 a 6 {9-6 +3} hacer
para l = k + 1 a 7 {9-6 +4} hacer
para m = l + 1 a 8 {9-6 +5} hacer
para n = m + 1 a 9 {9-6 +6} hacer
empezar
IV. {Imprima las combinaciones en el bucle más interno:}
{Puede usar un contador, c para rastrear el número de combinaciones impresas.}
c = c +1
Imprimir (c, AR (i), AR (j), AR (k), AR (l), AR (m), AR (n))
end {iteraciones e impresiones de cada combinación numerada}
Nota: Si implementa esto usando un lenguaje que usa indexación basada en cero para matrices / listas, etc. (lo más común en estos días. ¡Lo desarrollé a principios de la década de 1990 y usé Pascal!), Su ciclo inicial (más externo) del nest se ejecutará de 0 a 3 en lugar de 1 a 4. Todos los bucles posteriores deberán ajustarse de manera similar. En su caso, x = 5 ey = 10. Entonces necesitará 5 bucles anidados y 5 variables de bucle asociadas. El primer ciclo producirá (10 – 5 + 1) = 6 iteraciones, 0 a 5 para implementaciones de indexación basadas en cero.
Aquí hay una salida abreviada (primeros 10 y últimos 10 subconjuntos) de su caso implementado usando Python (aproximadamente una docena de líneas de código):
>>>
Programa para enumerar todos los subconjuntos únicos de 5 elementos de un conjunto de 10 elementos: [1,2,3,4,5,6,7,8,9,10].
1) [1 2 3 4 5]
2) [1 2 3 4 6]
3) [1 2 3 4 7]
4) [1 2 3 4 8]
5) [1 2 3 4 9]
6) [1 2 3 4 10]
7) [1 2 3 5 6]
8) [1 2 3 5 7]
9) [1 2 3 5 8]
10) [1 2 3 5 9]
.
.
.
243. [4 6 7 8 10]
244. [4 6 7 9 10]
245. [4 6 8 9 10]
246. [4 7 8 9 10]
247. [5 6 7 8 9]
248. [5 6 7 8 10]
249. [5 6 7 9 10]
250 [5 6 8 9 10]
251. [5 7 8 9 10]
252. [6 7 8 9 10]
>>>
Su desafío, si así lo acepta, es escribir su propio programa para este caso para ver los 252 subconjuntos. Después de eso, puede intentar escribir uno que se pueda usar con varios tamaños de subconjunto (N) y varios tamaños del conjunto (K), ambos para ser suministrados en tiempo de ejecución, es decir, no codificados en su programa. Sugerencia: No sabrá cuántos bucles se necesitan o sus variables asociadas antes de que se ejecute el programa, por lo que se requerirán variables dinámicas, en función del tamaño del subconjunto de entrada. La recursión también sería útil.
¡Buena suerte!