Discussion :

[AlexBsd]

Bonjour,
Je suis lycéen (Terminale S option ISN) et j'ai un devoir sur python à faire pendant les vacances, ce devoir comporte 2 exercices, j'ai réussi à faire le 1er mais je bloque sur le deuxième.

Intitulé de l'exercice :

276 lampes sont numérotées de 1 à 276. Pour passer le temps, 25 enfants appuient sur les interrupteurs à tour de rôle. Le premier enfant presse chaque interrupteur. Le second presse les boutons 2,4,6, etc, (il presse les boutons ayant un numéro multiple de 2). Le troisième appuie sur les boutons 3, 6, 9, etc, (multiples de 3). Le quatrième presse tous les boutons ayant un numéro multiples de 4, et ainsi de suite jusqu'au 25ème enfant. Avant le passage du premier enfant, toutes les ampoules sont éteintes.

Questions :
1. Combien d'ampoules seront allumées après le passage des 25 enfants ?
2. Proposer une évolution du programme permettant à l'utilisateur de faire varier le nombres d'enfants.
3. Proposer une évolution du programme permettant à l'utilisateur de faire varier le nombre d'ampoules.

Cela ne fait que 2 mois que nous voyons les bases de python, et j'avoue que pour cet exercice je bloque totalement, je ne sais pas par où commencer.
Cependant, voici ce qui je pense est un début d'idée (mais je sais pas l'exprimer en langage python) :
0 serait la valeur d'une ampoule éteinte et 1 une ampoule allumée.
Il faudrait une liste de 276 ampoules éteintes (donc 0)
Chaque enfant donnerait à la valeur 0 ou 1 son inverse, c'est à dire 1 ou 0. (Une histoire de boléen ça non?)
Par contre je sais pas vraiment (même pas du tout) comment programmer les enfants qui interviennent dans la liste
Enfin à la fin du programme il faudrait un compteur du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
a=0
for i in (liste de 0 et de 1):
 
                if i==1           #donc ampoule allumée
                a = a+1
 
print a                      #qui normalement nous donnerais le nombre d'ampoules allumées

Etant donné que je bloque dès la question, je plante carrément en lisant les 2 autres, mais je pense que après avoir réussi la question 1 ce sera plus simple d'identifier la fonction de chaque ligne du code.
Voilà voilà c'est tout, j'espère vraiment que vous m'aiderez (avec indulgence svp je suis débutant )

Merci!

[wiztricks]

Salut,

Il faut apprendre à utiliser les "booleans":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> ampoules = [False,False,False,False]
>>> ampoules[0] = not ampoules[0]
>>> ampoules
[True, False, False, False]

Puis écrire des boucles, ce qui a votre niveau passe par des boucles while:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
>>> while i < len(ampoules):
...       ampoules[i] = not ampoules[i]
...       i = i + 1
...
>>> ampoules
[False, True, True, True]

Là, on a déjà l'élève qui allume ou éteins toutes les ampoules.
Pour sauter de 2 en 2 ou de 3 en 3, il suffit d'ajouter 2 ou 3 à la place de 1

Voilà, pour le reste, ce n'est qu'en essayant de faire l'exercice que vous allez progresser...

- W

[tyrtamos]

Bonjour,

Ça, c'est un chouette exo! Voilà un coup de pouce.

Au départ, on a 276 lampes éteintes. On peut les représenter par une liste de 277 booléens False (éteinte=False, allumée=True) dont on n'utilisera pas la 1ère valeur d'index 0. On peut ainsi numéroter les lampes dans la liste avec les index 1, 2, 3, ... 276.

On va aussi numéroter les élèves et, en fonction de leur numéro, voir quelles lampes vont changer d'état:

l'élève 1 => 1, 2, 3, 4, 5, ...
l'élève 2 => 2, 4, 6, 8, 10, ...
l'élève 3 => 3, 6, 9, ...
...
l'élève 25 => 25, 50, 75, 100, ...

Si on veut appeler l'élève par son index i (i=1 à 25), il changera les lampes d'index: i, 2*i, 3*i, 4*i, 5*i, ...

A chaque fois qu'une lampe doit être changée on peut utiliser "not" pour inverser sa valeur (puisque not True => False et not False=> True).

On aura donc une 1ère boucle 'for' pour les 25 élèves (=> range(1,26)), et à l'intérieur une 2ème boucle 'for' qui changera l'état des bonnes lampes en fonction du numéro i de l'élève (=> range(i, 277, i)).

A la fin, on peut compter le nombre de lampes allumées dans la liste avec la méthode count: si je ne me suis pas trompé, il y en aura... 154.

Avec ça, tu devrais pouvoir faire le boulot!

[AlexBsd]

Merci beaucoup pour vos réponses !

Effectivement wiztricks j'ai réussi à comprendre que cela se jouerai avec les boléens, c'est pourquoi, pour créer la liste de 276 ampoules éteintes j'ai écrit le petit bloc suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Ampoules=[False]
while len(Ampoules)<276:
    Ampoules= Ampoules + [False]

Ensuite pendant la soirée j'ai essayé tout plein d'opérations sur cette liste pour essayer d'en comprendre les propriétés. Notamment, j'ai vu dans mon cours qu'on pouvait demandé d'afficher les termes de la suite avec un certain pas, en effet on note nomdelaliste[premierterme :dernierterme :pas]. De ce fait, j'ai fait quelques tests pour l'élève 1 (en me disant qu'en trouvant pour l'élève 1 cela allait m'éclairer pour les autres), avec cette histoires de pas, je me suis dit qu'on pouvait créer une boucle "for ... in ...:" où la variable sauterait de 2 en 2 si l'on choisissait 2 comme pas ou de 100 en 100 si l'on choisissait 100. Bref jusque là rien de sorcier car je l'avais déjà fait en écrivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for i in range(0, len(variable), lefameuxpas)

Je me suis donc dit que c'était possible d'assembler ces deux propriétés et de créer cette boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for i in Ampoules[0 :len(Ampoules) :1]

par exemple, pour le premier élève.
Ensuite j'ai compléter cette boucle en écrivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
for i in Ampoules[0 :len(Ampoules) :1]:
    if Ampoules[i]==[True]:
        Ampoules[i]=[False]
 
    elif Ampoules[i]==[False]:
        Ampoules[i]=[True]

Et pour l'instant je n'allait pas plus loin, je faisais juste afficher la liste Ampoules pour voir les changements, sauf que là, problème, la liste était toujours composée de 276 False.

J'ai donc cherché d'autre solutions en essayant encore pleins de petits trucs (après tout c'est en pratiquant qu'on apprend non?),
et je savais que si je faisais par exemple Ampoules[2]= "test", le terme ayant pour index 2 dans la liste Ampoules allait devenir "test".
Je me suis dit que je pouvais donc tout simplement écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Ampoules[0 :len(Ampoules) :25]= not(Ampoules[0 :len(Ampoules) :25])   #Par exemple pour l'enfant 25

Sauf que non, ça marche pas.

Bref tout ça pour vous dire que j'ai essayé plein de choses mais bon au final j'ai pas trouvé...

Merci Tyrtamos pour ta réponse qui m'aide à visualiser l'ensemble (c'est d'ailleurs à peu près la même explication que mon père sauf que toi tu ajoutes les fonctions correspondantes alors ça m'aide vraiment merci)!
Je continue mes essais demain et je posterai un message de mon avancée

[VinsS]

Salut,

Comme l'énoncé est plaisant, Mon petit doigt me dit que Tyrtamos a griffonné quelques codes pour rechercher la méthode de résolution la plus simple.

Moi aussi bien sûr, et j'obtiens une résolution en quatre lignes de code plus deux print de contrôle.

Un conseil : rester le plus simple.

[tyrtamos]

Bonjour VinsS,

j'obtiens une résolution en quatre lignes de code plus deux print de contrôle.

Pareil!

[AlexBsd]

Salut!
Ca y est je m'y suis remis un peu ce matin en lisant attentivement ton message Tyrtamos et je pense avoir réussi, en plus en proposant directement l'évolution du programme qui permet de faire varier le nombre d'ampoules et d'enfants!
Cependant, j'ai pas réussi à le faire en 4 lignes
Donc voilà ce que j'ai écrit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
n1= input("Nombre d'ampoules : ")
n2= input("Nombre d'enfants : ")
 
 
Ampoules=[False]
while len(Ampoules)<(n1+1):
    Ampoules= Ampoules + [False]    #Liste de (n1+1) Ampoules eteintes, pour ne pas utiliser le boleen d'index 0
 
for a in range(1,(n2+1)):
    for b in range(a, len(Ampoules), a):
        Ampoules[b]= not(Ampoules[b])       # Bloc qui eteint/allume les ampoules
 
a=0
for i in Ampoules[1::]:
    if i==True:
        a=a+1                       #Bloc compteur d'ampoules allumees
 
print "Le nombre d'ampoules allumees est", a

Je vous laisse l'essayer et me prévenir si vous y trouvez une erreur
Et ensuite, bien que mon prof (je pense) n'attend pas un perfectionnement total, j'aimerais bien voir votre version en 4 lignes s'il vous plaît
Merci beaucoup!

[wiztricks]

Salut,

Je me suis dit que je pouvais donc tout simplement écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Ampoules[0 :len(Ampoules) :25]= not(Ampoules[0 :len(Ampoules) :25])   #Par exemple pour l'enfant 25

Sauf que non, ça marche pas.

Ca fonctionne mais il faut apprendre à le faire marcher

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> L = [ True, ] * 10
>>> ampoules = [ True, ] * 10
>>> ampoules[0:-1:2] = False
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must assign iterable to extended slice
>>>

L'erreur dit qu'on doit assigner autant d'éléments. Ce qui peut se faire avec une construction comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> ampoules[0:-1:2] = (not e for e in ampoules[0:-1:2])
>>> ampoules
[False, True, False, True, False, True, False, True, False, True]
>>>

Mais il faut voir ce genre de construction non comme "solution" mais comme façon rapide d'exprimer/coder ses itérations. Et comme vous débutez, il faut vous appliquer à comprendre ce que sont les itérations/boucles (plutôt que de rechercher les différents styles permettant de les exprimer).
Ce qui commence par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
i = 0 # initialisation
while i < N:   # test de fin
        # on fait des choses
        i = i + 1   # on incrémente pour passer au suivant

Et la difficulté de votre exercice est que vous devez imbriquer 2 itérations/boucles.

En Python, on préférera remplacer ces 3 instructions par un "for i in range(N):", çà fait la même chose. Et outre que ce soit plus concis, çà évite d'oublier l'initialisation, l'incrémentation,... et permet au programmeur de se concentrer sur ce que fait la boucle plutôt que sur les détails de construction de la boucle (la gestion de l'index).

- W