salut

z_{n + 1} = (1 + i)/z_n * z_n = 1 + i

Pardon j'ai fait une erreur dans l'énoncé : c'est (1+i)/2 x Zn

bonsoir

je suppose que tu as calculé les premiers termes de la suite;
qu'as-tu trouvé ?

avant de faire l'algorithme, déroule les calculs à la main :

tu peux poser z = a+ib  
et simplifier z * (1+i)/2

quelle expression tu obtiens pour la partie réelle ? pour la partie imaginaire ?
vérifie-les sur les premiers termes calculés précédemment.

quand tu auras ces expressions, l'algo ira tout seul normalement.

Bonjour !
Merci pour la réponse, j'ai calculé les premiers termes :
Z1=1+i
Z2=i
Z3=-1/2 + 1/2i

En développant je trouve (a+ai+ib-b)/2

calculs sont bons

En développant je trouve (a+ai+ib-b)/2
oui, mais poursuis :
partie réelle = ...
partie imaginaire = ...

Partie réelle : (a-b)/2
Partie imaginaire: (a+b)/2

voilà
tu vérifieras que ça fonctionne pour les premiers termes.

on retiendra donc que
si on précise à l'algo les valeurs réelles  a et b  d'un Z_k,
alors l'algo pourra facilement nous retourner les  parties réelle et imaginaire de Z_k+1


ensuite,
je suppose que tu as déjà fait des algorithmes.
tu as une idée pour  la structure de celui-ci ?

Merci pour votre aide !
C'est à ce moment là que j'ai du mal, je ne vois pas comment le rendre en version algorithmique, j'en ai très peu fait avec mon professeur

tu as vérifié sur les premiers termes ?
cette étape est importante, c'est pas juste une vérif de tes calculs.
parce qu'en détaillant les étapes que tu vas faire là,
tu vas mettre le doigt sur ce qu'il faudra faire dans le corps de calcul de l'algorithme.

tu en as fait en seconde et en 1ère.
plusieurs questions à se poser :

- qu'est-ce que je veux en sortie ?
- qu'est-ce que je dois préciser en entrée ?
- de quelles variables je vais avoir besoin ?
- dois-je faire une boucle ? avec quelle condition de sortie ?
- que dois-je faire à l'intérieur de cette boucle ?

tu auras pas mal débroussaillé le terrain après ça.

c'est les vacances, on n'est pas pressés.
je te laisse réfléchir ?

si besoin, tu peux jeter un oeil ici [lien]
en 1er chapitre, un peu de cours et des exemples sur l'algorithmique,
farfouille - ou révise

Merci !
Je vais y réfléchir.
Déjà je sais que je veux la partie réelle et la partie imaginaire. Je dois préciser a et b. J'ai besoin de n aussi .

bon début
je reviens demain
a+

**malou **message modéré **

pzorba75,
penses-tu qu'au bout du compte tu rendes service à mathsssxxx ?

La modération joue son rôle et j'essaie de respecter les règles.

certes, mais je préférerais ne pas avoir à le faire....
(modérateur)

bonjour pzorba75,

je ne doute pas une seconde de ta bonne volonté,
mais le but doit rester d'aider le demandeur à progresser vers l'autonomie,
et l'étape de l'effort de recherche personnelle est incontournable.

si tu en dis trop, même si c'est exact, clairement expliqué, et bien compris par le demandeur,
tu annihiles cet effort, et on prend le risque que face à un problème similaire,
le demandeur ne sache pas adapter et reproduire le raisonnement.

à l'évidence, tu sais faire cet algorithme.
ça signifie qu'à un moment donné sur un exo du même genre, tu as réfléchi sur le comment faire,
et tu l'as assimilé via un effort personnel...

tu vois?
sans rancune.
bonne journée à toi.

_{bonjour malou}

_{bonjour carita de retour chez moi, ai retrouvé mon ordi, ça va mieux !!}

Bonjour !

A nouveau merci pour votre aide.
J'y ai réfléchi et je trouve quelque chose du type :

Lire a
Lire b

R prend la valeur (a-b)/2
I prend la valeur (a+b)/2

Afficher R
Afficher I

soit !
si je fais tourner cet algo à la main :

a=2
b=0    ----- puisque Z₀=2

R prend la valeur (a-b)/2  ----- R =1  affiché
I prend la valeur (a+b)/2  ----- I =1   affiché

donc tu obtiens les parties réelle et imaginaire de Z₁... et après ?
tu as répondu à la question posée par l'énoncé ?

remarque : étant donné que l'on connait déjà les a et b de  Z₀,
est-ce vraiment utile de les demander en saisie en entrée ?

réfléchis un peu plus longtemps
déroule ton algo à la main pour voir s'il "tourne" bien
et si tu obtiens bien les parties et imaginaires de Z_n pour une valeur de n donnée.

Oui d'accord je comprends. Je sais qu'il faut que je fasse une boucle qui met en jeu n. J'essaye de mon côté mais ce n'est pas évident.
Merci beaucoup

Je sais qu'il faut que je fasse une boucle qui met en jeu n.
tout à fait, puisque les termes Z_n sont définis par récurrence.

c'est comme lorsque tu as une suite numérique définie par récurrence :
chaque terme dépend de son précédent.

quand tu as calculé Z₃ au début, comment tu as fait... ?
l'algorithme doit calquer la même procédure.

Z3= (1+i)/2 x Z2

D'accord je vois, je vais essayer de mettre ça en langage algo. j'avoue que j'ai un peu plus du mal parce qu'on manipule des suites de complexe !

Quand tu as des calculs avec des nombres complexes, tu peux te vérifier en utilisant une calculatrice, fonction disponible en mode examen sur TI 83, le i des nombres complexes s'obtient par 2nd + . , il est imprimé j sur le clavier.

J'ai une casio mais je vais regarder ça.
J'ai cherché cette après midi pour l'algorithme et je n'y arrive vraiment pas. Surtout pour la boucle

tu as étudié les exemples et exercices des liens indiqués?
tu as dû repérer sur le cours que tu as 2 types de boucles...
lequel choisirais-tu ?

- combien de fois doit tourner cette boucle ?
- que doit-on faire calculer à l'intérieur de la boucle à chaque fois ?

---

je te propose de réfléchir par exemple pour n=2.
autrement dit pour obtenir Re(Z₂) et Im(Z₂)

écris en liste et en détail toutes les étapes que tu fais pour trouver le résultat à la main,
sans algorithme.

je n'y arrive vraiment pas. Surtout pour la boucle

montre déjà ce que tu as écrit.

Pour k allant de 0 à n
    Si k prend la valeur 0 alors
R prend la valeur 2
I prend la valeur 0
    Sinon
R prend la valeur An-1 x (1+i)/2
I prend la valeur Bn-1 x (1+i)/2

Afficher R
Afficher I

Je corrige mon erreur :

Variables : A NOMBRE
                        B NOMBRE
                        k nombre

Lire n

Pour k allant de O à n
    Si k prend la valeur 0 alors
R prend la valeur 2
I prend la valeur 0
    Sinon
R prend la valeur (An-1-Bn-1)/2
I prend la valeur ( An-1+Bn-1)/2

Afficher R
Afficher I

Je l'ai testé normalement il fonctionne

bonjour

tu l'as testé comment ? parce qu'il ne fonctionnera pas.

je détaille :

Variables : A NOMBRE
                        B NOMBRE
                        k nombre
tu utilises aussi les variables R et I...
(note : selon le langage de programmation utilisé ensuite, la déclaration de variables n'est pas utile,
c'est juste pour que tu prennes l'habitude de bien faire l'inventaire des variables dès le début de ta réflexion)

---

Lire n   ---- oui, on a besoin que de "n", puisque les a et b du premier terme sont déjà connus

Pour k allant de 0 à n ---- bon choix de boucle
n'oublie de signaler le "fin pour" pour délimiter sur l'algorithme  ce qui fait partie de la boucle.
selon le langage de programmation utilisé ensuite, ce "fin pour" n'est pas traduit,
mais sur l'algo, il permet de bien cadrer le groupe d'instructions à répéter.

mais, pourquoi de 0 à n ?
pour calculer Z2, par exemple, donc n=2 combien de boucles tu devras "faire tourner" ?

---

R prend la valeur 2
I prend la valeur 0  ---  pourquoi affecter 2 et 0 à R et I?

---

le test si/sinon n'a aucun intérêt ici, surtout à l'intérieur de la boucle

---

R prend la valeur (An-1-Bn-1)/2
I prend la valeur ( An-1+Bn-1)/2 ---- d'où tu nous sors ces variables  indicées?
la machine est bête - et parfois méchante
tu lui dis de réserver une boite simple appelée A pour y ranger un nombre (=déclaration de variable...)
et tu lui parles ensuite de An-1 : elle ne connait pas...

---

dérouler l'algo à la main, c'est :
- dresser un tableau avec en colonnes autant de variables que tu en as déclarées
- dérouler ligne après ligne ton algo, crayon en main, en remplissant le tableau à chaque fois
- si tu as choisi n=2, vérifier qu'en suivant fidèlement l'algo (pas en lui forçant la main comme avec tes indices...), tu trouveras bien les éléments de Z2.

--

note : une variable ne peut contenir qu'une seule valeur à la fois.

ex:
a prend la valeur 2  ---> dans la 'boite' appelée a, il y aura le nombre 2
a prend la valeur a+1 -->  dans la 'boite' appelée a, il y aura le nombre 3 (le 2 a disparu)

je préférais ton :
                                 R prend la valeur (a-b)/2
                                  I prend la valeur (a+b)/2
de 22-10-19 à 10:46

Bonjour,

Variables : a,b, k, I, R,n

Entrée : a prend la valeur 2
                   b prend la valeur 0
Lire n

Traitement : pour k allant de 1 à n
                              R prend la valeur (a-1)-(b-1)/2
                              I prend la valeur (a-1)+(b-1)/2
                           Fin du pour
Afficher R
Afficher I

ya du beaucoup mieux

mais cette partie est à reprendre :
                             R prend la valeur (a-1)-(b-1)/2
                              I prend la valeur (a-1)+(b-1)/2

visiblement tu n'as pas testé ton algo à la main, comme conseillé plusieurs fois...
parce qu'avec ces formules, tu ne trouveras jamais Z1 !

et si tu le déroules à la main comme indiqué (pour n=2 ou 3)
tu constateras qu'il y a autre chose à faire dans cette boucle...

J'ai fait les tableaux, je me rends bien compte que ça ne fonctionne pas mais j'écris tout de même ou j'en suis. Je vais retravailler dessus.
Merci

Variables : a,b, k, I, R,n

Entrée : a prend la valeur 2
                   b prend la valeur 0
Lire n

Traitement : pour k allant de 1 à n
                       R prend la valeur [(a-1)-(b-1)/2] *b
                       I prend la valeur [ (a-1)+(b-1)/2]*b
                           Fin du pour
Afficher R
Afficher I

Pardon ce que je viens n'a pas de sens. Je continue à travailler

Pour que ton algorithme ait un sens, tu dois placer des opérations qui modifient a et/ou b dans la boucle Pour, sinon cette boucle est inutile.

R prend la valeur [(a-1)-(b-1)/2] *b
I prend la valeur [ (a-1)+(b-1)/2]*b

toujours pas.
pourquoi compliques-tu  avec des formules alambiquées?
les formules sont toutes simples; ce sont celles vues au début.

relis ici :  21-10-19 à 21:24  et    23-10-19 à 09:25

---

dérouler l'algo à la main, c'est :
- dresser un tableau avec en colonnes autant de variables que tu en as déclarées
- dérouler ligne après ligne ton algo, crayon en main, en remplissant le tableau à chaque fois


montre-moi ton tableau pour n=3
(ne mets pas la photo de ton brouillon, complète le début ci-dessous)
je ne mets pas n, puisqu'il n'évolue pas.

                                            a         b         k        I       R      
init.                                   2         0                                      ----- on initialise à  Z₀
1er tour de boucle  2         0         1         ?       ?      ----- on calcule Z₁
2ème tour                      ?         ?          ?          ?        ?      ----- on calcule Z₂
3ème tour                      ?         ?          ?          ?        ?      ----- on calcule Z₃

... tu vois mieux ce qui manque à ton algo ?

Je crois avoir compris. a prend la valeur de R non ? Et b prend la valeur de I a chaque tour ?

voilà !
c'est ce que te suggérait pzorba75 à 13h57

si tu ne changes pas les valeurs de a et b à chaque tour de boucle, ben chaque boucle te sortira les mêmes calculs.

allez, montre ton algo tout propre... il y a peut-être un détail à revoir...

salut

intéressant à programmer

salut flight !
mon petit doigt me dit que tu attends la fin de l'échange pour nous montrer ta programmation
(en python?)

Variables : a,b, k, I, R,n

Entrée : a prend la valeur 2
                   b prend la valeur 0
Lire n

Traitement : pour k allant de 1 à n
                       R prend la valeur (a-b)/2
                       I prend la valeur (a+b)/2
                       a prendre la valeur R
                       b prend la valeur I
  
                           Fin du pour
Afficher R
Afficher I

bien

une question :
" Écrire un algorithme donnant les parties et imaginaires de ZN pour une valeur de n donnée. "

.... et si on choisit n=0?
que va afficher l'algo ?

Il affiche R=2 et I=0 car il prend les valeurs de a et b initial ?

non,
et à quel moment il ferait ça ?
déroule à la main, avec le tableau...

donc, que dois-tu changer sur ton algo pour qu'il fonctionne pour tout n ?

Je peux mettre une boucle avec si k=0 alors
I prend la valeur b
R prend la valeur a

Sinon ...

pas besoin, on peut faire plus simple :

si on tape n=0
on ne va pas entrer dans la boucle, puisqu'elle dit : de 1 à n

donc l'algo passe à la ligne : Afficher R / Afficher I
soit 0 et 0

==> il suffit de faire afficher a et b, et non pas R et I

Ah d'accord oui effectivement c'est plus simple !
Merci encore pour votre aide, j'ai été lent à comprendre