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

Algorithmes et structures de données Discussion :

Algorithme qui affiche les N premiers entiers impairs


Sujet :

Algorithmes et structures de données

  1. #41
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Mai 2002
    Messages
    3 409
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Mai 2002
    Messages : 3 409
    Points : 5 799
    Points
    5 799
    Par défaut
    salut

    tout depend de ta boucle
    et de ta façon de voir l'agorithme

    on vas prendre un exemple on demende les 11 premier nombre impaire
    sachant que le 11ieme seras (11*2)+1 = 23

    donc plusieur choix se trouve devant toi

    soit tu part de 23 et à chaque iteration tu enleve 2 jusqu'a atteindre la fin
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    IMAX = 23 
    INBITER = 0
     TANSQUE IMAX >=0 FAIRE  // on ne connais pas le nombre d'iteration a l'avance
        ECRIRE(IMAX )
        IMAX = IMAX -2
        INBITER = INBITER+1
     FIN TANSQUE
     ECRIRE(INBITER)
    soit tu te dis tu en as onze à trouver et à chaque fois tu multiplie ton indice par 2 et tu ajoute 1
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
     INBITER = 11 
     POUR  ICOUNT DE INBITER A 0 FAIRE 
         ECRIRE((ICOUNT*2)+1 )
     FIN POUR 
    ECRIRE(INBITER)
    tu t'apperçois ici que tout depend de ce que signifie N
    si N est ton Nombre d'elements a trouver la division par deux n'a aucun sens
    par-contre si N est ta valeur max à obtenir on s'aperçcois ici que la division a tout son sens

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
     IMAX = 23
     INBITER = QUOTIENT(IMAX;2) // => 11 (DIVISION ENTIERE) 
     POUR  ICOUNT DE INBITER A 0 FAIRE 
         ECRIRE((ICOUNT*2)+1 )
     FIN POUR 
    ECRIRE(INBITER)

    voila en esperant avoir été assez exaustif
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  2. #42
    Expert éminent sénior Avatar de Flodelarab
    Homme Profil pro
    Inscrit en
    Septembre 2005
    Messages
    5 238
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations forums :
    Inscription : Septembre 2005
    Messages : 5 238
    Points : 13 443
    Points
    13 443
    Par défaut
    Citation Envoyé par arknos Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    manu@ultimate:~$ ./devel/divers/n_impairs
    11
    9
    7
    5
    3
    1
    Ma foi, ça à l'air de fonctionner.
    Ton code affiche des nombres impairs.
    Mais là, tu affiches 6 nombres impairs et pas 11.
    Pourtant N=11.
    On veut les 11 premiers nombres impairs.
    Tu as bien divisé en 2.
    C'est i mod 2 dans ton code qui provoque ceci.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    for i in reverse 1..N then
       if i mod 2 = 1 then
            put_line(i);
       end if;
    end loop;
    Cette réponse vous apporte quelque chose ? Cliquez sur en bas à droite du message.

  3. #43
    Membre du Club
    Homme Profil pro
    codeur
    Inscrit en
    Mars 2018
    Messages
    158
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Gard (Languedoc Roussillon)

    Informations professionnelles :
    Activité : codeur

    Informations forums :
    Inscription : Mars 2018
    Messages : 158
    Points : 64
    Points
    64
    Par défaut
    Citation Envoyé par Flodelarab Voir le message
    Ton code affiche des nombres impairs.
    Mais là, tu affiches 6 nombres impairs et pas 11.
    Pourtant N=11.
    On veut les 11 premiers nombres impairs.
    Tu as bien divisé en 2.
    C'est i mod 2 dans ton code qui provoque ceci.
    A ok, j'ai compris ce que vous avez compris.

    Alors il faut faire N*2 et pas N/2.

    edit : Plus ou moins l'ambiguïté de l'énoncé.
    Les N permiers entier impairs : renvoie à :
    - les N premiers impairs des entiers.
    - les impairs des N premiers entiers.
    Logique sans matière est matière de logique.

  4. #44
    Rédacteur/Modérateur

    Homme Profil pro
    Ingénieur qualité méthodes
    Inscrit en
    Décembre 2013
    Messages
    4 038
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur qualité méthodes
    Secteur : Conseil

    Informations forums :
    Inscription : Décembre 2013
    Messages : 4 038
    Points : 9 347
    Points
    9 347
    Par défaut
    Les N premiers entiers impairs, il n'y a pas d'ambiguité, on veut afficher N lignes... et peu importe si certains des nombres affichés sont plus grands que N

    Par ailleurs, quand on parle d'algorithme, il y a en général 2 objectifs.
    1. L'algorithme doit donner le bon résultat.
    2. L'algorithme doit aller vite.
    Si N vaut 1000, tu vas prendre tous les nombres entre 2001 et 1, et tu vais faire 2000 divisions, et 2000 soustractions (en retirant 1 à chaque fois, pour gérer la boucle.)
    Compare avec l'algorithme suivant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    M = 2*N+1
    tantque M >= 1
     afficher  M
     M=M-2
    fin
    On a 1000 soustractions au lieu de 2000, et aucune division au lieu de 2000 divisions.

    Ce n'est pas un détail, c'est la différence entre un algorithme bâclé et un bon algorithme.
    N'oubliez pas le bouton Résolu si vous avez obtenu une réponse à votre question.

  5. #45
    Membre du Club
    Homme Profil pro
    codeur
    Inscrit en
    Mars 2018
    Messages
    158
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Gard (Languedoc Roussillon)

    Informations professionnelles :
    Activité : codeur

    Informations forums :
    Inscription : Mars 2018
    Messages : 158
    Points : 64
    Points
    64
    Par défaut
    Et baclé toi même, j'ai réflechie 2 minutes quand même pour participer cordialement.
    Et vous venez me dire que je bacle.... ?
    Vous avez beau être modérateur ne me manqué pas de respect quand même.
    Logique sans matière est matière de logique.

  6. #46
    Rédacteur/Modérateur

    Homme Profil pro
    Ingénieur qualité méthodes
    Inscrit en
    Décembre 2013
    Messages
    4 038
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur qualité méthodes
    Secteur : Conseil

    Informations forums :
    Inscription : Décembre 2013
    Messages : 4 038
    Points : 9 347
    Points
    9 347
    Par défaut
    Désolé, le mot bâclé était effectivement inadapté.
    N'oubliez pas le bouton Résolu si vous avez obtenu une réponse à votre question.

  7. #47
    Membre du Club
    Homme Profil pro
    codeur
    Inscrit en
    Mars 2018
    Messages
    158
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Gard (Languedoc Roussillon)

    Informations professionnelles :
    Activité : codeur

    Informations forums :
    Inscription : Mars 2018
    Messages : 158
    Points : 64
    Points
    64
    Par défaut
    Bon, et bien bravo pour votre algorithme,
    Logique sans matière est matière de logique.

  8. #48
    Membre émérite

    Homme Profil pro
    Formation: Chimie et Physique (structure de la matière)
    Inscrit en
    Décembre 2010
    Messages
    1 333
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 77
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Formation: Chimie et Physique (structure de la matière)
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2010
    Messages : 1 333
    Points : 2 570
    Points
    2 570
    Billets dans le blog
    9
    Par défaut Algorithme qui affiche les N premiers entiers impairs (et pas plus)
    Citation Envoyé par arknos Voir le message
    ... edit : Plus ou moins l'ambiguïté de l'énoncé:
    "Les N premiers entiers impairs" : renvoie à :
    - les N premiers impairs des entiers.
    - les impairs des N premiers entiers.
    L'énoncé initial ne présente aucune ambiguïté: l'ensemble des N premiers entiers impairs ne saurait être confondu avec celui des entiers impairs présents parmi les N premiers entiers .
    La distorsion de l'énoncé que tu introduis ne relève pas de son imprécision, mais d'un faute de compréhension; un peu de réflexion permet de s'en apercevoir.

    Citation Envoyé par tbc92 Voir le message
    Les N premiers entiers impairs, il n'y a pas d'ambiguité, on veut afficher N lignes ...
    Compare avec l'algorithme suivant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    M = 2*N+1
    tantque M >= 1
     afficher  M
     M=M-2
    fin
    On a 1000 soustractions au lieu de 2000, et aucune division au lieu de 2000 divisions.
    Ce n'est pas un détail, c'est la différence entre un algorithme bâclé et un bon algorithme.
    Ton procédé est effectivement celui qui répond à l'exigence du moindre calcul.
    À un petit détail près : le nombre de termes n'est pas celui que l'on attend.

    En prenant par exemple N = 7, l'énumération s'amorce pour Mini = 2*7 + 1 = 15 et se poursuit par décrémentation jusqu'à Mfin = 1; il s'affiche donc sur l'écran:
    (15 , 13 , 11 , 9 , 7 , 5 , 3 , 1) ... ce qui fait huit (8) termes.

    Cela ira peut-être mieux en prenant M = 2*N - 1 , la liste précédente commençant désormais à Mini = 2*7 - 1 = 13 .
    À croire qu'un mauvais sort s'acharne sur cette discussion : la même erreur avait été signalée auparavant (#20 à 22).

    Les entiers impairs admettent deux expressions équivalentes: I = 2*k + 1 et I = 2*k - 1
    dont l'opportunité dépend du contexte.


    Le français, notre affaire à tous
    Grand Dictionnaire Terminologique

  9. #49
    Nouveau Candidat au Club
    Inscrit en
    Mars 2008
    Messages
    34
    Détails du profil
    Informations forums :
    Inscription : Mars 2008
    Messages : 34
    Points : 1
    Points
    1
    Par défaut
    Citation Envoyé par Flodelarab Voir le message
    "1" n'est-il pas un diviseur de "N" ?

    Pourquoi diviser par 2 ? "N" n'a-t-il pas le droit d'être diviseur de "N" ?

    Ce n'est pas qu'il n'y a pas de diviseur. C'est que "i" n'est pas diviseur.
    var i,N,M : entiers
    début
    donner ( "N")
    lire (N)
    M=N/2 ou /N
    pour i=2 à M faire
    si ( le reste de N/i = 0 ) alors afficher ( "i")
    sinon ( afficher " i n'est Pas diviseur ")
    fin pour
    fin début
    Merci Pour La Remarque

  10. #50
    Rédacteur/Modérateur

    Homme Profil pro
    Ingénieur qualité méthodes
    Inscrit en
    Décembre 2013
    Messages
    4 038
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur qualité méthodes
    Secteur : Conseil

    Informations forums :
    Inscription : Décembre 2013
    Messages : 4 038
    Points : 9 347
    Points
    9 347
    Par défaut
    On veut afficher les diviseurs d'un entier N

    Pour N = 126
    il faut donc afficher 1, 2, 3 ,6 ,7, 9, 14, 18, 21, 42, 63, 126 (ne pas oublier 1 et 126 ...)
    Mais si on fait un algorithme qui affiche les mêmes nombres, mais dans cet ordre :
    1, 126, 2, 63, 3, 42 , 6, 21, 7, 18 9,14
    J'imagine que c'est aussi une bonne réponse.
    Et c'est une piste pour un algorithme qui fera beaucoup moins de calcul que la version actuelle.
    N'oubliez pas le bouton Résolu si vous avez obtenu une réponse à votre question.

  11. #51
    Membre émérite

    Homme Profil pro
    Formation: Chimie et Physique (structure de la matière)
    Inscrit en
    Décembre 2010
    Messages
    1 333
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 77
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Formation: Chimie et Physique (structure de la matière)
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2010
    Messages : 1 333
    Points : 2 570
    Points
    2 570
    Billets dans le blog
    9
    Par défaut Algorithme qui n'affiche plus du tout les N premiers entiers impairs
    Citation Envoyé par tbc92 Voir le message
    ... c'est une piste pour un algorithme qui fera beaucoup moins de calcul que la version actuelle.
    C'est juste.

    Citation Envoyé par tbc92 Voir le message
    ... Pour N = 126 ... si on fait un algorithme qui affiche les mêmes nombres, mais dans cet ordre :
    1, 126, 2, 63, 3, 42 , 6, 21, 7, 18 9,14
    J'imagine que c'est aussi une bonne réponse ...
    ... mais ça fait un peu désordre .

    Il suffit de programmer la liste croissante des diviseurs, en notant le quotient correspondant, et avec une condition d'arrêt appropriée.
    Par exemple en prévoyant un tableau de (N) booléens initialisés à False, et à l'aide des instructions suivantes:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    d:= 0; 
     
    REPEAT
      Inc(d); 
      q:= N DIV d;                      // quotient de la division euclidienne   
      r:= N MOD d;                      // reste de la division euclidienne 
      Test:= (q>=d);                    // quotient non inférieur au diviseur
      IF (Test AND (r=0)) THEN BEGIN
                                 ListeB[d]:= True; IF (q>d) THEN ListeB[q]:= True
                               END
    UNTIL (q<d);
    Il suffit ensuite d'énumérer les rangs des termes de valeur True:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    FOR k:= 1 TO N DO
      IF ListeB[k] THEN <Afficher k>
    Mais là on a changé de sujet ...


    Le français, notre affaire à tous
    Grand Dictionnaire Terminologique

Discussions similaires

  1. [Python 3.X] Coder un algorithme qui détermine les nombres premiers.
    Par Gwynbleidd dans le forum Calcul scientifique
    Réponses: 6
    Dernier message: 11/02/2017, 13h51
  2. Réponses: 2
    Dernier message: 04/10/2007, 12h31
  3. Un ls récursif qui affiche les chemins absolus
    Par Michaël dans le forum Shell et commandes GNU
    Réponses: 4
    Dernier message: 10/07/2006, 18h04
  4. [SQL Server] Requete qui affiche les doublons
    Par Vesta dans le forum Langage SQL
    Réponses: 11
    Dernier message: 26/05/2006, 14h42
  5. afficher les n premiers caractères d'un champs
    Par kabool dans le forum MS SQL Server
    Réponses: 3
    Dernier message: 08/03/2006, 19h22

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