Discussion :

[Oguri]

Bonsoir,
au début d'un algorithme, je ne comprends pas les affectations de départ comme par exemple pour initialiser. Je ne vois pas à quoi ils servent.
Par exemple:
On a un type abstrait Liste
Question : Ecrire l'opération qui permet de récupérer la référence du ième élément d'une liste

Solution:

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
Pré-conditions definie(l.valeurElement(i)) <==> 1 <= i <= longueur(l)
Observateur Liste : valeurElement(Entier i) : Element
// Le paramètre implicite
Observé l
Références locales
Liste l1
Entier j
// Début de l'algorithme
DEBUT
    l1 <-- l
    j <-- 1
    TANTQUE j < i FAIRE // Structure itérative
        l1 <-- l1.reste()
    FinTantQue
    retourner l1.tete()
FIN

Je ne comprends pas à quoi l1 <-- l et j <-- 1 servent. Si on affecte la valeur 1 à j, il n'y aura qu'une seule valeur pour j alors que l'intérêt est de prendre toutes les valeurs de j pour la boucle TantQue. Et pourquoi créer une liste l1 au lieu de faire directement les opérations avec l?

[Biribibi]

Bonjour.

A mon avis, ton code est incomplet, ça doit être quelque chose du genre:

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
Pré-conditions definie(l.valeurElement(i)) <==> 1 <= i <= longueur(l)
Observateur Liste : valeurElement(Entier i) : Element
// Le paramètre implicite
Observé l
Références locales
Liste l1
Entier j
// Début de l'algorithme
DEBUT
    l1 <-- l
    j <-- 1
    TANTQUE j < i FAIRE // Structure itérative
        l1 <-- l1.reste()
        j <-- j + 1
    FinTantQue
    retourner l1.tete()
FIN

[violet]

Bonsoir,
au début d'un algorithme, je ne comprends pas les affectations de départ comme par exemple pour initialiser. Je ne vois pas à quoi ils servent.
Par exemple:
On a un type abstrait Liste
Question : Ecrire l'opération qui permet de récupérer la référence du ième élément d'une liste

Solution:

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
Pré-conditions definie(l.valeurElement(i)) <==> 1 <= i <= longueur(l)
Observateur Liste : valeurElement(Entier i) : Element
// Le paramètre implicite
Observé l
Références locales
Liste l1
Entier j
// Début de l'algorithme
DEBUT
    l1 <-- l
    j <-- 1
    TANTQUE j < i FAIRE // Structure itérative
        l1 <-- l1.reste()
    FinTantQue
    retourner l1.tete()
FIN

Je ne comprends pas à quoi l1 <-- l et j <-- 1 servent. Si on affecte la valeur 1 à j, il n'y aura qu'une seule valeur pour j alors que l'intérêt est de prendre toutes les valeurs de j pour la boucle TantQue. Et pourquoi créer une liste l1 au lieu de faire directement les opérations avec l?

J doit être incrémenté à chaque itération sinon il ne servirait absolument à rien.