Discussion :

[maxoumax]

Bonjour,
Voila j'ai un petit exercice a faire :

Ecrire une fonction qui prend un tableau d’entiers représentant le cours boursier d’
une action jour par jour sur les 30 derniers jours, et qui retourne une structure
contenant deux indices achat et vente qui indiquent quels jours il fallait acheter et
vendre les actions pour maximise son profit.




Pour ce faire j'imagine un tableau:
1 ere ligne Jour
2 eme ligne prix
donc voici mon algo

Code x :

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
19
20
21
22
Function AchatVente( Tableau)
  resultat1 = nouveauTableau
  resultat2 = nouveauTableau
  n=longueur(Tableau)
  i=0
 moyenne = 0
 somme = 0
  WHILE (i<n)
   somme = somme + Tableau[2][i]
   i=i+1
  ENDWHILE
 moyenne = somme / n
  WHILE (i<n)
    IF(Tableau[2][i] >= moyenne )
       resultat1 [1][i] =Tableau[1][i]

    ELSE
 
     resultat2 [1][i] =Tableau[1][i]

   END IF
Return (" les jours ou il faut vendre=",resultat1 " les jours ou il faut acheter", resultat2)

Voila une petite correction serait cool
Merci bonne soirée

[CliffeCSTL]

Code c :

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
19
function_achatVente(tableau) {
    int jour_achat, jour_vente, benefice_max = 0;
 
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            int benefice = tableau[j] - tableau[i];
            if (benefice > benefice_max) {
                benefice_max = benefice;
                jour_achat = i;
                jour_vente = j;
            }
        }
    }
 
    if (benefice_max != 0)
        return (jour_achat, jour_vente);
    else
        return NO_BENEFICE; // Fonction décroissante
}

[BufferBob]

salut,

si je comprends bien l'énoncé, on a en entrée un tableau de 30 valeurs, dont l'indice correspond de facto au jour du mois, et la fonction doit renvoyer le couple (minimum, maximum)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
fonction (tableau)
   meilleurJourAchat = 1
   meilleurJourVente = 1
   pour chaque jour dans l'intervalle [1,30]
      si tableau[jour] > tableau[meilleurJourAchat]
         meilleurJourAchat = jour
      si tableau[jour] < tableau[meilleurJourVente]
         meilleurJourVente = jour
   retourner (meilleurJourAchat, meilleurJourVente)

[Flodelarab]

Bonjour

@BufferBob: Il manque une condition: que le jour d'achat soit avant le jour de vente. Sinon, tu auras la plus grosse catastrophe boursière plutôt que le plus plus grand profit

Il faut donc stocker le minimum, le maximum et le nouveau minimum potentiel.

[BufferBob]

@BufferBob: Il manque une condition: que le jour d'achat soit avant le jour de vente. Sinon, tu auras la plus grosse catastrophe boursière plutôt que le plus plus grand profit

c'est pas bête en effet

Edit: et en y réfléchissant un peu plus, c'est donc pas les extremums qu'on cherche, c'est bien la plus grande amplitude entre jour d'achat et jour de vente, l'un étant obligatoirement avant l'autre
donc au plus simple c'est la méthode de CliffeCSTL qui est la bonne (mais sans commentaire de sa part j'ai du faire l'erreur pour m'en rendre compte ^^)

[Flodelarab]

c'est la méthode de CliffeCSTL qui est la bonne

Je ne crois toujours pas.

Stocker le bénéfice est inutile.
Et stocker les jours successifs dans un tableau est inutile, également.

Tu parcours tes jours.
Si le max augmente, tu stockes le nouveau max. (Et le jour)
Si le min diminue, tu stockes comme min_potentiel. (Et le jour)
Quand le jour en cours moins le min_potentiel est supérieur au max moins min, tu remplaces min par min_potentiel et max par le cours du jour. (Et le jour)

À la fin, tu as les jours et les valeurs de la plus grosse hausse possible.

[anapurna]

salut flo
j'essai de comparer et de comprendre ce que tu reproche a l'algo de cliffeCSTL

si tu regarde l'algo de CliffeCSTL

il parcours les jours et cherche le benefice maximun

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 for (int i = 0; i < n-1; ++i) {

du premier a n-1 je me suis permis de corriger sinon il plante à la dernière boucle
ensuite il refait une boucle sur le jours + 1 jusqu'a n

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  for (int j = i + 1; j < n; ++j) {

ensuite il conserve que le delta max entre les deux dates

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 tableau[j] - tableau[i];

si cette condition est avéré :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  if ((tableau[j] - tableau[i]) > max) {

alors on conserve les indices permettant de trouver le max

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
     max = tableau[j] - tableau[i];
     jour_achat = i;
     jour_vente = j;

effectivement cela oblige à parcourir deux fois les cours mais le raisonnement est correct car tu passera obligatoirement
par le delta maxi

pour le tiens j'ai quelque soucis de compréhension

Tu parcours tes jours. // ok les jour c'est un calendrier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
For days :=CurrentDays-30 to  CurrentDays do 
begin

Si le max augmente, tu stockes le nouveau max. (Et le jour) //

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
   si max < Cours[days] alors 
      max := Cours[days]
      Jmax := days
  Fin si

Si le min diminue, tu stockes comme min_potentiel. (Et le jour)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
   Si min > Cours[days] alors 
     min_potentiel := Cours[days]
     Jmin := days
  Fin si

Quand le jour en cours moins le min_potentiel est supérieur au max moins min, tu remplaces min par min_potentiel et max par le cours du jour. (Et le jour)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  si (Cours[days] - min_potentiel ) > (max-min) alors
     min     := min_potentiel
     max    := Cours[days]
     Jvente := days
     Jachat := Jmin       // le jour de quoi de la ventes ou de l'achat ?  
  Fin si

À la fin, tu as les jours et les valeurs de la plus grosse hausse possible.

j'avoue que je comprend pas pourquoi tu modifie le max 2 fois
par contre je comprend bien que dans ton cas on ne parcours qu'une seul fois les jours
mais je sais pas j'ai comme un doute sur l'algo j'ai le pressentiment d'oublier un truc
merci pour les éclaircissement

[Flodelarab]

D'abord, un mea culpa:
C'est vrai que l'entrée est un tableau. Par énoncé. Donc reprocher l'utilisation du tableau est abusif. Mais l'algorithme que je propose fonctionne même "à la volée", sans tableau.

effectivement cela oblige à parcourir deux fois les cours

Cette expression est tendancieuse.
On est plus près du carré que du double.
Pour n cours de bourse, on est plus près de n(n-1)/2 que de 2n.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

j'avoue que je comprends pas pourquoi tu modifies le max 2 fois

Un exemple vaut mieux qu'un long discours. Prenons les cours suivants:

50
60
70
10
20
40

Calculons min max et min_potentiel à chaque étape:
50 50 50
50 60 50
50 70 50
50 70 10
50 70 10
10 40 10

On remarque que le min_potentiel ne devient min que si il y a une valeur max lui correspondant et donnant un meilleur bénéfice que celui précédent. Ce nouveau max est inférieur au max précédent quoique donnant un meilleur bénéfice car le min_potentiel est très bas par rapport au min.
Il y a une étape, après le repérage du min_potentiel, où rien ne se passe car le top précédent est meilleur que le bénéfice en cours.

j'ai le pressentiment d'oublier un truc

On n'a pas besoin de calculer toutes les différences.

• Si le cours est inférieur au max, ça ne peut pas donner le meilleur bénéfice. (cas exclu du min_potentiel)
• Si le cours est supérieur au min, ça ne peut pas donner le meilleur bénéfice car le min serait meilleur.
• Si le cours est supérieur au max, ce cas est traité par cet algo.
• Si le cours est inférieur au min, ce cas est traité par cet algo par la création du min_potentiel.
  Il n'y a qu'un min_potentiel car s'il est écrasé par une nouvelle valeur, cela signifie que le min_potentiel écrasé n'a pas donné de meilleur bénéfice et que le nouveau min_potentiel sera dorénavant plus performant que le min_potentiel écrasé.
  S'il avait permis un meilleur bénéfice, alors min_potentiel serait devenu min.

Et dans tous les cas on peut oublier les vieux min car nous avons trouvé une meilleur valeur dorénavant.

Nous avons bien tous les cas.

[anapurna]

salut flo

dans le premier cas énoncé, effectivement on est plus près du carré que du double.

pour ton algo je comprend mieux le raisonnement

merci