logiciel décomposition/recomposition de nombres

[invite312a1646]

Bonjour, je vais essayer d'être claire. Existe t-il un programme capable de retrouver à partir d'une liste de nombres nommée pour l'occasion "A"(par addition et soustraction uniquement) les mariages necessaires pour retrouver les nombres(associés entre eux parfois)de la dite liste "A" mais aussi d'une liste"B" (sachant qu'un meme nombre peut servir plusieurs fois) ? Voici un exemple simplifié:

Liste "A": 585.68 - 383.90 - 3153.53 - 308.80 - 588.65 - 203.78 - 381.9 - 221.20 - 24.12 - 3.38 - 512.58


Liste "B": 1191.75 - 27.50

On peut voir ici que 203.78+381.9=585.68, donc en voila un mais 381.9 est aussi necessaire au calcul de 1191.75 (221.20+381.90+588.65) alors que 203.78 est lui necessaire pour trouver 512.58 (308.8+203.78).
J'ai élaborer une serie de formules (16000) avec excel, ce qui me permet de travailler avec 15 nombres mais ce n'est pas suffisant, ces formules me permettent uniquement de rentrer une liste de 15 nombres et de saisir un nombre que je cherche....si il existe une combinaison possible, excel me la donne mais ça ne me suffis malheureusement pas.
Si l'un où l'une d'entre vous a une solution informatique, je serais ravis de pouvoir l'essayer.Merci d' avance pour votre aide...
-----

[Towl]

Je vais essayer de reformuler pour voir si j'ai bien compris
On dispose d'une liste de nombre A et B.
Le but, obtenir une formule (addition/soustraction) pour chaque nombre de A et de B, de facon à ce que chacun d'entre eu soit composé uniquement d'éléments de A. Chaque élément de A intervient une seule fois dans la formule, mais peut apparaitre dans plusieurs formules.

Ex:
A = 2; 3; 5;
B = 7; 9.
on a :
2 = 5-3
3 = 5-2
5 = 3+2
7 = 5+2
9 : impossible avec que des éléments de A

Est-ce que j'ai bon ? Si oui, ca doit être facilement réalisable, pas de manière optimale dans un premier temps, mais ca peut te sortir de tes 16.000 formules

[invite312a1646]

Bonjour Tow! et merci pour ton intervention.
Je pense que tu as saisis ma question, en tout cas ta retranscription est bonne. Je tiens à préciser que le tableau excel que j'utilise fonctionne bien, que les 16000 formules ne posent pas de problemes de ralentissements et que seul le fait de rajouter un nombre (16 nombres trouvables) est bloquant puisqu'il faut doubler la quantité de formules.
Tu parrais detenir une solution , et ça m'arrange...
Sur un autre forum, on m' a parler d' un programme informatique distinct, plutot que excel, qui permet un brassage des nombres et ce sans se limiter dans la taille de la liste, je n'ai malheureusement pas le nom de cette petite merveille...
Si tu veux bien m'en dire plus sur ta solution, je suis preneur....d'avance merci, à bientot.

[Towl]

J'avais pas spécialement d'idées, mais effectivement il vaut mieux passer par un langage de programmation et donc un programme distinct.

Voici un script python sous optimal : (il te trouve une solution de formule, pas forcément la plus directe, et pas de manière la plus rapide)

A = [ 585.68, 383.90, 3153.53, 308.80, 588.65, 203.78, 381.9, 221.20, 24.12, 3.38, 512.58]
B = [1191.75, 27.50]




def getPermut(elem, tab, ret):
    ret.append("%s" % elem)
    if len(tab) == 0:
        return
    for i in range(len(tab)):
        getPermut("%s + %s" % (elem, tab[i]), tab[i+1:], ret)
        getPermut("%s - %s" % (elem, tab[i]), tab[i+1:], ret)


def myfunc(A, B):
    print "Permutation et creation des formules"
    formules_A = []
    for i in range(len(A)):
        getPermut(A[i], A[i+1:], formules_A)

    print "Recherche des elements de A dans les formules"
    for e in A:
        for formule in formules_A:
            if eval(formule) == e:
                print "%s = %s" % (e, formule)
                break
        else:
            print "%s non trouve" % e

        
    print "Recherche des elements de B dans les formules"
    for e in B:
        for formule in formules_A:
            if eval(formule) == e:
                print "%s = %s" % (e, formule)
                break
        else:
            print "%s non trouve" % e



myfunc(A, B)

import os
os.system("PAUSE")

Il te suffit de copier coller ce code dans un fichier .py (exemple : decomposition.py). Ensuite tu n'as plus qu'a modifier ta liste A et B et à double cliquer sur ton fichier python.

Pour disposer de l'environnement python, il te faut l'installer. Tu peuxle trouver ici http://www.python.org/ftp/python/2.6/python-2.6.msi


Si besoin je ferais une version qui écrit les résultats dans un fichier plutot que les afficher, de meme pour trouver la solution optimale.

Exemple de résultats obtenus avec A = [ 2, 3, 5 ] et B = [ 7, 9 ]

Permutation et creation des formules
Recherche des elements de A dans les formules
2 = 2
3 = 3
5 = 2 + 3
Recherche des elements de B dans les formules
7 = 2 + 5
9 non trouve

Résultats obtenus avec ton exemple :

Permutation et creation des formules
Recherche des elements de A dans les formules
585.68 = 585.68
383.9 = 585.68 + 383.9 - 203.78 - 381.9
3153.53 = 585.68 + 3153.53 + 308.8 - 381.9 - 512.58
308.8 = 308.8
588.65 = 585.68 + 308.8 + 588.65 - 381.9 - 512.58
203.78 = 203.78
381.9 = 585.68 + 308.8 - 512.58
221.2 = 585.68 - 203.78 - 381.9 + 221.2
24.12 = 585.68 - 203.78 - 381.9 + 24.12
3.38 = 585.68 - 203.78 - 381.9 + 3.38
512.58 = 585.68 + 308.8 - 381.9
Recherche des elements de B dans les formules
1191.75 = 585.68 - 383.9 + 308.8 + 588.65 + 203.78 - 381.9 - 221.2 - 24.12 + 3.38 + 512.58
27.5 = 585.68 + 308.8 - 381.9 + 24.12 + 3.38 - 512.58

Comme tu peux le voir, des fois je trouve des trucs rigolo : 24.12 = 585.68 - 203.78 - 381.9 + 24.12




Pour info, le principe de fonctionnement du programme :
dans un premier temps, je créé un tableau contenant toutes les formules possibles à partir des éléments de A.
Ensuite, pour chaque élément de A, je calcule la formule et je compare le résultat à l'élément cherché. Dès que je trouve une réponse, je passe à un autre élement
de même pour B.

Les seules limitations vont être en termes de mémoire et de temps, aucun stockage de taille du tableau de A ou B n'est effectué.

[A voir en vidéo sur Futura]

[Towl]

Apres m'etre reposé la tete, je me suis apercu que je cherchais les solutions optimales du style 512.58 = 512.58, ce qui va énormément t'avancer

Donc voici une deuxieme version du programme qui recherche toutes les forumes du type X = a + b - c ... avec a, b,c ... différents de X et qui en plus recherche la solution optimales (le moins d'additions soustractions à faire).

Voici le code

A = [ 585.68, 383.90, 3153.53, 308.80, 588.65, 203.78, 381.9, 221.20, 24.12, 3.38, 512.58]
B = [1191.75, 27.50]

def getPermut(elem, tab, ret):
    ret.append("%s" % elem)
    if len(tab) == 0:
        return
    for i in range(len(tab)):
        getPermut("%s + %s" % (elem, tab[i]), tab[i+1:], ret)
        getPermut("%s - %s" % (elem, tab[i]), tab[i+1:], ret)


def myfunc(A, B):
    print "Permutation et creation des formules"
    formules_A = []
    for i in range(len(A)):
        getPermut(A[i], A[i+1:], formules_A)

    print "Precalcul des formules"
    f = []
    for formule in formules_A:
        d = {}
        d ['formule'] = "%s" % formule
        d ['res'] = eval(formule)
        f.append(d)
    del formules_A
    formules_A = f
    

    print "Recherche des elements de A dans les formules"
    for e in A:
        found = False
        c = 99999
        for i in xrange(len(formules_A)):
            if formules_A[i]['res'] == e:
                tmp = formules_A[i]['formule'].count('+') + formules_A[i]['formule'].count('-')
                for x in formules_A[i]['formule'].split(' '):
                    if x == '+' or x == '-':
                        continue
                    if eval(x) == e:
                        break
                else:
                    if tmp != 0 and (not found or c > tmp):
                        found = "%s = %s" % (e, formules_A[i]['formule'])
                        c = tmp
        if not found:
            print "%s non trouve" % e
        else:
            print found

        
    print "Recherche des elements de B dans les formules"
    for e in B:
        found = False
        c = 99999
        for i in xrange(len(formules_A)):
            if formules_A[i]['res'] == e:
                tmp = formules_A[i]['formule'].count('+') + formules_A[i]['formule'].count('-')
                if not found or (tmp != 0 and c > tmp):
                    found = "%s = %s" % (e, formules_A[i]['formule'])
                    c = tmp
        if not found:
            print "%s non trouve" % e
        else:
            print found



myfunc(A, B)

import os
os.system("PAUSE")

Et voici le résultat :

Permutation et creation des formules
Precalcul des formules
Recherche des elements de A dans les formules
585.68 = 203.78 + 381.9
383.9 non trouve
3153.53 non trouve
308.8 non trouve
588.65 non trouve
203.78 non trouve
381.9 = 585.68 - 203.78
221.2 non trouve
24.12 non trouve
3.38 non trouve
512.58 = 308.8 + 203.78
Recherche des elements de B dans les formules
1191.75 = 588.65 + 381.9 + 221.2
27.5 = 24.12 + 3.38

J'ai rajouté une option de précalcul des formules pour éviter d'avoir à trop perdre de temps. Y a pas mal d'optimisatios à apporter pour gagner du temps, mais c'est un premier jet

[Towl]

Bon comme j'aime pas les codes trop sales, j'ai retouché une derniere fois (et corrigé les bugs ) :

A = [ 585.68, 383.90, 3153.53, 308.80, 588.65, 203.78, 381.9, 221.20, 24.12, 3.38, 512.58]
B = [1191.75, 27.50]


MARGE_ERREUR_FLOTTANT = 0.00001
FILENAME = "c:\\resultats.txt"


def getPermut(elem, tab, ret):
    ret.append(elem)
    if len(tab) == 0:
        return
    for i in range(len(tab)):
        d = {}
        d['elem'] = elem['elem'] + [tab[i]]
        d['formule'] = "%s - %s" % (elem['formule'], tab[i])
        getPermut(d, tab[i+1:], ret)
        d = {}
        d['elem'] = elem['elem'] + [tab[i]]
        d['formule'] = "%s + %s" % (elem['formule'], tab[i])
        getPermut(d, tab[i+1:], ret)



def findFormule(liste, formules, file=None):
    for e in liste:
        found = False
        c = 99999
        for i in xrange(len(formules)):
            if e in formules[i]['elem']:
                continue
            if not (e >= formules[i]['res'] - MARGE_ERREUR_FLOTTANT and e <= formules[i]['res'] + MARGE_ERREUR_FLOTTANT):
                continue
            if not found or c > len(formules[i]['elem']):
                found = "%s = %s" % (e, formules[i]['formule'])
                c = len(formules[i]['elem']) 
        if not found:
            if file is None:
                print "%s non trouve" % e
            else:
                file.write("%s non trouve\n" % e)
        else:
            if file is None:
                print found
            else:
                file.write("%s\n" % found)


def compute(A, B):
    print "Permutation et creation des formules"
    formules_A = []
    for i in range(len(A)):
        d = {}
        d['elem'] = [A[i]]
        d['formule'] = '%s' % A[i]
        getPermut(d, A[i+1:], formules_A)

    print "Precalcul des formules"
    f = []
    for formule in formules_A:
        d = {}
        d ['formule'] = "%s" % formule['formule']
        d ['res'] = eval(formule['formule'])
        d ['elem'] = formule['elem']
        f.append(d)
    formules_A = f
   


    file = open(FILENAME, 'w+')
    print "Recherche des elements de A dans les formules"
    findFormule(A, formules_A, file)
       
    print "Recherche des elements de B dans les formules"
    findFormule(B, formules_A, file)
    file.close()


compute(A, B)

Il te suffit de modifier la variable FILENAME pour écrire dans le fichier pointé (en mettant 2 '\' a chaque changement de répertoire).
Cela te donne :

585.68 = 203.78 + 381.9
383.9 non trouve
3153.53 non trouve
308.8 non trouve
588.65 non trouve
203.78 = 585.68 - 381.9
381.9 = 585.68 - 203.78
221.2 non trouve
24.12 non trouve
3.38 non trouve
512.58 = 308.8 + 203.78
1191.75 = 588.65 + 381.9 + 221.2
27.5 = 24.12 + 3.38

Normalement, cette version est correcte C'était bien marrant à faire comme petit truc

Edit: C'est fou ce que j'aime me parler à moi meme

[invite312a1646]

Ecoute TOW! Je n' ai pas encore essayé les solutions que tu m' a envoyé (la derniére en tout cas ) cependant je peux deja voir la quantité de travail que tu as fourni pour en arriver là et je t"en suis trés reconnaissant....c'est donc ça qu'on appel un passioné !!
Je vais essayé cela le plus tot possible et te donne bien vite des nouvelles de ton application dans l'environnement que je lui destine.
Merci encore , bonne soirée à toi et à trés bientot.

[invite312a1646]

Cher POW, cher passionné......je viens d'essayer le programme que tu as elaboré et....c'est une petite merveille.Je n'ai pas changé les listes que tu as mis dans l' exemple mais tout fonctionne trés trés bien....et rapidement.
Penses tu qu'il serait possible d'isolé le code du contenu des listes? du genre un fichier dans lequel n'apparaitrait que les deux listes et qui serait mis en liaison avec le fichier contenant le code avec quelque chose comme un "lien hypertexte". Le but bien entendu étant de proteger le code d'un fausse manipulation....en tout cas, même en l'état, il est super ce code. Je le mets à l'essais dés demain....merci merci...

[Towl]

Ca fait plaisir des messages comme ca
Mais t'inquiete pas je n'y ai pas passé tant de temps que ca, je codais 5 lignes quand j'en avais le temps Mais c'est vrai que je suis un passioné

Sinon, oui, c'est possible de séparer le code des listes : Il te suffit simplement de mettre les listes dans un fichiers (listes.py) et ensuite de rajouter (from listes import *) à la place de la déclaration des listes dans le premier fichier.

ce qui donne pour listes.py

A = [...]
B = [...]

et pour l'autre

from listes import *

FILENAME = "c:\\resultats.txt"
...

Ares il doit même etre possible de faire un affichage plus propre pour l'importer directement dans excel et ne plus avoir à tout faire à la main, tout dépend de ce que tu souhaites faire

[invite312a1646]

Heureux de t'avoir fais plaisir...cela dit, ce n'était pas usurpé, même si ta maitrise te permet d'écrire ces codes comme je fais des crepes
Voila , j' ai suivi les instructions que tu m' as laissé lors de ton dernier message mais je ne suis pas parvenu à utiliser un second fichier, separé du premier. J'ai essayé simplement comme tu me l'as écris, puis j' ai essayé de multiples combinaisons mais je n'ai pas fais mieux.....Si tu as une minute de plus dans les jours à venir
En tout cas, je te tiens au courant de la suite....Bon début de semaine à toi,encore merci et à bientot....

[Towl]

Une version rapide (car il se fait tard ) et qui marche à tous les coups :

OUT_FILENAME = "c:\\resultats.txt"
INPUT_FILENAME = "c:\\in.txt"

MARGE_ERREUR_FLOTTANT = 0.00001



def getPermut(elem, tab, ret):
    ret.append(elem)
    if len(tab) == 0:
        return
    for i in range(len(tab)):
        d = {}
        d['elem'] = elem['elem'] + [tab[i]]
        d['formule'] = "%s - %s" % (elem['formule'], tab[i])
        getPermut(d, tab[i+1:], ret)
        d = {}
        d['elem'] = elem['elem'] + [tab[i]]
        d['formule'] = "%s + %s" % (elem['formule'], tab[i])
        getPermut(d, tab[i+1:], ret)



def findFormule(liste, formules, file=None):
    for e in liste:
        found = False
        c = 99999
        for i in xrange(len(formules)):
            if e in formules[i]['elem']:
                continue
            if not (e >= formules[i]['res'] - MARGE_ERREUR_FLOTTANT and e <= formules[i]['res'] + MARGE_ERREUR_FLOTTANT):
                continue
            if not found or c > len(formules[i]['elem']):
                found = "%s = %s" % (e, formules[i]['formule'])
                c = len(formules[i]['elem']) 
        if not found:
            if file is None:
                print "%s non trouve" % e
            else:
                file.write("%s non trouve\n" % e)
        else:
            if file is None:
                print found
            else:
                file.write("%s\n" % found)


def compute(A, B):
    print "Permutation et creation des formules"
    formules_A = []
    for i in range(len(A)):
        d = {}
        d['elem'] = [A[i]]
        d['formule'] = '%s' % A[i]
        getPermut(d, A[i+1:], formules_A)

    print "Precalcul des formules"
    f = []
    for formule in formules_A:
        d = {}
        d ['formule'] = "%s" % formule['formule']
        d ['res'] = eval(formule['formule'])
        d ['elem'] = formule['elem']
        f.append(d)
    formules_A = f
   


    file = open(OUT_FILENAME, 'w+')
    print "Recherche des elements de A dans les formules"
    findFormule(A, formules_A, file)
       
    print "Recherche des elements de B dans les formules"
    findFormule(B, formules_A, file)
    file.close()


file = open(INPUT_FILENAME, 'r')
A = [eval(x) for x in file.readline().split(';')]
B = [eval(x) for x in file.readline().split(';')]
file.close()

compute(A, B)

modifier INPUT_FILENAME par le fichier d'entrée. Format : 2 lignes, la premiere contenant A, chaque champ séparé par un ;, de meme pour la deuxieme représentant B :

585.68;383.90;3153.53;308.80;588.65;203.78;381.9;221.20;24.12;3.38;512.58
1191.75;27.50

PS : les espaces sont autorisés

[invite312a1646]

Bonsoir Tow!
Je viens te donner les nouvelles....trois au total.
En premier, j' ai essayé d'utiliser la derniére version que tu m' as envoyé(listes separées), mais toujours sans succés, biensur, ce n'est rien puisque ça ne m'empêche pas de le faire fonctionner avec l'ancienne mouture(chez moi toutefois, voir la suite).
En second...petite decéption au bureau car nous utilisons Win NT et il ne reconnais pas Python 2.6. Je pense utiliser la version 2.5.2, d'aprés ce que j'ai cru lire, ça devrait fonctionné(?).

Enfin, j'ai pu le faire fonctionner sous win XP avec le portable d'un collégue (pentium M 1.73ghz) et une liste A de 18 nombres, une B de 2 (j'avais commencé avec 25 et 7) mais ça a tourné plus d'une heure sans resultats (on a interompu).
Je sais que le brassage que doit faire le PC est gigantesque (j'en veux pour preuve mes 16000 formules sous excel ) cela dit, avec des opérations plus legéres, ça a été du bonheur...
Alors trois questions ce soir:
Penses tu qu'il soit consevable d'obtenir des resultats + rapides (sans changer le proc et la mémoire), genre formule allégée ?
Peux tu me confirmer la version de python utilisable sous Win NT ?
Et enfin, sais tu s'il existe un moyen de multiplier la quantité de nombres que je peux utiliser avec ma formule sous excel sans avoir un nombre de formules dement(14 nombres pour 16000 formules ce jour).
D'avance merci pour ton aide à venir et passée et...à charge de revenche bonne soirée....

[Towl]

En premier, j' ai essayé d'utiliser la derniére version que tu m' as envoyé(listes separées), mais toujours sans succés, biensur, ce n'est rien puisque ça ne m'empêche pas de le faire fonctionner avec l'ancienne mouture(chez moi toutefois, voir la suite).

Bizarre quand même ... chez moi ca marche sans aucun soucis :s Ta ligne ne se termine pas par un ; par hasard ?

En second...petite decéption au bureau car nous utilisons Win NT et il ne reconnais pas Python 2.6. Je pense utiliser la version 2.5.2, d'aprés ce que j'ai cru lire, ça devrait fonctionné(?).

Aucune idée. C'est vrai que je me focalisais plus sur du Windows 2000+, MacOS ou Linux. Enfin mon code est 100% compatible python 2+, donc meme si tu trouves un python 2.1 pour NT, ca devrait fonctionner

Enfin, j'ai pu le faire fonctionner sous win XP avec le portable d'un collégue (pentium M 1.73ghz) et une liste A de 18 nombres, une B de 2 (j'avais commencé avec 25 et 7) mais ça a tourné plus d'une heure sans resultats (on a interompu).
Je sais que le brassage que doit faire le PC est gigantesque (j'en veux pour preuve mes 16000 formules sous excel ) cela dit, avec des opérations plus legéres, ça a été du bonheur...

Hum effectivement, il consomme un chouilla de mémoire, j'ai du le tuer à 5.5Go de RAM utilisé, et il avait pas finit
Donc tu peux dire adieux à la version optimisée en temps mais pas en mémoire (la précédente) et bienvenue à la version optimisée en mémoire mais pas en temps (la nouvelle). Malheureusement, faire un mix des deux est beaucoup plus compliqué :s

OUT_FILENAME = "c:\\resultats.txt"
INPUT_FILENAME = "c:\\in.txt"

MARGE_ERREUR_FLOTTANT = 0.00001



import time
start = time.time()


def eq(a, b):
	return (a + MARGE_ERREUR_FLOTTANT > b) and (a - MARGE_ERREUR_FLOTTANT < b)

def getPermut(elem, tab, value, nbElem):
	if nbElem == 1 and eq(eval(elem), value):
		return None, 9999999
	if nbElem > 1:
		if eq(eval(elem), value):
			return elem, nbElem
		elif eq(eval("(%s) * -1" % elem), value):
			elem = elem.replace('-', '_')
			elem = elem.replace('+', '-')
			elem = elem.replace('_', '+')
			elem = "-%s" % elem
			return elem, nbElem
	if len(tab) == 0:
		return None, 9999999
	res = None
	nb = None
	for i in range(len(tab)):
		if tab[i] == value:
			continue
		res1, nb1 = getPermut("%s - %s" % (elem, tab[i]), tab[i+1:], value, nbElem+1)
		res2, nb2 = getPermut("%s + %s" % (elem, tab[i]), tab[i+1:], value, nbElem+1)
		if nb1 < nb2:
			if nb is None or nb1 < nb:
				res = res1
				nb = nb1
		else:
			if nb is None or nb2 < nb:
				res = res2
				nb = nb2
	return res, nb

def findElem(A, elem):
	r = None
	n = None
	for i in range(len(A)):
		res, nb = getPermut('%s' % A[i], A[i+1:], elem, 1)
		if res is not None:
			if n is None or nb < n:
				n = nb
				r = res
	if r is not None:
		file.write("%s =  %s\n" % (elem, r))
	else:
		file.write("%s non Trouve\n" % elem)



def compute(A, B):
	file.write("LISTE A\n")
	for e in A:
		print "Debut du programme il y a %fs" % (time.time() - start)
		print "Recherche %s dans A" % e
		findElem(A, e)
	file.write("LISTE B\n")
	for e in B:
		print "Debut du programme il y a %fs" % (time.time() - start)
		print "Recherche %s dans B" % e
		findElem(A, e)


file = open(INPUT_FILENAME, 'r')
A = [eval(x) for x in file.readline().split(';')]
B = [eval(x) for x in file.readline().split(';')]
file.close()

file = open(OUT_FILENAME, 'w+')

compute(A, B)
end = time.time()
print "Done in %fs" % (end - start)
file.close()

Pour info : la premiere version mettais 3s sur ton exemple, la nouvelle en mets 31 .. Mais consomme 2Mo de RAM au lieu de 13

J'ai mis quelques jolis messages pour voir un peu l'activité.


Sinon, si tu connais un algo pour faire ce genre de calcul, je suis preneur, la je fais toutes les permutations possibles et imaginables à partir de ma liste A. Peut etre qu'il existe un moyen de voir que l'on s'éloigne trop de la valeur et que l'on ne va jamais l'atteindre pour supprimer quelques calculs. Mais la c'est plus trop mon domaine de compétence

Et enfin, sais tu s'il existe un moyen de multiplier la quantité de nombres que je peux utiliser avec ma formule sous excel sans avoir un nombre de formules dement(14 nombres pour 16000 formules ce jour).

Je ne penses pas, a moins qu'il soit possible de faire de la programmation sous excel (ca doti exister mais je ne connais pas assez) pour ne pas faire des formules mais plutot des "générateurs de formules", comme le fait mon programme Python

[Towl]

Petit jeu pour savoir si tu es patient

Si je me trompe pas dans mes calculs (ce qui est fort propable), pour 11 nombres (ton exemple), tu as 1 744 436 permuttations possibles (en comptant les signes). Pour 17, tu passes à 7 423 131 482 possibilités, soit 4 200 fois plus.
En partant du principe que le 11 est résolu en 30s, , tu obtiendra ton résultat au bout de 35h pour 17 nombres Courage

Donc si par un pur hasard tu as une autre méthode pour contourner ton probleme, peut etre que ca vaut le coup de se pencher dessus