Bonjour,

la simple écriture de U(n) qui ne veut rien dire du tout..
tu dois utiliser une simple variable de nom constant et fixe tout simplement "U"

c'est son contenu qui va varier et qui prendra successivement les valeurs "mathématiquement" appelées U(n)

ne pas confondre variable et contenu de cette variable.

après il y a très certainement d'autres "détails" faux dans la syntaxe spécifique à la TI 82

en particulier la portée du test et la portée de la boucle (les instructions End)
quelles sont exactement les instructions qui sont exécutées dans la boucle
quelles sont exactement les instructions qui sont exécutées si le test est vrai ..
(pas ce que tu aimerais, mais ce que la TI fait en suivant sa syntaxe précise)

de plus cela me semble bien maladroit de continuer à calculer des trucs inutiles après la première valeur trouvée pour n
(vu qu'on demande juste la plus petite valeur "qui..." et pas toutes le valeurs "qui..." )

donc la boucle "pour" est certainement mauvaise dès le départ. (une boucle "tant que" alias "while" serait plus appropriée)

Bonsoir, le problème est que tu mets une boucle for alors que tu ne sais pas le nombre d'itérations qu'il faut pour dépasser A.
le reste est aussi n'importe quoi, ton n ne change jamais de valeur. U(n) ne veut rien dire.
la logique de l'algorithme aurait dû être :

: Input A
: 0 n
: 60000 U
: While U < A
: -15 000*0.8^n+75 000 U
: n+1 n
: End
: Disp "n=",n

L'algorithme que vous avez donné ne marche pas. La calculatrice marque: "ERRATA TYPE" et je ne sais pas quel est le problème.

(excusez-moi pour le 60000 mais dans mon devoir maison cela était écrit de la sorte : 60 000)  

Oui je m'excuse encore pour cette faute.

Pourrais-je avoir d'autres renseignements pour mon algorithme s'il vous plaît ?

tu as essayé ce que je répète : pas d'espace dans les nombres, dans aucun nombre ?

Oui je n'ai pas mis d'espace dans les nombres

alors je ne sais pas
il faut un spécialiste de la TI 82 ...

D'accord, merci quand même de votre aide.

Il y aurait-il quelqu'un d'autre pour m'aider ?

J'ai modifié mon algorithme, le voici:

: Prompt A
: 0-->n
: While u supérieur ou égal à A
: -15000*0,8^n+75000-->u
: n+1-->n
: Disp n
: End

Mais cette fois-ci quand je test l'algorithme la calculatrice me marque DONE sans résultat. Quel est le problème ?

Merci d'avance de votre aide.

il faut que tu donnes une valeur à u avant de rentrer dans le while
c'est pour ça que dans mon algorithme il y avait : 60000 --> U
et puis il faut mettre : While U < A
car on continue tant que l'on est inférieur et on s'arrête quand on dépasse.
mais sinon je te fais remarquer que ton algorithme est le même que le mien.

le problème est que u n'est pas initialisée
et donc au moment du "while" il ne sait pas répondre s'il faut ou pas faire quoi que ce soit
et donc il répond "faux" et ne fait rien du tout (et donc passe directement au "End")

de plus de toute façon le while ça veut dire "tant que on n'a pas fini"

et la condition "on n'a pas fini" est bien que la suite est encore inférieure à A

de plus à mon avis le Disp n doit être en dehors de la boucle (sinon il va te cracher un tas de valeurs dont seule la dernière est ce qu'on cherche)
ce qui redonne l'algorithme donné par Glapion ou presque !!!
il n'y a pas à en démordre

: Prompt A
: 1-->n mettre 0 au départ ferait calculer 0,8^0 et pas sûr que la TI aprécie
: 60000-->u une valeur quelconque dont on sait qu'elle est < A (parce que l'énoncé dit que A est entre 60000 et 75000)
on pourrait tout aussi bien mettre 0-->u ça ferait pareil
mais de toute façon u doit avoir été initialisé par quelque chose
: While u inférieur ou égal à A tant que on n'a pas fini, tant que u est encore trop petit
: -15000*0.8^n+75000-->u 0,8 "légal" s'écrit très certainement 0.8 (point décimal et pas virgule)
: n+1-->n
: End ce end définit la fin de ce qu'on exécute à chaque boucle, ou une syntaxe spécifique pour dire la fin du While
: Disp n le disp est quand on a fini de chercher
: End je ne connais pas la TI mais ce End là s'il est nécessaire (?) veut dire la fin de l'algorithme complet

et ton erreur initiale de valeurs illégales est peut être due à ce n = 0 au départ (il ne sait pas calculer 0.8^0 ??)
ou bien à la virgule décimale à la place d'un point décimal.

oui c'est peut-être le n=0 du départ qui fait que ça ne marchait pas.

Autre problème, quand je rentre une valeur quelconque (compris entre  60000 et 75000) pour tester l'algorithme la calculatrice affiche toujours le même résultat c'est-à-dire 60000.

le même écrit en Algobox

***Algorithme lancé***
Entrer A : 65000
3
***Algorithme terminé***

***Algorithme lancé***
Entrer A : 72000
9
***Algorithme terminé***$

après j'ai pas vérifié que ces valeurs étaient justes non plus, hein ...
mais elle n'ont rien à voir avec ton 60000 constant
tu dois certainement encore avoir une "faute de frappe" quelque part dans ton algo.
(un u à la place d'un n ou le contraire par exemple)

Oui mais quand je teste l'algorithme sur Algobox, il y a toujours une même valeur qui s'affiche : c'est 2.

pareil tu dois avoir une erreur de frappe,

et sur algobox 0.8^n ne veut pas du tout dire ce que tu crois

0.8 à la puissance n s'écrit pow(0.8,n)

Mais quand je rentre 63000, l'algorithme donne 3.

Est-ce quand même juste ?

bein tu peux vérifier à la main (à la calculette ordinaire) en calculant u(2) et u(3)

si u(2) < 63000 u(3) c'est juste

sinon c'est faux

et comme on a u(2) = 65400 > 63000 c'est donc faux
la réponse juste est n = 1 puisque u(0) = 75000 - 15000*0.8^0 = 75000 - 15000 = 60000 et u(1) = 63000 (calcul laissé au lecteur)
le plus petit n pour lequel u(n) 63000 est donc 1

comme je le disais : d'où peut bien venir le décalage de 1 ? et même dans ce cas un décalage de 2 !!

en fait on calcule u(n)
puis on augmente n de 1 de sorte que ce qu'on affichera à la fin c'est n+1 et pas le n qui a servi à calculer u(n)

la correction est simple : il suffit d'inverser le calcul de u et l'incrémentation de n
et donc pour éviter d'en rater au début, d'initialiser n à 0
comme on commence par incrémenter n, on n'aura pas de problème de 0.8^0, on commence toujours par calculer 0.8^1


reste le décalage supplémentaire de encore 1 de plus (dans ce cas particulier de A = 63000 on a un décalage de 2 !!)

dans le tant que / while il faut mettre strictement inférieur vu que la condition "c'est fini" est > ou égal (énoncé)
la condition "c'est pas fini" est donc strictement <
le contraire de est <, pas

algorithme corrigé (version calculette)

: Prompt A
: 0-->n
: 60000-->u
: While u < A
: n+1-->n
: -15000*0.8^n+75000-->u
: End
: Disp n

moyennant la syntaxe exacte de la TI bien entendu

Merci beaucoup de votre aide, L'algorithme marche.

Bonne soirée et bon nouvel an.

je ne vois pas bien la différence avec celui de mon post du 30-12-15 à 17:56
mais bon

l'inversion de n+1-->n avec
formule-->u

sans cette modif, il y a un décalage de 1 systématique entre la valeur de n affichée et la vraie calculée à la main directement et qui correspond exactement à l'énoncé demandé.
(voir les copies de résultats et le pourquoi du comment)

de plus avec cet algorithme on doit initialiser u à la valeur u(0) = 60000

une "amélioration" consiste à ne pas calculer à la main u(0) = 60000 et de laisser faire la machine :

: Prompt A
: -1-->n de sorte que la première valeur calculée est pour n = 0
: 0-->u valeur < quelque valeur de A que ce soit
: While u < A
: n+1-->n
: -15000*0.8^n+75000-->u
: End
: Disp n

à condition que le calcul de 0.8^0 marche
(ça marche sous Algobox avec pow(0.8, n) qui rend bien 1 si n = 0)