Algobox soucis programme boucles

Résolu
Bonjour,

Je me suis lancé dans un programme pour un DM en Terminal S.
Trouver un programme qui donne Un.
On a U0=1 et Un+1 = 1/(1+3*Un)

Je pense que le programme est juste:

1 VARIABLES
2 n EST_DU_TYPE NOMBRE
3 k EST_DU_TYPE NOMBRE
4 x EST_DU_TYPE NOMBRE
5 DEBUT_ALGORITHME
6 LIRE n
7 k PREND_LA_VALEUR 1
8 TANT_QUE (k<=n) FAIRE
9 DEBUT_TANT_QUE
10 x PREND_LA_VALEUR k
11 k PREND_LA_VALEUR 1/(1+3*x)
12 FIN_TANT_QUE
13 AFFICHER k
14 FIN_ALGORITHME

Et paf !!

Algorithme interrompu ligne xx 12 : dépassement de la capacité autorisée pour les boucles

J'avais déjà fait un programme avec Pour ... Jusqua en pensant que c'était juste, même soucis niveau de la boucle.

Alors mon programme est-il faux ou c'est le logiciel?

12 réponses

  1. Modérateur
    Moi je n'ai rien testé du tout, je n'ai pas Algobox, et d'ailleur je ne garantit pas que mon code soit effectivement correct, c'est le principe qui compte ;-)

    Si je comprend bien Algobox que je ne connais pas du tout, pour n=0 ta boucle POUR va faire un calcul à reculons pour aller de 1 à 0, tu vas donc faire un calcul et obtenir la valeur de U1=0.25 !

    Dans ce cas la boucle TANT_QUE (k<=n) était peut-être plus adapté que la boucle POUR, je te laisse essayer, normalement les premières valeurs sont 1, 0.25, 0.571, 0.368, 0.475... le tout convergeant à l'infini vers (RacineCarré(13)-1)/6 = 0.434258454591...
    1. Oula j'avais fait un erreur.

      Gros merci à toi l'ami, je te dois quelques points sur le coup (j'ai quand même chercher 2 heure et j'étais pas si loin c'est juste que je mettais k de 0!!! à n au lieu de 1 à n.

      Merci pour tout. Je vais me reposer les méninges maintenant. Bonne soirée.
      1. Merci pour cette explication.
        Je pense au final que le problème viens de mon logiciel car là en utilisant ce que tu me propose il me donne les mêmes résultats qu'avant (exemple pour n=0 Uk=0.25 au lieu de 1).
        Pourrais-tu vérifier si chez toi il fonctionne, histoire de voir si le problème vien de moi (j'utilise Algobox c'est peut-être là le soucis??)
        1. Modérateur
          Tu prends une variable Uk qui sera ton résultat final à afficher.
          Pour k=0, au tout début donc, tu as Uk=U0=1 au vu de ton problème.
          Après pour k qui va de 1 (on a déjà réglé le cas 0) à n, tu fais ton calcul Uk=1/(1+3.Uk) et une fois que tu as égrainé tous les k, tu te retrouves donc avec Un que tu cherchais...

          VARIABLES
          
          	n EST_DU_TYPE NOMBRE
          	k EST_DU_TYPE NOMBRE
          	Uk EST_DU_TYPE NOMBRE
          
          DEBUT_ALGORITHME
          
          	LIRE n
          
          	Uk PREND_LA_VALEUR 1
          
          	POUR k ALLANT_DE 1 A n
          	DEBUT_POUR
          		Uk PREND_LA_VALEUR 1/(1+3*Uk)
          	FIN_POUR
          
          	AFFICHER Uk 
          
          FIN_ALGORITHME
          La confiance n'exclut pas le contrôle
          1. C'est ce que je croyais faire mais au final c'est vrai que c'est stupide ce que je fais.
            Le truc c'est que je ne sais pas faire.
            Pourrais-tu m'expliquer brièvement? Je me débrouillerais après je penses :) .
            1. Modérateur
              Tu mélanges k et U0. Quand tu calcules U0, U1... Uk... Un, c'est k que tu fais varier de 0 à n, pas Uk ! La formule avec Uk tu l'as c'est Uk+1 = 1/(1+3*Uk) donc tu ne dois pas modifier k, mais Uk au fur et à mesure.
              1. Ben x c'est une mémoire pour permettre de calculer

                U0
                U1
                U2
                U3
                etc etc
                Non?
                Il faudrait que je change quoi?
                J'ai modifier un peu mais c'est toujours pas ce que je recherche :

                1 VARIABLES
                2 n EST_DU_TYPE NOMBRE
                3 U0 EST_DU_TYPE NOMBRE
                4 k EST_DU_TYPE NOMBRE
                5 x EST_DU_TYPE NOMBRE
                6 DEBUT_ALGORITHME
                7 LIRE n
                8 k PREND_LA_VALEUR 1
                9 POUR U0 ALLANT_DE 0 A n
                10 DEBUT_POUR
                11 U0 PREND_LA_VALEUR 0
                12 x PREND_LA_VALEUR k
                13 k PREND_LA_VALEUR 1/(1+(3*x))
                14 FIN_POUR
                15 AFFICHER k
                16 FIN_ALGORITHME

                PS/ les lettre de l'algo ne corresponde a rien c'est juste de variable hein ^^!
                1. Modérateur
                  C'est parce que tu confond k et Un donc pour toi Uk=k ce qui est absurde !
                  Il ne te faut pas une autre variable, mais juste que tu comprennes à quoi te sert x...
                  1. Le problème c'est que j'ai fait un autre programme :

                    VARIABLES
                    2 n EST_DU_TYPE NOMBRE
                    3 U0 EST_DU_TYPE NOMBRE
                    4 k EST_DU_TYPE NOMBRE
                    5 x EST_DU_TYPE NOMBRE
                    6 DEBUT_ALGORITHME
                    7 LIRE n
                    8 k PREND_LA_VALEUR 1
                    9 POUR k ALLANT_DE 0 A n
                    10 DEBUT_POUR
                    11 x PREND_LA_VALEUR k
                    12 k PREND_LA_VALEUR 1/(1+3*x)
                    13 FIN_POUR
                    14 AFFICHER k
                    15 FIN_ALGORITHME

                    Bon au final je crois qu'en fait il me faut une autre variable.

                    Vous pourriez m'éclaircir?
                    La il me donne quand n=0 k (donc Un) = 2 au lieu de 1 ^^
                    1. Modérateur
                      C'est ton programme... k doit être incrémenté de 1 en 1 pour atteindre n, or vu l'affectation que tu lui donnes, k est toujours inférieur à n, donc ton programme ne se termine jamais... enfin si, quand le nombre de boucles autorisées est dépassé !La confiance n'exclut pas le contrôle
                      1. Je précise qu'il arrive a calculer U0=1 (donc n=0) et après il plante comme décrit ci dessus a partir de n=1 donc.