aide programmation python

[invited0b2ef3b]

Bonjour à tous,
Je commence tout juste à programmer à l'aide de Python. Je m'acharne depuis une heure sur un problème que je me suis posé:
Soit 12 variables x1,x2,x3,...,x12 appartenant chacune à l'intevalle [0;9999]
On a l'opération suivante:
x1 + x2 + x3 + ... + x12
Je ne veut pas un résultat numérique, je voudrais créer un programme qui nous donne toutes les possibilités qu'aurait la "tête" de l'addition (en tenant compte de l'ordre des variables).
C'est en fait le début d'un programme que j'essaie de réaliser. Je vais réutiliser les valeurs numériques de chaques variables c'est pour cela que je n'ai pas besoin de valeur numérique suite à l'addition. J'ai pensé à utiliser la fonction randint() mais je veu être sur que toutes les possibilités soient présentes dans le programme.
J'espère être assez clair cependant si vous avez des questions n'hésitez pas à m'envoyer des messages le faisant savoir.
Merci de vos futures réponses
Cordialement,
Elek
-----

[invite597d4991]

J'avoue que je ne vois pas trop ce que sont les "possibilités de tête d'addition" tu peux donner un exemple?

[invited0b2ef3b]

bonsoir overmind,par exemple:
789+546+7+0+369+9999+7894+85+3 621+23+658+74
ou
0+2+3+4+89+7+6+2+0+698+47+984
ou encore
0+0+0+0+1+0+0+1+2+0+0+0
J'espère avoir été assez clair...

[invite597d4991]

Si tu veux juste 12 nombres aléatoires à additioner, tu peux faire:
Liste = [randint(0,9999) for i in range(12)]
Après tu peux les additionner:
Liste[0] + ... +Liste[11]

Leur donner des noms poétiques:
x1 = Liste[0]
...
x12 = Liste[11]

Mais je ne vois pas trop le but de tout ça...

[A voir en vidéo sur Futura]

[invited0b2ef3b]

j'ai pensé à utiliser la fonction aléatoire mais je veu que toutes les opérations possibles passent au moins une fois
au pire je peu t'expliquer ce que je veu faire comme programme mais je sais pas si je vais arriver à tout expliquer correctement et je sais qu'il est vrément complexe... dite moi si vous êtes intéressé
merci pour votre aide

[invite597d4991]

Tu te rend compte du temps que ça prend, si on respecte l'ordre il y a 9999^12 possibilités...
998800659780049492080923920804 949780006599880001
Déjà tu peux être sûr que tu retombera pas deux fois sur la même, et ensuite, si toutes les possbilités doivent passer, tu aura le temps de mourrir au moins 10^30 fois avant que ça se termine....
A quoi ça sert ton truc?

[invited0b2ef3b]

Voila je vais t'expliquer à quoi servirai mon programme:
Je cherche une réponse au problème que j'ai posé ici:
http://forums.futura-sciences.com/sh...highlight=Elek
J'avais penser à utiliser les mathématiques pour trouver une solution mais en vain. C'est pourquoi j'ai penser que ma machine pourrait en trouver une grâce à un code source que j'aurais réaliser. Je débute tout juste dans la programmation informatique et c'est pour ça que je demande de l'aide.
Cependant j'ai changer mon problème je voudrais qu'il y ai au moins un ingrédient en plus que les ingrédients du départ après différentes combinaisons de recettes.
J'ai réaliser un schéma simplifié qu'aurait le programme (si il existe plus simple n'hésite pas à me le faire savoir). Inutile de me dire que le schéma n'a rien d'un travail rigoureux mais c'est pour m'éviter de t'embrouiller dans mes explications.
Je sais qu'un tel programme fournirai une solution au bout d'un bon moment à l'ordinateur mais qu'est ce qui nous empêche d'essayer? Y aurait'il une méthode plus rapide de trouver une solution?

[invited0b2ef3b]

oups j'ai oublié de donner l'image...
voila encore merci pour votre aide

[invite597d4991]

En données:
Si on a un dico qui contient ce qu'on veut:
Kejeve ={
"toto":3
".....": n
...
}
Et ce qui est dispo:
Kejai = {
"tata":5
"....."
...
}
Avec une structure représentant les recettes:
Map = {
"tata" = [("toto",5/3), ("Frodon",42/3) ,...] #ceci est une recette...
...
}
On peut pendre un élément des trucs qu'on veut, passer par Map pour trouver de quoi on a besoin (on peut surcharger la méthode __getitem__ de Map pour actualiser la liste des recettes utilisées)
Pour chaque Item trouvé dans Map, on vérifie si il est dispo ou non, si oui on le vire si non on l'ajoute à Kejeve.
Ensuite on prend un autre élément de Kejeve (méthode popitem) et on recommence.
Ça, ça va marcher si le graphe des recettes ne fait pas de boucles... ce qui serait bizzare pour des recettes mais bon...
Il faut aussi unicité de la recette pour un produit.
grr ces smileys au millieu du code...

[invited0b2ef3b]

merci beaucoup overmind mais je vais être franc avec toi je n'ai rien compris... Ce n'est pas de mon niveau. Alors si j'ai bien compris il nous est possible de créer ce programme. Je vais travailler ce que tu m'as donné mais serait gentil de me donner un petit coup de pouce
Merci à toi
Elek

[invite597d4991]

Je sais pas trop quel est ton niveau en python, mais le problème en lui même est un parcours d'arbre en gros.
J'ai reregardé "l'énoncé", plusieurs équations donnent la même chose, donc mon algo ne marche pas.
Ceci dit il pourrait marcher un le modifiant un peu, mais je crois qu'il est vraiment temps de te demander ce que tu as en entrée et ce que tu dois avoir en sortie.

Fixe aussi le formalisme pour les équations, les produits, etc, bref les données quoi (listes, dicos, voir chaines ou variables).
Une fois le problème clairement posé on a des chances de trouver une solution adaptée.

[invited0b2ef3b]

merci beaucoup mais c'est quoi le dico dont tu parle?

[invite597d4991]

En python, un dictionnaire est un mapping:
Ex:
Toto = {"Gaga":2,"Nitro":"Boom","Cona n":Barbare}
Ainsi Toto["Conan"] va retourner ce qu'il y a dans Barbare.

Effectivement, il faut apprendre les bases avant de se lancer dans de tels projets.

[invited0b2ef3b]

bonjour, j'aurais besoin d'un coup de pouce là je commence à ramer dans la programmation
je m'intéresse vraiment à la solution de ce problème, j'y conssacre beaucoup de temps mais j'ai bien peur que le manque d'expérience m'empêche de réaliser correctement mon projet c'est pourquoi j'ai besoin de votre aide

P.S: je vois ce qu'est un dictionnaire, je manipule bien les listes, les variables , les fonctions de bases cela dit je n' utilise que très rarement les modules proposés par Python

Merci pour votre aide

[invite597d4991]

Pas de problème, pas de solution.

Il faut absolument que tu réfléchisse d'abord à poser correctement le problème.
Il faut donc qu'on sache exactement ce qu'il doit y avoir en entrée et en sortie.

[invited0b2ef3b]

Merci pour une réponse aussi rapide Overmind
Mon problème est de savoir si il est possible, en un seul tour, d'avoir des arbres à l'infini pour gagner (c'est le but du jeu) même si il faut avoir que 10 arbres pour gagner. J'ai pensé à utiliser les recettes. Peut-être que si on combine des recettes avec les ingrédients de départ selon un ordre précis on aurait un ingrédient en plus qu'au départ!
Ce qu'on a au début c'est des ingrédients aléatoires et ce qu'on veut c'est des ingrédients en plus des ingrédients de départ après combinaisons des recettes.
En ayant une infinité d' un ou plusieurs ingrédients on pourra les utiliser dans des recettes afin d'avoir des arbres.
Ce que l'on veut c' est un enchaînement de recettes.

[invite597d4991]

J'avais à peu près compris ça, mais il faudrait un point de vue sensiblement plus formel. Du genre:
"Programmer une fonction qui accepte en paramètre un listing d'ingrédients, un (?) de recettes, et renvoie un listing des produits qu'il est possible d'obtenir"

Il reste à définir en Python ce qu'est une recette, un ingrédient et un produit.
deux possibilités:
-créer un objet spécial, mais ça requiert la POO...
-utiliser des chaines de caractères, et des dictionnaires, mais on y perd en fonctionnalité (dans ton cas il va alloir oublier dans un premier temps les quantités d'ingrédients, que ce soit dans les
recettes ou dans les ingrédients initiaux).

Une fois le problème posé de cette manière, il est relativement aisé de le résoudre. Mais est-ce que cette vision des choses te convient?

[invited0b2ef3b]

Une fois le problème posé de cette manière, il est relativement aisé de le résoudre. Mais est-ce que cette vision des choses te convient?

Oui, cela me convient mais pourrait tu me donner des pistes, des idées ou des des débuts de codes pour que je puisse les continuer... Je pense opter pour la deuxième méthode que tu as évoquée (chaînes de caractère, dico, listes etc ..)
Merci beaucoup pour ton aide
Elek

[invite597d4991]

Bon, on va dire que les recettes sont des fonctions:

def recette1(*args):
 if "cocacola" in args and "hamburger" in args:
  return ["mcfleury"]
else:
 return [ ]

De cette manière, si L est la liste des ingrédients disponibles:

recette1(*L)

va retourner les éventuels produits obtenus, dans une liste.

A partir de là, si on veut la liste des produits totale (avec les ingrédients):

len_L_old = 0
while len(L)!=len_L_old:
 len_L_old = len(L)
 for recette in recettes:
  for produit in recette(*L):
   if produit not in L: L.append(produit)

Je n'ai pas testé mais à peu de choses près ça devrait marcher.

[invited0b2ef3b]

Si je comprends bien

args

du premier code correspond à une liste d'ingrédient que l'on a au départ,

cocacola, hamburger

les ingrédients d'une recette et

mcfleury

le(s) produits de celle-ci.

J'ai l'impression qu l'on ne tient pas compte des quantités d'ingrédients dans les listes

Il y a juste une ligne que j'arrive pas à comprendre:

if produit not in L: L.append(produit)

[invite597d4991]

Ceci ne tient en effet pas compte des quantités, j'y reviendrai plus tard.

args est la liste des arguments passés à la recette (fonction).
Mettre:

 
def nomdelafonction(*args)

définit une fonction qui met ses arguments dans la liste, args.

et passer une liste avec une étoile devant:
L = ['a','b']
toto(*L)
revient à écrire:
toto('a','b')

L'instruction:
if produit not in L: L.append(L)
veut dire:
si on ne peut trouver la chaine référencée par produit dans la liste L, alors, il faut mettre cette chaine au bout de L.
Ceci permet de ne pas rajouter le produit si on l'a déjà fabriqué.


Pour les quantités, c'est plus complexe.
En effet on ne peut pas raisonner de la même manière, il se peut très bien qu'un ingrédient puisse servir dans plusieurs recettes, et donc il n'y a fatalement pas de liste de produits quantifiée définitive.

Tout dépend donc de l'information que tu veux en tirer. Ce qui serait gérable serait de parcourir l'arbre des recettes à l'envers (des produits vers les ingradients en posant la question "puisje fabriquer n moles de mcfleury?"), mais comme tu peux le voir, ceci demande une autre représentation des données.

[invited0b2ef3b]

J'ai essayé de savoir combien de fois on peut utiliser une recette (ici r1) avec des ingrédients donnés (ici nbing)

r1=[0,0,5,0,5,0,0,0,0,0,0,0]
nbing=[0,0,6,0,8,0,10,0,0,0,0,0]


deg=nbing
g,r=0,0
while r<=12
for arg in deg
if deg[g]= 0
del(deg[g])

a,b,c=0,0,len(deg)

while a<=12 and b<=c

if nbing[a]>=r1[a]
x1=nbing[a]
y1=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x2=nbing[a]
y2=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x3=nbing[a]
y3=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x4=nbing[a]
y4=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x5=nbing[a]
y5=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x5=nbing[a]
y5=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x6=nbing[a]
y6=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x7=nbing[a]
y7=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x8=nbing[a]
y8=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x9=nbing[a]
y9=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x10=nbing[a]
y10=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x11=nbing[a]
y11=r1[a]
b=b+1

elif nbing[a]>=r1[a]
x12=nbing[a]
y12=r1[a]
b=b+1

a=a+1

if x1>y1
x2/y2=f
else x1/y1=f
print f


Cela dit,il y a un bug dans le code ça serais gentil de le corriger
Peut-être que l'idée pourrait t'inspirer vers une nouvelle méthode ...

[invited0b2ef3b]

comment fait-on pour garder l'incrémentation parce que là c'est assez moche...

[invite597d4991]

Ce n'est pas très clair ton code.
Par exemple pourquoi ton "for arg in deg"??

Il serait plus simple d'expliquer en deux mots ton idée (ce qu'i n'empêche pas d'être précis)...

Si il s'agit juste de compter le nombre maximum d'utilisations, il y a deux choix:
-Soit le formalisme choisi permet de connaitre facilement les ingréduients nécesaires, dans ce cas on fait des divisions (disponible/requis) et on regarde le minimum.
-Soit le formalisme oblige à faire un détour, comme par exemple 'appliquer' la recette en question jusqu'à ce que ce soit impossible sur une copie de la structure des ingrédients.

[invited0b2ef3b]

oui je sais que ce n'est pas très clair mais c'est l'idée...
maintenant comment fait-on pour prendre en compte les quantités avec les fonctions représentant les recettes?

[invited0b2ef3b]

oui je sais que ce n'est pas très clair mais c'est l'idée... En fait j'avais pensé à tenir compte de l'ordre des ingrédiens puisque les listes en tiennent compte. On sait que toutes les listes des recettes ainsi que celle des ingrédients de départ ont 12 index. A la première "place" il y aurait les vavangues, à la deuxième les jujubes, ...
maintenant comment fait-on pour prendre en compte les quantités et les combinaisons? Je ne vois pas du tout comment on pourrait faire les combinaisons.

[invite597d4991]

Bon j'ai essayé de relire tes posts...
Si ton objectif est:
"Jai n ingrédients, p recettes, je veux fabriquer des ingrédients à l'infini mais je ne sais pas si c'est possible, le but est de donner une séquence de recettes qui fait tendre les quantités d'ingrédients vers l'infini, si elle existe."
Ben à mon avis tu peux galérer longtemps sur un truc comme ça, tu peux peut être bidouiller une sorte d'algo récursif pour être sûr d'explorer toutes les possibilités, mais ça risque d'être merdique.
Fait d'autres problèmes d'algo avant de retourner sur celui là.

[invited0b2ef3b]

Bonsoir j'est réalisé un programme qui serait en mesure de réoudre le problème. Cela dit je n'arrive pas à le faire fonctionner...Si quelqu'un pourrait m'aider ça serait bien gentil!
Pour les ingrédients et les produits des recettes j'ai utilisé des listes. J'y ai respecté un ordre,chaque emplacement d'une liste correspond à un ingrédient.
Je pense avoir règlé l'istoire des combinaisons avec la fonction randint au début des assignations.
Merci pour vos futures réponses!
Elek

[invite597d4991]

Ohlala... Je ne sais pas por le fond, mais mettre 30 'if' à la suite est certainement contournable....

Exemple: mettre les listes prodX et rX dans un dictionnaire. Comme ça tu peut faire une affectation à la place de tes 25 'if' du début.
Ce qui donne:

hasr=R["r%i"%ty]
hasprod=Prod["prod%i"%ty]

C'est tout de même beaucoup plus clair...

Ensuite, l'encoding "projet recettes" est certainement très bien , mais pas très répandu....

Enfin, tu as une boucle infinie dans ton programme, et je ne vois rien pour l'arrêter...

[invited0b2ef3b]

En fait le problème est que le programme tourne en boucle dans la deuxième "boucle"!! Que faut-il faire pour que le programme revienne à la première boucle lorsque les instructions demandées par les fonctions if ne sont pas respectées?
Merci de votre aide!
Elek