Inscription / Connexion Nouveau Sujet
Programme
Bonjour tout le monde,
J'ai besoin d'aide sur un devoir :
On me demande de créer un programme sur ma calculatrice (la mienne est une TI-82 advanced) tel que si on prend deux nombres distincts d'une liste compris entre 1 et 30 inclus, on fait leur somme, puis qu'on mette ce nombre dans cette liste. On nous demande de recommencer l'opération jusqu'à ce qu'il ne reste plus qu'un seul nombre dans cette liste et que la calculatrice affiche le résultat.
Merci d'avance
PS : Excusez-moi d'avance si jamais les questions sur la programmation sont interdites ici.
Bonjour,
Je ne comprends pas tout :
- tu ajoutes à chaque fois la sommes des deux nombres dans une seconde liste?
- comment peux-tu avoir un seul nombre restant dans la liste de départ, vu que tu les prends par paires et que tu en as 30 au début?
- quel résultat dois-tu afficher à la toute fin du programme?
Je n' ai pas compris...
Ce que je ne comprends pas très bien, dans cet énoncé,
c'est le truc de remettre "ce nombre dans cette liste".
On le remet à quelle position dans la liste ?
En fait, je veux prendre deux nombres distincts au hasard de la liste {1,2,...30}, les supprimer et faire leur somme pour ensuite la rajouter dans la liste. Par exemple, si je prends 9 et 26, je vais obtenir la liste {1,2,...,8,10,...,25,27,...30, 35}. On me demande ensuite de répéter l'opération, et à la fin on devrait tomber sur un seul nombre (vu qu'on en élimine un à chaque fois), et on nous demande alors de déterminer ce nombre
Avant que tu écrives ton programme pour ta TI-82, on peut t' aider pour l'algorithme, mais il faut qu'on comprenne les choses qu' il y a à faire 
Bonjour,
si on retire deux nombres de la seule et unique liste et qu'on en rajoute un (leur somme) le nombre d'éléments de la liste a diminué de 1
par contre ce qui n'est pas clair du tout c'est quelle est la liste au départ et quelles paires de nombres on choisit à chaque étape !!
PS : (ou ce qui revient un peu au même au mème à quel endroit on remet la somme)
En gros, j'ai effacé les nombres que j'ai pris, et j'ai remis leur somme dans cette liste, l'ordre n'étant pas important
pas tout à fait vu,
OK on les choisit au hasard et on met la somme n'importe où.
mais deux nombres distincts au hasard
au bout de quelques opérations, on risque fort de ne plus avoir que des nombres distincts ...
et même au bout d'un certain temps on risque même de n'avoir peut être que des nombres égaux !
quid ?
"de ne plus avoir que des nombres distincts ... "
expression grammaticalement douteuse
"que certains soient égaux" voulais-je dire
Dsl, quand je disais distincts, c'est seulement pour la première opération, vu qu'ils sont tous distincts au début... Pour l'algorithme, je n'ai aucune idée de comment choisir mes nombres au hasard, et surtout pour la boucle que je dois former.
Choisir deux nombres au hasard dans une liste c'est choisir deux indices distinct au hasard (entre 0 et la taille de la liste-1)
c'est à dire un nombre i entre 0 et n-2 inclus
un nombre j entre i+1 et n-1 inclus
et les deux nombres de la liste seront T[i] et T[j]
reste à savoir comment on retire deux nombres d'une liste et comment on en ajoute un
la boucle est une boucle "tant que la taille de la liste est > 1"
Ben, on ne dit pas dans l'énoncé qu'on choisit au hasard.
On peut donc faire simple ou compliqué.
Une manière de faire, entre d'autres :
On fait la somme du dernier de la liste avec l'avant dernier
de la liste, et on met le résultat à la place de l'avant-dernier,
on réduit ensuite la longueur de la liste de 1
puis on recommence…
certes, "au hasard" c'était pour répondre à Nekromancian
mais comme le résultat final ne dépend pas de l'ordre dans lequel on choisit les nombres ...
J'avais aussi pensé à faire comme pgeod, mais je n'ai aucune idée de comment choisir ces nombres, et encore moins comment mettre leur somme dans la liste. Et merci à mathafou pour la boucle
Bonjour.
En Python, ça donnerait cela :
Script :
#*******************************************************************************
# IMPORT ***********************************************************************
#*******************************************************************************
# module pour le systeme d'exploitation
import os
# module specifique pour le systeme
import sys
# acces au module 'aleatoire'
from random import *
#*******************************************************************************
# MAIN *************************************************************************
#*******************************************************************************
# effacement de l'ecran
os.system('cls')
print("\n")
# creation d'une liste des nombres de 1 a 30
liste = list(range(1, 30 + 1))
print(" somme attendue : %d\n" % sum(liste))
# nombre de boucle
boucle = 0
# boucle
while len(liste) >= 2 :
print(" boucle : %2d liste : %s" % (boucle, repr(liste)))
# indice du 1er nombre
indice_1 = randint(0, len(liste) - 1)
# 1er nombre
nombre_2 = nombre_1 = liste.pop(indice_1)
print(" ind_1 : %2d n_1 : %2d" % (indice_1, nombre_1))
print(" : %2d liste : %s" % (boucle, repr(liste)))
# nombres distincts ?
while nombre_2 == nombre_1 :
# non : recherche d'un autre nombre
# indice du 2e nombre
indice_2 = randint(0, len(liste) - 1)
# 2e nombre
nombre_2 = liste.pop(indice_2)
print(" ind_2 : %2d n_2 : %2d\n" % (indice_2, nombre_2))
# addition des 2 nombres
somme = nombre_1 + nombre_2
# sauvegarde de la somme dans la lise
liste.append(somme)
# incrementation du nombre de tour
boucle += 1
print(" boucle : %2d liste : %s\n\n" % (boucle, repr(liste)))
print(" FIN : somme = %d\n\n" % somme)
A l'exécution :
somme attendue : 465
boucle : 0 liste : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
ind_1 : 18 n_1 : 19
: 0 liste : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
ind_2 : 4 n_2 : 5
boucle : 1 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 24]
ind_1 : 19 n_1 : 22
: 1 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 24]
ind_2 : 10 n_2 : 12
boucle : 2 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 24, 34]
ind_1 : 23 n_1 : 28
: 2 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 23, 24, 25, 26, 27, 29, 30, 24, 34]
ind_2 : 16 n_2 : 20
boucle : 3 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 21, 23, 24, 25, 26, 27, 29, 30, 24, 34, 48]
ind_1 : 25 n_1 : 34
: 3 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 21, 23, 24, 25, 26, 27, 29, 30, 24, 48]
ind_2 : 23 n_2 : 30
boucle : 4 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 21, 23, 24, 25, 26, 27, 29, 24, 48, 64]
ind_1 : 15 n_1 : 18
: 4 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 21, 23, 24, 25, 26, 27, 29, 24, 48, 64]
ind_2 : 17 n_2 : 24
boucle : 5 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 21, 23, 25, 26, 27, 29, 24, 48, 64, 42]
ind_1 : 22 n_1 : 48
: 5 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 21, 23, 25, 26, 27, 29, 24, 64, 42]
ind_2 : 23 n_2 : 42
boucle : 6 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 21, 23, 25, 26, 27, 29, 24, 64, 90]
ind_1 : 14 n_1 : 17
: 6 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 21, 23, 25, 26, 27, 29, 24, 64, 90]
ind_2 : 11 n_2 : 14
boucle : 7 liste : [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 15, 16, 21, 23, 25, 26, 27, 29, 24, 64, 90, 31]
ind_1 : 4 n_1 : 6
: 7 liste : [1, 2, 3, 4, 7, 8, 9, 10, 11, 13, 15, 16, 21, 23, 25, 26, 27, 29, 24, 64, 90, 31]
ind_2 : 14 n_2 : 25
boucle : 8 liste : [1, 2, 3, 4, 7, 8, 9, 10, 11, 13, 15, 16, 21, 23, 26, 27, 29, 24, 64, 90, 31, 31]
ind_1 : 6 n_1 : 9
: 8 liste : [1, 2, 3, 4, 7, 8, 10, 11, 13, 15, 16, 21, 23, 26, 27, 29, 24, 64, 90, 31, 31]
ind_2 : 7 n_2 : 11
boucle : 9 liste : [1, 2, 3, 4, 7, 8, 10, 13, 15, 16, 21, 23, 26, 27, 29, 24, 64, 90, 31, 31, 20]
ind_1 : 8 n_1 : 15
: 9 liste : [1, 2, 3, 4, 7, 8, 10, 13, 16, 21, 23, 26, 27, 29, 24, 64, 90, 31, 31, 20]
ind_2 : 12 n_2 : 27
boucle : 10 liste : [1, 2, 3, 4, 7, 8, 10, 13, 16, 21, 23, 26, 29, 24, 64, 90, 31, 31, 20, 42]
ind_1 : 7 n_1 : 13
: 10 liste : [1, 2, 3, 4, 7, 8, 10, 16, 21, 23, 26, 29, 24, 64, 90, 31, 31, 20, 42]
ind_2 : 1 n_2 : 2
boucle : 11 liste : [1, 3, 4, 7, 8, 10, 16, 21, 23, 26, 29, 24, 64, 90, 31, 31, 20, 42, 15]
ind_1 : 10 n_1 : 29
: 11 liste : [1, 3, 4, 7, 8, 10, 16, 21, 23, 26, 24, 64, 90, 31, 31, 20, 42, 15]
ind_2 : 3 n_2 : 7
boucle : 12 liste : [1, 3, 4, 8, 10, 16, 21, 23, 26, 24, 64, 90, 31, 31, 20, 42, 15, 36]
ind_1 : 10 n_1 : 64
: 12 liste : [1, 3, 4, 8, 10, 16, 21, 23, 26, 24, 90, 31, 31, 20, 42, 15, 36]
ind_2 : 13 n_2 : 20
boucle : 13 liste : [1, 3, 4, 8, 10, 16, 21, 23, 26, 24, 90, 31, 31, 42, 15, 36, 84]
ind_1 : 15 n_1 : 36
: 13 liste : [1, 3, 4, 8, 10, 16, 21, 23, 26, 24, 90, 31, 31, 42, 15, 84]
ind_2 : 8 n_2 : 26
boucle : 14 liste : [1, 3, 4, 8, 10, 16, 21, 23, 24, 90, 31, 31, 42, 15, 84, 62]
ind_1 : 12 n_1 : 42
: 14 liste : [1, 3, 4, 8, 10, 16, 21, 23, 24, 90, 31, 31, 15, 84, 62]
ind_2 : 10 n_2 : 31
boucle : 15 liste : [1, 3, 4, 8, 10, 16, 21, 23, 24, 90, 31, 15, 84, 62, 73]
ind_1 : 8 n_1 : 24
: 15 liste : [1, 3, 4, 8, 10, 16, 21, 23, 90, 31, 15, 84, 62, 73]
ind_2 : 9 n_2 : 31
boucle : 16 liste : [1, 3, 4, 8, 10, 16, 21, 23, 90, 15, 84, 62, 73, 55]
ind_1 : 1 n_1 : 3
: 16 liste : [1, 4, 8, 10, 16, 21, 23, 90, 15, 84, 62, 73, 55]
ind_2 : 4 n_2 : 16
boucle : 17 liste : [1, 4, 8, 10, 21, 23, 90, 15, 84, 62, 73, 55, 19]
ind_1 : 0 n_1 : 1
: 17 liste : [4, 8, 10, 21, 23, 90, 15, 84, 62, 73, 55, 19]
ind_2 : 8 n_2 : 62
boucle : 18 liste : [4, 8, 10, 21, 23, 90, 15, 84, 73, 55, 19, 63]
ind_1 : 9 n_1 : 55
: 18 liste : [4, 8, 10, 21, 23, 90, 15, 84, 73, 19, 63]
ind_2 : 10 n_2 : 63
boucle : 19 liste : [4, 8, 10, 21, 23, 90, 15, 84, 73, 19, 118]
ind_1 : 8 n_1 : 73
: 19 liste : [4, 8, 10, 21, 23, 90, 15, 84, 19, 118]
ind_2 : 0 n_2 : 4
boucle : 20 liste : [8, 10, 21, 23, 90, 15, 84, 19, 118, 77]
ind_1 : 9 n_1 : 77
: 20 liste : [8, 10, 21, 23, 90, 15, 84, 19, 118]
ind_2 : 8 n_2 : 118
boucle : 21 liste : [8, 10, 21, 23, 90, 15, 84, 19, 195]
ind_1 : 4 n_1 : 90
: 21 liste : [8, 10, 21, 23, 15, 84, 19, 195]
ind_2 : 6 n_2 : 19
boucle : 22 liste : [8, 10, 21, 23, 15, 84, 195, 109]
ind_1 : 2 n_1 : 21
: 22 liste : [8, 10, 23, 15, 84, 195, 109]
ind_2 : 1 n_2 : 10
boucle : 23 liste : [8, 23, 15, 84, 195, 109, 31]
ind_1 : 3 n_1 : 84
: 23 liste : [8, 23, 15, 195, 109, 31]
ind_2 : 0 n_2 : 8
boucle : 24 liste : [23, 15, 195, 109, 31, 92]
ind_1 : 2 n_1 : 195
: 24 liste : [23, 15, 109, 31, 92]
ind_2 : 1 n_2 : 15
boucle : 25 liste : [23, 109, 31, 92, 210]
ind_1 : 0 n_1 : 23
: 25 liste : [109, 31, 92, 210]
ind_2 : 0 n_2 : 109
boucle : 26 liste : [31, 92, 210, 132]
ind_1 : 3 n_1 : 132
: 26 liste : [31, 92, 210]
ind_2 : 1 n_2 : 92
boucle : 27 liste : [31, 210, 224]
ind_1 : 2 n_1 : 224
: 27 liste : [31, 210]
ind_2 : 0 n_2 : 31
boucle : 28 liste : [210, 255]
ind_1 : 0 n_1 : 210
: 28 liste : [255]
ind_2 : 0 n_2 : 255
boucle : 29 liste : [465]
FIN : somme = 465
Bonjour,
Peut-être quelque chose comme ça, qu'il restera à peaufiner :
Début
Affecter 30 à N
Tant que N>1
A est un entier aléatoire entre 1 et N (inclus)
B est un entier aléatoire, distinct de A, entre 1 et N (inclus)
S est la somme des éléments d'indices A et B de la liste
Supprimer les éléments d'indices A et B de la liste
Ajouter S à la fin de la liste
Diminuer N de 1
Fin tant que
Afficher le premier élément de la liste
Fin
Cet algorithme est très incomplet. En particulier, il faudrait initialiser la liste avec 30 nombres... Il restera ensuite à programmer ça sur une machine, mais c'est le plus facile.
Désolé, après relecture, il manque une ligne :
# nombres distincts ?
while nombre_2 == nombre_1 :
# non : recherche d'un autre nombre
# indice du 2e nombre
indice_2 = randint(0, len(liste) - 1)
if liste[indice_2] != nombre_1 :
# 2e nombre
nombre_2 = liste.pop(indice_2)A est un entier aléatoire entre 1 et N (inclus)
B est un entier aléatoire, distinct de A, entre 1 et N (inclus)
on risque de tirer par hasard A = B (le même élément au lieu de deux éléments de la liste)
soit on boucle tant que A =B sur le tirage de B (bbomaths
soit on fait comme j'ai dit (pour des indices entre 0 et n-1) :
un nombre i entre 0 et n-2 inclus
un nombre j entre i+1 et n-1 inclus
et les éléments d'indice i et j de la liste sont deux éléments distincts de la liste (même si ils sont égaux
)Pour choisir B, il faut détailler avec une boucle Répéter...jusqu'à B
A. Ça ne pose aucun problème... L'algorithme que j'ai écrit précise bien que B doit être distinct de A. Il appartient au programmeur ensuite de respecter cette consigne
Après réflexion, je crois que je n'avais pas bien compris l'énoncé : je pensais que la liste contenait 30 nombres quelconques et non pas les entiers de 1 à 30. Dans mon esprit, A et B représentaient les rangs des nombres dans la liste et non pas les nombres eux-mêmes. Désolé d'avoir interféré dans ce topic sans avoir bien lu 
non pour moi la liste contient bien 30 nombres quelconques distincts (distincts ou pas d'ailleurs aucune importance)
et oui A et B représentent bien les rangs des nombres et désolé d'avoir lu en diagonale ton algorithme
B est un entier aléatoire, distinct de A, entre 1 et N (inclus)
Personnellement, j'ai compris que les nombres étaient distincts 2 à 2 et compris entre 1 et 30, bornes incluses :
deux nombres distincts d'une liste compris entre 1 et 30 inclus
de toute façon que cette liste contienne 30 nombres quelconques distincts ou les nombres de 1 à 30 ça ne change rigoureusement rien du tout à ce qu'est l'algorithme de traitement de cette liste
("l'énoncé" - hum - ne dit pas de générer cette liste, elle est "préexistante")
et si c'est les nombres de 1 à 30 un tel algorithme est bien inutile vu que le résultat est connu d'avance, c'est 465.
(et pour des nombres quelconques, il peut être simplifié en une simple somme, mais bon ...)
Waaaaaaah, je m'attendais pas à ce genre de réponse... Eh bien vraiment merci à tout le monde, surtout à bbomaths pour son algorithme. J'ai une fiche qui me permet de convertir le langage python en TI basic, je vous remercie du fond du coeur pour ce que vous avez fait
Annuler
connectez vous