Ç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 ?
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.
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 ?
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))
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
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à
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.
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)
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
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)
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
Le Tout est souvent plus grand que la somme de ses parties.
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)))
PB68
PB68
PB68
Le Tout est souvent plus grand que la somme de ses parties.
Découverte Python Doc Tkinter Les chaînes de caractères