Bonjour,

d'abord bravo pour avoir eu le courage de taper tout ça.

Peux-tu tester bout par bout ton programme, jusqu'à trouver à quel moment exactement ça ne marche pas ?

Peux-tu également me préciser le langage de programmation que tu utilises ?

Bonjour, c'est du AlgoBox.

Points_C1 est une chaîne de caractères, mais essais ça :

Points_C1 PREND_LA_VALEUR (xC1+" ; "+yC1)

, j'ai modifier les guillemets.

Fais pareil pour Points_A1.

Tout d'abord merci d'avoir eu le courage de tout lire . J'ai testée bout à bout
FONCTIONS_UTILISEES
VARIABLES
  xA EST_DU_TYPE NOMBRE
  yA EST_DU_TYPE NOMBRE
  xB EST_DU_TYPE NOMBRE
  yB EST_DU_TYPE NOMBRE
  xC EST_DU_TYPE NOMBRE
  yC EST_DU_TYPE NOMBRE
  xC1 EST_DU_TYPE NOMBRE
  yC1 EST_DU_TYPE NOMBRE
  xA1 EST_DU_TYPE NOMBRE
  yA1 EST_DU_TYPE NOMBRE
  u EST_DU_TYPE NOMBRE
  v EST_DU_TYPE NOMBRE
  u2 EST_DU_TYPE NOMBRE
  v2 EST_DU_TYPE NOMBRE
  Points_C1 EST_DU_TYPE CHAINE
  Points_A1 EST_DU_TYPE CHAINE
  a EST_DU_TYPE NOMBRE
  b EST_DU_TYPE NOMBRE
  c EST_DU_TYPE NOMBRE
  a2 EST_DU_TYPE NOMBRE
  b2 EST_DU_TYPE NOMBRE
  c2 EST_DU_TYPE NOMBRE
  xG EST_DU_TYPE NOMBRE
  yG EST_DU_TYPE NOMBRE
  Coordonnées_G EST_DU_TYPE CHAINE
DEBUT_ALGORITHME
  LIRE xA
  LIRE yA
  LIRE xB
  LIRE yB
  LIRE xC
  LIRE yC
  xC1 PREND_LA_VALEUR (xA+xB)/2
  yC1 PREND_LA_VALEUR (yA+yB)/2

Là tout va bien , l'algorithme se lance puis non.Et je en comprends vraiment pas pourquoi.
Effectivement c'est du algobox

L'endroit où ça bogue correspond exactement à ce que Aalex00 proposait de corriger, donc je pense que c'est pertinent d'essayer ce qu'il te propose.

Désolée , j'ai réalisée que j'avais oubliée les + , maintenant il se lance ! Enfin mais il reste étranges .

Donc jusqu'à la ligne :
yC1 PREND_LA_VALEUR (yA+yB)/2
, tout va bien et en ajoutant la prochaine ligne
Points_C1 PREND_LA_VALEUR (xC1+" ; "+yC1)
ça tourne à l'infini ?

L'erreur est toujours au même endroit .Je l'ai écrit en bleu , sinon tout est correct enfin il me semble . Mais je ne sais pas comment arranger ça .

FONCTIONS_UTILISEES
VARIABLES
  xA EST_DU_TYPE NOMBRE
  yA EST_DU_TYPE NOMBRE
  xB EST_DU_TYPE NOMBRE
  yB EST_DU_TYPE NOMBRE
  xC EST_DU_TYPE NOMBRE
  yC EST_DU_TYPE NOMBRE
  xC1 EST_DU_TYPE NOMBRE
  yC1 EST_DU_TYPE NOMBRE
  xA1 EST_DU_TYPE NOMBRE
  yA1 EST_DU_TYPE NOMBRE
  u EST_DU_TYPE NOMBRE
  v EST_DU_TYPE NOMBRE
  u2 EST_DU_TYPE NOMBRE
  v2 EST_DU_TYPE NOMBRE
  Points_C1 EST_DU_TYPE CHAINE
  Points_A1 EST_DU_TYPE CHAINE
  a EST_DU_TYPE NOMBRE
  b EST_DU_TYPE NOMBRE
  c EST_DU_TYPE NOMBRE
  a2 EST_DU_TYPE NOMBRE
  b2 EST_DU_TYPE NOMBRE
  c2 EST_DU_TYPE NOMBRE
  xG EST_DU_TYPE NOMBRE
  yG EST_DU_TYPE NOMBRE
  Coordonnées_G EST_DU_TYPE CHAINE
DEBUT_ALGORITHME
  LIRE xA
  LIRE yA
  LIRE xB
  LIRE yB
  LIRE xC
  LIRE yC
  xC1 PREND_LA_VALEUR (xA+xB)/2
  yC1 PREND_LA_VALEUR (yA+yB)/2
  Points_C1 PREND_LA_VALEUR (xC1+" ; yC1+")
  //On affiche les coordonnées du point C1 , la médiane qui coupe AB:
  AFFICHER Points_C1
  //Abscisse du vecteur AB :
  u PREND_LA_VALEUR (xC1-xC)
  //Ordonnée du vecteur AB :
  v PREND_LA_VALEUR (yC1-yC)
  //M(x; y) appartient à (AB) si les vecteurs CC1 et CM sont colinéaires.
  //Le test de colinéarité entre les vecteurs CC1 et CM donne :
  //u(y-yA)-v(x-xA)=0 soit -v.x +u.y+(v.xA-u.yA)=0 donc :
  a PREND_LA_VALEUR -v
  b PREND_LA_VALEUR u
  c PREND_LA_VALEUR (v*xC)-(u*yC)
  AFFICHER* "La droite (AB) a pour équation ax+by+c=0 avec : "
  AFFICHER "a="
  AFFICHER a
  AFFICHER "b="
  AFFICHER b
  AFFICHER "c="
  AFFICHER c
  //On fait de même pour la droite BC.
  xA1 PREND_LA_VALEUR (xB+xC)/2
  yA1 PREND_LA_VALEUR (yB+yC)/2
  Points_A1 PREND_LA_VALEUR (xA1+" ; yA1+")
  AFFICHER Points_C1
  //Abscisse du vecteur CB :
  u2 PREND_LA_VALEUR (xA1-xA )
  //Ordonnée du vecteur CB :
  v2 PREND_LA_VALEUR (yA1-yA)
  //M(x; y) appartient à (CB) si les vecteurs AA1 et AM sont colinéaires.
  //Le test de colinéarité entre les vecteurs AA1 et AM donne :
  //u(y-yC)-v(x-xC)=0 soit -v.x +u.y+(v.xC-u.yC)=0 donc :
  a2 PREND_LA_VALEUR -v2
  b2 PREND_LA_VALEUR u2
  c2 PREND_LA_VALEUR (v2*xC)-(u2*yC)
  AFFICHER* "La droite (CB) a pour équation ax+by+c=0 avec : "
  AFFICHER "a="
  AFFICHER a2
  AFFICHER " b="
  AFFICHER b2
  AFFICHER " c="
  AFFICHER c2
FIN_ALGORITHME

Au fait si tu veux vérifier le fonctionnement exact de ton algo avec un triangle quelconque, saches que ; avec les notations de tes points :
et

Essaie  Points_C1 PREND_LA_VALEUR (xC1+" ; "+yC1)

Finalement les points A1, C1 et Coordonnée_G ne sont pas essentiels, ils ne servent qu'à afficher les résultats intermédiaires.

Peux-tu essayer d'enlever ces variables, ne demander au programmer qu'afficher xG et yG pour voir si ça fonctionne ?

Si ça fonctionne bien, alors le problème ne sera qu'au niveau de la syntaxe de tes chaînes de caractères.

Mais essais :
Points_C1 PREND_LA_VALEUR (xC1+" ; "+yC1)
et :
Points_A1 PREND_LA_VALEUR (xA1+" ; "+ yA1)

Bonjour

en fait tout dépend de ce qu' veut afficher

suppsosns que xC1 ait la valeur 3 et yC1 la valeur 2

si on veut afficher textuellement (3;2)

c'est "("+xC1+";"+yC1+")"

ce qui est en rouge est du texte, ce qui est en bleu est des variables
chaque morceau de texte doit être entre " " et c'est les morceaux de texte qu'on met entre "", pas les variables
et on "rassemble" le tout avec des +

mieux : afficher ce que c'est :

"C1 ("+xC1+"; "+yC1+")"
(noter l'ajout d'un espace après le ; pour faire plus propre à l'affichage)


(xC1+" ; "+yC1) est bon mais affiche uniquement 3;2 sans les parenthèses
elles ne servent strictement à rien ici (a) et a c'est pareil.

Merci , j'ai suivis vos conseil sauf le dernier car c'était plus simple pour moi. Cependant ,il ya une erreur de signe dans mon algorithme ..Et encore une fois ,je ne sais pas pourquoi !J'ai vraiment du mal avec les algorithmes ...

FONCTIONS_UTILISEES
VARIABLES
  xA EST_DU_TYPE NOMBRE
  yA EST_DU_TYPE NOMBRE
  xB EST_DU_TYPE NOMBRE
  yB EST_DU_TYPE NOMBRE
  xC EST_DU_TYPE NOMBRE
  yC EST_DU_TYPE NOMBRE
  xC1 EST_DU_TYPE NOMBRE
  yC1 EST_DU_TYPE NOMBRE
  xA1 EST_DU_TYPE NOMBRE
  yA1 EST_DU_TYPE NOMBRE
  u EST_DU_TYPE NOMBRE
  v EST_DU_TYPE NOMBRE
  u2 EST_DU_TYPE NOMBRE
  v2 EST_DU_TYPE NOMBRE
  Points_C1 EST_DU_TYPE CHAINE
  Points_A1 EST_DU_TYPE CHAINE
  a EST_DU_TYPE NOMBRE
  b EST_DU_TYPE NOMBRE
  c EST_DU_TYPE NOMBRE
  a2 EST_DU_TYPE NOMBRE
  b2 EST_DU_TYPE NOMBRE
  c2 EST_DU_TYPE NOMBRE
  xG EST_DU_TYPE NOMBRE
  yG EST_DU_TYPE NOMBRE
  Coordonnées_G EST_DU_TYPE CHAINE
DEBUT_ALGORITHME
  LIRE xA
  LIRE yA
  LIRE xB
  LIRE yB
  LIRE xC
  LIRE yC
  xC1 PREND_LA_VALEUR (xA+xB)/2
  yC1 PREND_LA_VALEUR (yA+yB)/2
  Points_C1 PREND_LA_VALEUR (xC1+" ; "+yC1)
  //On affiche les coordonnées du point C1 , la médiane qui coupe AB:
  AFFICHER "C1 ( "
  AFFICHER Points_C1
  AFFICHER* " )"
  //Abscisse du vecteur AB :
  u PREND_LA_VALEUR (xC1-xC)
  //Ordonnée du vecteur AB :
  v PREND_LA_VALEUR (yC1-yC)
  //M(x; y) appartient à (AB) si les vecteurs CC1 et CM sont colinéaires.
  //Le test de colinéarité entre les vecteurs CC1 et CM donne :
  //u(y-yA)-v(x-xA)=0 soit -v.x +u.y+(v.xA-u.yA)=0 donc :
  a PREND_LA_VALEUR -v
  b PREND_LA_VALEUR u
  c PREND_LA_VALEUR (v*xC)-(u*yC)
  AFFICHER* "La droite (AB) a pour équation ax+by+c=0 avec : "
  AFFICHER "a= "
  AFFICHER a
  AFFICHER " b= "
  AFFICHER b
  AFFICHER " c= "
  AFFICHER* c
  //On fait de même pour la droite BC.
  xA1 PREND_LA_VALEUR (xB+xC)/2
  yA1 PREND_LA_VALEUR (yB+yC)/2
  Points_A1 PREND_LA_VALEUR (xA1+" ; "+yA1)
  AFFICHER "A1 ( "
  AFFICHER Points_A1
  AFFICHER* " )"
  //Abscisse du vecteur CB :
  u2 PREND_LA_VALEUR (xA1)-(xA)
  //Ordonnée du vecteur CB :
  v2 PREND_LA_VALEUR (yA1)-(yA)
  //M(x; y) appartient à (CB) si les vecteurs AA1 et AM sont colinéaires.
  //Le test de colinéarité entre les vecteurs AA1 et AM donne :
  //u(y-yC)-v(x-xC)=0 soit -v.x +u.y+(v.xC-u.yC)=0 donc :
  a2 PREND_LA_VALEUR -v2
  b2 PREND_LA_VALEUR u2
  c2 PREND_LA_VALEUR (v2*xC)-(u2*yC)
  AFFICHER* "La droite (CB) a pour équation ax+by+c=0 avec : "
  AFFICHER "a= "
  AFFICHER a2
  AFFICHER " b= "
  AFFICHER b2
  AFFICHER " c= "
  AFFICHER* c2
  SI ((a*b2)!=(b*a2)) ALORS
    DEBUT_SI
    xG PREND_LA_VALEUR (c*b2 )-(b*c2)/(a*b2)-(b*a2)
    yG PREND_LA_VALEUR (a*c2)-(c*a2)/(a*b2)-(b*a2)
    AFFICHER "xG="
    AFFICHER* xG
    AFFICHER "yG="
    AFFICHER yG
    AFFICHER "."
    FIN_SI
    SINON
      DEBUT_SINON
      SI ((a*c2)!=(c*a2)) ALORS
        DEBUT_SI
        AFFICHER "Pas de solution désolée ."
        FIN_SI
        SINON
          DEBUT_SINON
          AFFICHER "Infinité de solution ."
          FIN_SINON
      FIN_SINON
FIN_ALGORITHME

problème de signes = mauvaise étude mathématique de l'algorithme

on ne commence JAMAIS par le codage d'un algorithme, serait-ce par petit bouts

on commence par rédiger les calculs qu'il faudra faire explicitement de façon mathématique.
et on vérifie mathématiquement que ces calculs so,t bons

le codage en forme d'algorithme (et pire de programme en Algobox) vient ensuite...

surtout avec ce fatras de tas de variables et de tas de trucs à calculer.

Justement c'est ce que j'ai fais  par peur de m'embrouiller . Les résultats de l'algo sont les mêmes que les miens mais il y a une erreur de signe que je ne comprends pas.

parce que la méthode mathématique n'a rien à voir avec les calculs que tu fais

la vraie méthode avec les médianes est

calculer C1 milieu de [AB]
calculer l'équation de la droite (CC1) (droite passant par deux points donnés C et C1, médiane)
calculer A1 milieu de [BC]
calculer l'équation de la droite (AA1)
calculer leur intersection (de ces deux médianes et pas d'autre chose)
et c'est tout

tes trucs avec la droite (AB) ou le vecteur AB n'ont rigoureusement rien à faire là dedans

en fait tes commentaire sont faux et n'ont aucun rapport avec ce que tu calcules vraiment
mettre des commentaires faux c'est pire que pas de commentaires du tout dans un algo !
tu sembles bien suivre la méthode mathématique

reste à voir les détails de tous tes signes lors du calcul (de façon purement mathématique)
que par exemple tu ne t'es pas trompé entre une équation ax+by = c et une équation ,ax+by+c = 0 etc

et que tu as bien traduit ces calculs mathématiques là et pas d'autres.

Je crois que je viens de comprendre , enfaite tout les textes après //  sont des commentaires pour ne pas me perdre mais il n'apparaisse pas dans l'algorithme.

Du coup je ne vois pas d'où provient l'erreur .

parce que les commentaires ce n'est pas toi qui les as écrits ?? qui donc à rédigé ce programme ???

erreur là :

xG PREND_LA_VALEUR (c*b2 )-(b*c2)/(a*b2)-(b*a2)

cela veut dire

mette des parenthèses autour de c*b2 ne sert strictement à rien du tout
par contre il en manque d'autres !!

quand on vous tanne sur les histoires de parenthèses et de fraction c'est parce que c'est tout aussi fondamental dans un programme que sur papier !!

C'est un  travail en binome et c'est mon ami qui les a rédigé .L'erreur de signe apparaît bien avant la fin .

en tout cas les lignes que je t'ai signalées sont fausses
(dans le calcul final des coordonnées de G)
sans préjuger d'autres erreurs avant
je vais devoir quitter, retour tard. mais tu as d'autres intervenants sur le coup

de l'importance de mettre des commentaires qui correspondent à ce qu'on veut calculer

//Abscisse du vecteur CB AA1 :
u2 PREND_LA_VALEUR (xA1)-(xA)
//Ordonnée du vecteur CB AA1 :
v2 PREND_LA_VALEUR (yA1)-(yA)
//M(x; y) appartient à (CB) (AA1) si les vecteurs AA1 et AM sont colinéaires.
//Le test de colinéarité entre les vecteurs AA1 et AM donne :
//u(y-yC)-v(x-xC)=0 soit -v.x +u.y+(v.xC-u.yC)=0 donc : [rouge]??? C ???[/rouge]
a2 PREND_LA_VALEUR -v2
b2 PREND_LA_VALEUR u2
c2 PREND_LA_VALEUR (v2*xC)-(u2*yC) // ?????? pour la droite AA1 ???
AFFICHER* "La droite (CB) (AA1) a pour équation ax+by+c=0 avec : "