IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

programme python probleme


Sujet :

Python

  1. #1
    Candidat au Club
    Femme Profil pro
    Inscrit en
    Février 2013
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2013
    Messages : 8
    Points : 3
    Points
    3
    Par défaut programme python probleme
    Bonjour à tous

    Je vous explique mon problème,
    je dois crée un programme pour mon examen de juin qui se rapporte sur les interactions entre molécules.
    Une molécule est par exemple représentée par le chiffre 1, l'autre par le chiffre 2,.. et si l'on permute deux 1 , l'état ne change pas mais si on permute un 1 et un 2 l'etat change
    J'ai commencé mais je me suis vite arretée car je ne sais plus quoi faire
    Il faudrait donc que le programme puisse me dire le nombre d'état possible.

    Mon probleme en python c'est de faire le quadrillage avec les chiffres à l'intérieur et de trouver un programme qui sache compter le nombre d'interactions.

    Ce que j'ai déjà fait c'est de trouver un truc qui puisse mélanger les chiffres :

    >>> import random
    >>> a=[1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2]
    >>> len(a)
    21
    >>> a=a+[1,1,1,1]
    >>> a
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1]
    >>> len(a)
    25
    >>> random.shuffle(a)
    >>> a
    [1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]
    >>> random.shuffle(a)
    >>> a
    [1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1]

  2. #2
    Expert éminent

    Homme Profil pro
    Inscrit en
    Octobre 2008
    Messages
    4 302
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2008
    Messages : 4 302
    Points : 6 782
    Points
    6 782
    Par défaut
    Salut,

    Peux-tu clarifier ceci:
    Une molécule est par exemple représentée par le chiffre 1, l'autre par le chiffre 2,.. et si l'on permute deux 1 , l'état ne change pas mais si on permute un 1 et un 2 l'etat change
    Donc le nombre de 1 et le nombre de 2 ne changent jamais, est-ce bien cela ?
    En quelque sorte seul l'ordre change ?

  3. #3
    Candidat au Club
    Femme Profil pro
    Inscrit en
    Février 2013
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2013
    Messages : 8
    Points : 3
    Points
    3
    Par défaut
    Ouii c'est cela les particules 1 et 2 ne changent jamais. Seul l'ordre changent
    par exemple si on a :
    1 1 1
    1 1 1
    1 1 1

    si on permute deux 1 on ne voit pas de différence donc on a le meme etat

    mais si on a :

    1 2 2
    2 1 1
    1 1 2

    et qu'on permute un 1 et un 2 au hasard on aura par exemple:

    2 1 2
    2 1 1
    1 1 2

    donc l'etat change ici

    et c'est cela que le programme doit savoir me dire :/
    Dans mon cours j'ai une formule qui me permet de savoir cela mais je ne sais pas si j'en ai besoin

    Merci

  4. #4
    Nouveau membre du Club
    Homme Profil pro
    Inscrit en
    Janvier 2013
    Messages
    32
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Janvier 2013
    Messages : 32
    Points : 36
    Points
    36
    Par défaut
    Tu doit donc faire un programme qui compte (ou calcule) le nombre d'états possibles ?

    Avant de te lancer dans la programmation à tu établis un algorithme, (une liste de taches à effectuer pour trouver ton résultat) ?
    Il te sera peut-être plus simple de raisonner par observation dans un premier temps.

    Par exemple:
    Si tu as [1,2] un seul autre état est possible: [2,1].
    Si tu as [1,2,1], deux autres états sont possibles: [2,1,1], [1,1,2]
    Si tu as [1,1,2,1], trois autres états sont possibles: [1,2,1,1], [2,1,1,1], [1,1,1,2]
    Etc ...

    En raisonnant ainsi, tu trouvera peut être un lien entre le nombre de 1, de 2 et le nombre d'états différents possibles, et tu pourra ensuite traduire ta méthode en Python.

    (En espérant avoir servit par le biais de ce message.)

  5. #5
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    Bonjour,

    Ce n'est pas tout simplement une comparaison des éléments ayant le même index dans les listes ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    l1[idx] == l2[idx] == l3[idx]
    Le nombre de possibilités étant multiplié par le nombre de liste.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    >>> df = 0
    >>> l1 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1]
    >>> l2 = [1, 1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]
    >>> l3 = [1, 2, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1]
    >>> for idx in range(len(l1)):
    ...     if not (l1[idx] == l2[idx] == l3[idx]):
    ...         df += 1
    ... 
    >>> df*3
    57
    >>> df
    19
    ?

    @+

  6. #6
    Expert éminent

    Homme Profil pro
    Inscrit en
    Octobre 2008
    Messages
    4 302
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2008
    Messages : 4 302
    Points : 6 782
    Points
    6 782
    Par défaut
    Moi, je le vois comme un problème binaire.

    Pour une molécule donnée: 1121122211212212
    remplaçons les 2 par des 0 1101100011010010

    Puisqu'il est dit que le nombre de 1 ne peut pas varier et que dans mon exemple j'ai huit 1,
    le nombre de combinaisons possibles s'étend de:

    0000000011111111 (255 en décimal)

    à:

    1111111100000000 (65280 en décimal)

    dont il ne faut conserver que les valeurs (binaires) ne comportant que huit 1.

    Voila, à vos cours de binaire, moi j'ai eu une longue nuit.

  7. #7
    Candidat au Club
    Femme Profil pro
    Inscrit en
    Février 2013
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2013
    Messages : 8
    Points : 3
    Points
    3
    Par défaut
    Merci pour vos réponses

    Mais je ne comprend pas l'explication "binaire" ni celui avec l'index :/
    Désolé, je suis vraiment débutante de débutante en python

Discussions similaires

  1. Réponses: 145
    Dernier message: 15/02/2009, 12h51
  2. Faire communiquer deux programmes python
    Par bestdomdom dans le forum Général Python
    Réponses: 5
    Dernier message: 26/10/2006, 10h30
  3. [Lien]erreur dans mon programme python
    Par durnambule dans le forum Général Python
    Réponses: 11
    Dernier message: 29/01/2004, 15h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo