Partage
  • Partager sur Facebook
  • Partager sur Twitter

[python] while nb premier dans intervalle

Sujet résolu
    19 novembre 2021 à 8:52:58

    Bonjour je dois écrire un prédicat renvoyant True si il y a un nombre premier dans intervalle False sinon

    Mais je ne vois pas comment faire.

    On passe en paramètre un intervalle cad range()

    Je dois utiliser range()[] et while.

    Pourriez-vous m'aider ? merci. 



    -
    Edité par LilililiMimimimi 19 novembre 2021 à 9:28:31

    • Partager sur Facebook
    • Partager sur Twitter
      19 novembre 2021 à 9:53:01

      Bonjour.

      Personnellement pour la boucle à réaliser, j'utiliserai "for" plutôt que "while" et associé effectivement à "range".

      • Partager sur Facebook
      • Partager sur Twitter

      PB68

        19 novembre 2021 à 10:23:17

        Oui mais l'exercice nous impose 'while' :/

        • Partager sur Facebook
        • Partager sur Twitter
          19 novembre 2021 à 10:29:50

          Ça le fait aussi mais faut incrémenter soi-même pour balayer l'intervalle.

          Par contre, peux-tu en dire plus ? Quelles sont les données que tu as au départ ? L'intervalle est-il donné par l'utilisateur ? Y'a-t-il d'autres consignes ?

          As-tu déjà produit un brin de code ?

          -
          Edité par PB68 19 novembre 2021 à 10:35:30

          • Partager sur Facebook
          • Partager sur Twitter

          PB68

            19 novembre 2021 à 10:36:28

            Oui j'essaye de trouver mais je suis bloquée

            • Partager sur Facebook
            • Partager sur Twitter
              19 novembre 2021 à 10:44:37

              LilililiMimimimi a écrit:

              Oui j'essaye de trouver mais je suis bloquée


              Et, pour les autres questions ?
              • Partager sur Facebook
              • Partager sur Twitter

              PB68

                19 novembre 2021 à 10:54:49

                Désolée elles n'étaient pas affichées. l'intervalle est donnée par l'utilisateur sous forme de range()

                While est obligatoire.

                Voilà ma docstring avec doctest. 

                def au_moins_un_premier(intervalle):
                    """Renvoie True si intervalle contient au moins un nombre premier.
                    Paramètres :
                    - intervalle (range)
                    Valeur de retour (bool)
                    Contraintes : aucune
                    Exemples :
                    >>> au_moins_un_premier(range(12))
                    True
                    >>> au_moins_un_premier(range(8,11))
                    False
                    """

                j'ai essayé d'écrire une fonction mais elle ne veut rien dire :/ (J'ai juste essayé de m'aider d'un prédicat renvoyant True ssi le paramètre est un nb premier, que j'ai écrit au préalable)

                    def au_moins_un_premier(intervalle):
                    r=0
                    i=2
                    if intervalle[r] == 0 or intervalle[r] == 1:
                            r=r+1
                            while intervalle[i]<max(intervalle) and (intervalle[r]) % i != 0:
                                i=i+1
                                r=r+1
                    return i==max(intervalle)

                Je ne dois pas utiliser 'max()' mais c'était pour m'aider.

                -
                Edité par LilililiMimimimi 19 novembre 2021 à 11:20:49

                • Partager sur Facebook
                • Partager sur Twitter
                  19 novembre 2021 à 11:06:56

                  Présenté ainsi je comprends encore moins l’intérêt du while. L'utilisation d'une boucle while aurait pu se justifier si les paramètres de la fonction étaient les bornes de l'intervalle, mais là... La docstring indique aucune contraintes, êtes-vous sûr de ce while ?
                  • Partager sur Facebook
                  • Partager sur Twitter
                    19 novembre 2021 à 11:10:00

                    Oui nous étudions le chapitre sur les 'while', il est donc obligatoire de l'inclure. Je pense que le professeur s'est trompé sur les contraintes
                    • Partager sur Facebook
                    • Partager sur Twitter
                      19 novembre 2021 à 11:12:42

                      Bonjour,

                      Par contre, les indentations dans ta fonction au-moins_un_premier() sont bizarres ...

                      • Partager sur Facebook
                      • Partager sur Twitter
                        19 novembre 2021 à 11:16:24

                        Bonjour, oui la fonction n'est pas bonne, elle ne veut rien dire

                        J'ai trouvé une fonction qui vérifie avec les doctest et d'autres tests effectués. Pourriez-vous me dire comment enlever 'max()' ? Merci

                        -
                        Edité par LilililiMimimimi 19 novembre 2021 à 11:24:30

                        • Partager sur Facebook
                        • Partager sur Twitter
                          19 novembre 2021 à 12:03:43

                          Pour commencer, moi, pour parcourir l'intervalle passé en argument à la fonction, je ferais ceci:

                          def au_moins_un_premier(intervalle):
                          
                              i = intervalle[0]
                              while(i >= intervalle[0] and i <= max(intervalle)):
                          #       Tester si i est premier, si oui, on en a au moins un: sortir de la boucle et retourner True
                                  i+=1
                          
                          au_moins_un_premier(range(12))
                          



                          -
                          Edité par Phil_1857 19 novembre 2021 à 12:06:22

                          • Partager sur Facebook
                          • Partager sur Twitter
                            19 novembre 2021 à 14:02:41

                            Et dans ce chapitre vous n'avez pas étudié l'itération ? Parce que range est un objet de type itérateur et que son usage implique l'instruction for quasi systématiquement. AMHA savoir qu'un range se comporte comme une liste est une notion secondaire.

                            Naïvement j'aurais écrit quelque chose comme ça, sans me soucier de cette histoire de while:

                            for n in range:
                                if is_prime(n):
                                    return True
                            return False

                            -
                            Edité par ЯК 19 novembre 2021 à 14:04:02

                            • Partager sur Facebook
                            • Partager sur Twitter
                              19 novembre 2021 à 14:10:50

                              La notion de liste est la prochaine notion que l'on va étudier, il est donc interdit de l'utiliser (nous n'avons le droit d'utiliser quelque chose qui n'a pas encore été vu)

                              Comme vous, j'aurais préféré utiliser 'for' mais il est interdit de l'utiliser pour ces exercices-là

                              @Phil_1857  Merci ! Je vais y réfléchir.

                              • Partager sur Facebook
                              • Partager sur Twitter
                                19 novembre 2021 à 14:20:47

                                Je suis prit d'une étrange curiosité vis-à-vis de votre cours qui, de ce que vous en dégagez, me paraît incroyablement tordu. Vous utilisez l'indexation sur un range mais n'avez pas encore étudié les listes. Intéressant comme approche... intéressant.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  19 novembre 2021 à 14:37:04

                                  Oui, les exercices sont difficiles pour notre niveau mais les chargés de TD n'y peuvent rien :/

                                  Dans le cours, nous n'avons pas non plus vu comment parcourir 'range()' avec 'while', c'est problématique...

                                  J'ai essayé d'écrire :

                                  def au_moins_un_premier(intervalle):
                                      i = intervalle[0]
                                      r=0
                                      while(i >= intervalle[0] and i <= max(intervalle)) and (intervalle[i] == 0 or intervalle[i] ==1 or (intervalle[r]) % i != 0):
                                          i+=1
                                          r+=1
                                      return i < max(intervalle


                                  Car c'est sous cette forme qu'on doit le rendre ('return True' ou 'return False' ou encore 'res=False/True   return res' sont interdits)

                                  -
                                  Edité par LilililiMimimimi 19 novembre 2021 à 14:38:12

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    19 novembre 2021 à 15:09:09

                                    pour faire simple (même si ce n'est pas totalement exact), le retour d'un range() peut être vu comme un tableau (ou une liste), donc tu le parcours de la même façon: avec un indice passé entre crochet. Et on peut connaitre sa taille avec la fonction len => len(intervalle)
                                    Vu que tu as déjà fait une fonction qui retourne True si son paramètre est premier, autant l'utiliser.

                                    Fonction au_momins_un_premier (intervalle) : Booleen
                                    i=0
                                    tant que i < len(intervalle) 
                                        si EstPremier(intervalle[i]) alors
                                            retourner True
                                       fin_si
                                       i = i+1
                                    fin_tant_que
                                    retourner False



                                    -
                                    Edité par umfred 19 novembre 2021 à 15:11:24

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      19 novembre 2021 à 18:26:05

                                      J'ai trouvé ceci:

                                      def au_moins_un_premier(intervalle):
                                          i = intervalle[0]
                                          r=0
                                          while (i >= intervalle[0] and i <= max(intervalle)) and (intervalle[r]==0 or intervalle[r]==1 or est_premier(intervalle[r])==False):
                                              i=i+1
                                              r=r+1
                                          return i < max(intervalle)

                                      -
                                      Edité par LilililiMimimimi 19 novembre 2021 à 18:30:54

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        19 novembre 2021 à 20:06:51

                                        Ton intervalle est une liste de 2 nombres? Le début et la fin?
                                        Je pensais que tu n'avais pas vu les listes ...
                                        n = intervalle[0]
                                        while n <= intervalle[1]:
                                            if isprime(n):
                                                return True
                                            n += 1
                                        return False

                                        Ha oui, tu dois utiliser range ...

                                        while n in range(intervalle[0], intervalle[1]+1):

                                        -
                                        Edité par PierrotLeFou 19 novembre 2021 à 20:18:29

                                        • Partager sur Facebook
                                        • Partager sur Twitter

                                        Le Tout est souvent plus grand que la somme de ses parties.

                                          19 novembre 2021 à 20:22:37

                                          Je n'ai pas le droit d'écrire 'return True' ou 'return False'...

                                          intervalle c'est range(..)

                                          Par exemple pour tester la fonction j'écris : au_moins_un_premier(range(12))

                                          Ma fonction n'est pas correcte ? 

                                          -
                                          Edité par LilililiMimimimi 19 novembre 2021 à 21:31:49

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            20 novembre 2021 à 1:14:51

                                            LilililiMimimimi a écrit:

                                            Ma fonction n'est pas correcte ? 

                                            Tu n'as pas donné ta fonction est_premier donc on ne peut pas tester. Dans le principe, ça semble correct.

                                            • La gestion de 0 et 1 me paraît peu heureuse. 
                                            • Un point plutôt maladroit est ton max(intervalle) : le calcul contient un parcours implicite du range donc max(range(10**10)) sera très long. En revanche intervalle.stop sera instantané ou encore intervalle[-1]
                                            • En Python, on n'écrit pas i>=A and i >=B mais A <= i<= B et ici il est naturel d'écrire plutôt i in intervalle (qui n'effectue aucune itération). 
                                            • Inutile d'entourer de parenthèses la condition du while. 
                                            • On n'écrit pas trop est_premier(intervalle[r])==False mais plutôt not est_premier(intervalle[r])

                                            Perso, j'ai écrit cela :
                                            def f(I):
                                                found = False
                                                n = I.start
                                                while n in I and not found:
                                                    d = 2
                                                    while n % d != 0 and d < n:
                                                        d += 1
                                                    if d == n:
                                                        found = True
                                                    else:
                                                        n += 1
                                                return found
                                            
                                            
                                            print(f(range(362867 + 1, 362897)))
                                            print(f(range(0, 3)))
                                            
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              20 novembre 2021 à 22:00:53

                                              D'accord. J'ai réussi. Merci à vous ! :)
                                              • Partager sur Facebook
                                              • Partager sur Twitter

                                              [python] while nb premier dans intervalle

                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                              • Editeur
                                              • Markdown