Puede probar una variación de la búsqueda de profundidad primero (DFS) de los algoritmos de gráficos.
def find_sum_DFS (lst, objetivo, n):
si n == 1:
volver [[gol]] si gol en lst más []
más:
res = []
para x en lst:
res + = [[x] + y
para y en find_sum_DFS (lst, goal-x, n-1)
Si y ]
volver res
def find_elem_sum_to_DFS (lst, objetivo, n):
lst_s = ordenado (lst)
- ¿Su solución tiene que ser perfecta para codificar entrevistas?
- ¿Puedes sintaxis de Google durante una entrevista telefónica de codificación?
- Tengo una matriz de números del 1 al 1000000, necesito obtener el tiempo que toma cada elemento de la matriz para converger a 1 sin ningún cálculo repetido. ¿Cómo debo resolver este problema?
- Cómo reorganizar una matriz determinada para que Arr [I] se convierta en Arr [Arr [I]] con O (1) espacio adicional
- Algoritmo para dividir un número en un grupo ordenado diferente de modo que la suma de esos números sea el número original
R = find_sum_DFS (lst_s, objetivo, n)
S = conjunto (tupla (ordenada (x)) para x en R)
devoluciones
L = [10, 2, 6, 3, 4, 9, 0, 1, 7, 6, 8, 5, 14, 234, 1124]
T, N = 36, 8
S = find_elem_sum_to_DFS (L, T, N)
para r en ordenados (lista (S)): print (r)
Ejecutar el programa anterior da los siguientes resultados:
(0, 1, 2, 3, 4, 5, 7, 14)
(0, 1, 2, 3, 4, 6, 6, 14)
(0, 1, 2, 3, 4, 7, 9, 10)
(0, 1, 2, 3, 5, 6, 9, 10)
(0, 1, 2, 3, 5, 7, 8, 10)
(0, 1, 2, 3, 6, 6, 8, 10)
(0, 1, 2, 3, 6, 7, 8, 9)
(0, 1, 2, 4, 5, 6, 8, 10)
(0, 1, 2, 4, 5, 7, 8, 9)
(0, 1, 2, 4, 6, 6, 7, 10)
(0, 1, 2, 4, 6, 6, 8, 9)
(0, 1, 2, 5, 6, 6, 7, 9)
(0, 1, 3, 4, 5, 6, 7, 10)
(0, 1, 3, 4, 5, 6, 8, 9)
(0, 1, 3, 4, 6, 6, 7, 9)
(0, 1, 3, 5, 6, 6, 7, 8)
(0, 2, 3, 4, 5, 6, 6, 10)
(0, 2, 3, 4, 5, 6, 7, 9)
(0, 2, 3, 4, 6, 6, 7, 8)
(1, 2, 3, 4, 5, 6, 6, 9)
(1, 2, 3, 4, 5, 6, 7, 8)