Bonjour,
où est le problème?
Qu'as tu fait?

Tu veux qu'on t'explique quoi clairement? Toi expliques-tu ton problème clairement?
Il me semble que l'énoncé est très clair, c'est du français, si on comprend le français on comprend l'énoncé...

bonsoir
on a un tableau T on veut déterminer combien on l'inversion sachant que l'inversion lorsque on a i<j et t[i]>t[j]
et la deuxieme question donnez une fonction qui calcule le nombre d'inversion dans un tableau t de taille n
merci d'avance

Bonjour Otto
Je trouve ta réaction un peu trop agressive. Même si la question posée peut sembler maladroite, Hassan est parfaitement correct dans son message demandant de l'aide.

Bonjour Hassan
Otto veut dire. Explique ce que tu as compris, ce que tu as pu faire et quelles difficultés tu rencontres. Et ceci concrètement et explicitement. Pas en disant par exemple je ne comprrends pas, ce n'est pas clair, etc. Quest-ce que tu ne comprends pas exactement. Qu'est-ce qui n'est pas clair.

bonsoir
merci pour votre intervention .
je ne comprends pas comment je fait pour resoudre ce l'algorithme?
tout simplement
merci

Bonsoir Hassan

D'après l'énoncé, une inversion est un couple (i,j) tel que  i<j et t[i]>t[j]. Le nombre d'inversions est donc le nombre de couples (i,j) tels que  i<j et t[i]>t[j].

Tu fais donc dans ton ton tableau de 10 éléments, les itérations (répétitions) suivantes:
- Pour i = 1, t[1]=18 : combien y a-t-il de j>1, tel que t[1]>t[j]. Il y a 7.
- Pour i = 2, t[3]=3 : combien y a-t-il de j>2, tel que t[2]>t[j]. Il y a 0.
....(je te laisse compléter ici)
- Pour i = 8, t[8]=13 : combien y a-t-il de j>8, tel que t[8]>t[j]. Il y a 1.
- Pour i = 9, t[9]=23 : combien y a-t-il de j>9, tel que t[9]>t[j]. Il y a 1.
- Pour i = 10 ; il est inutile de le traiter car c'est le dernier.


Question 2
Un algorithme se compose généralement de 3 phases: i) Initialisation, ii) Traitement, iii) Fin.
Je le fais comme je le ressens. Je te laisse l'adapter à la manière suivie dans vos cours.

Phase Initialisation (déclaration et initialisation des variables)
--------------------

i, j, n, NbreInv : déclaration de variables de type entier
t[] : déclaration de tableau d'entiers
NbreInv = 0
Lecture en entrée de la variable n // taille du tableau
Lecture en entrée du tableau t[] de 1 à n

Pour i = 1 à n-1
. Pour j=i 0 n
. . Si t[i]>t[j] alors NbreInv  = NbreInv +1 // incrémentation du nombre d4inversions
. . Fin boucle j
. Fin boucle i


Phase Fin de traitement
-----------------------

Affichage de la variable NbreInv  qui donne le nombre d'inversions

J'ai omis d'intituler la phase traitement. J'espère que tu sais identifier où cette phase se place.

bonsoir
merci beaucoup
mais comment on va fait l'algorithme avec fonction.?

Fonction Calcul_Inversions (
- Variables en entrée : n entier correspondant à la taille du tableau, t[] le tableau à étudier ;
- Variable retournée en sortie : NbreInv entier correspondant au nombre d'inversions)
{
NbreInv = 0
Pour i = 1 à n-1
. Pour j=i 0 n
. . Si t[i]>t[j] alors NbreInv  = NbreInv +1 // incrémentation du nombre d4inversions
. . Fin boucle j
. Fin boucle i

Retourner la variable NbreInv qui donne le nombre d'inversions
}