demande d'aide pour écriture algorithme en C++

Bonjour à tous,

C'est la première fois que je post sur ce forum alors j'espère ne pas me tromper d'endroit pour poser ma question. J'apprends le C++ toute seule alors je m'en excuse à l'avance si je n'utilise pas le bon vocabulaire.

Je souhaite coder la chose suivante à l'aide de boucles for :

J'ai une liste de composés auxquels je voudrais appliquer une équation. Mais bien entendu les équations sont différentes selon le composé et reviennentt en boucle. exemple ci-dessous

Liste de composés [0] [1] [2] [3] [4] [5] etc.... (nombre de composés ncomp inconnu)
Liste d'équations A B C

association composés/équations

[0] A
[1] B
[2] C
[3] A
[4] B
[5] C

Je voudrais faire une boucle du style

for (i=0, i<ncomp, i++) {
etc car là je ne sais plus quoi faire. Je ne sais pas comment écrire que

pour [0] on applique l'équation A ainsi que pour [0]+3
pour [1] on applique l'équation B ainsi que pour [1]+3
pour [2] on applique l'équation C ainsi que pour [2]+3

etc jusqu'à la fin du vecteur ncomp

Pouvez-vous m'expliquer comment on fait?

Merci d'avance :)

handmade

Salut,

par équation on va supposer que tu parles de fonction à appeler...
La solution est sans doute d'avoir un vector de function. Mais pour en être sûr il faudrait plus d'infos comme ce qu'est réellement l'opération à réaliser.

Salut et merci pour ta réponse,
Oui équation = fonction pour moi
on n'a qu'à prendre 3 fonctions lambda, par exemple

y=2x
y=3x
y=4x

En fait je voudrais pouvoir réaliser ceci :

pour les indices [0] et [3] ( [6] et [9] et ainsi de suite jusqu'à i<ncomp) appliquer l'équation y=2x sur la données d'entrée appelée x
pour les indices [1] et [4] ( [7] et [10] et ainsi de suite jusqu'à i<ncomp) appliquer l'équation y=3x sur la données d'entrée appelée x
pour les indices [2] et [5] ( [8] et [11] et ainsi de suite jusqu'à i<ncomp) appliquer l'équation y=4x sur la données d'entrée appelée x

Donc il faut lire l'ensemble de mes indices puis en fonction de l'indice de départ appliquer l'une ou l'autre des 3 équations.
C'est plus clair ce que j'ai écrit

Je suppose qu'il faut créer plusieurs boucles for

Je pensais faire un truc comme ça

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

VectorDbl y(ncomp);   for (size_t i=0; i<ncomp;i++) {   for (int countj=i;countj<ncomp;countj+3){ y[i] =2x[countj]; } for (int countk=i+1;countk<ncomp;countk+3){ y[i] =3x[countk]; } for (int countl=i+2;countl<ncomp;countl+3){ y[i] =4x[countl]; } }

---

ça pourrait le faire?

Merci d'avance

Ce n'est pas l'opérateur % (modulo) que tu cherches ?

Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream> #include <array>   void f(int v) { std::cout << v << '\n'; }   int main() { std::array array = {0,1,2,3,4,5,6,7,8,9,10}; for (auto v : array) { if (v % 3 == 0) { f(v); } } }

---

Sortie :

0
3
6
9

Bonjour et merci,

non non, je cherche vraiment à appliquer une fonction particulière tous les 3 index

Rebonjour à tous,

A priori je viens de trouver. Je ne sais pas si c'est la façon la plus élégante de le faire mais ça ne plante plus.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

VectorDbl y(ncomp);   for (size_t i = 0; i < ncomp; i++) { int j = 0; int k = 1; int l = 2; for (j = i; j < ncomp; j +=3){ y[j] = 2 * x[j]; } for (k = i + 1; k < ncomp; k += 3){ y[k] = 3 * x[k]; } for (l = i + 2; l < ncomp; l += 3){ y[l] = 4 * x[l]; } }

---

Si vous avez plus élégant, je suis preneuse d'idée, histoire de monter en compétence ;)

Salut!

Bktero t'a propose une bonne solution avec le modulo que tu as reimplemente par toi meme ensuite.
En utilisant les infos au dessus (et ce que j'en ai compris), ca donnerai un truc du genre:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <iostream> #include <array>   void f2(int v) { std::cout << 2*v << '\n'; } void f3(int v) { std::cout << 3*v << '\n'; } void f4(int v) { std::cout << 4*v << '\n'; }   int main() { std::array array = {0,1,2,3,4,5,6,7,8,9,10}; for (auto v : array) { switch(v % 3) { case 0: f2(v); break; case 1: f3(v); break; case 2: f4(v); break; default: break; } } }

---

Je ne suis pas chez moi, j'ai jete ca comme ca mais devrait etre fonctionnel.
J'ai laisse comme Bktero des cout pour les fonctions, a toi de les adapter.
Bon couarge ;)

Merci Bysbobo :)

Je n'ai jamais utilisé les modulos, je vais étudier le truc

Salut,

Voyons si on a bien compris:

On part du principe qu'il existe trois fonctions, que nous pourrions définir sous la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10

void a(int i){ std::cout<<"A called with value "<<i<<"\n"; } void b(int i){ std::cout<<"B called with value "<<i<<"\n"; } void c(int i){ std::cout<<"C called with value "<<i<<"\n"; }

---

(il va de soi que le code que je donne pour ces fonctions devrait être adapté à tes besoins, mais qu'il suffira très bien à pour mon exemple :D )

Et que, pour pouvoir les appeler successivement, tu les a placés dans un tableau sous la forme de

Code:

---

std::vector<std::function<void(int)>> functions{&a,&b,&c};

---

(nécessite l'inclusion du fichier <vector> et du fichier <functional> et l'utilisation de C++11 au minimum pour compiler)

Le plus cohérent est alors d'effectivement utiliser le modulo, qui fourni le reste de la division d'un nombre par un autre pour parcourir ce tableau, mais, d'utiliser le résultat obtenu comme indice du tableau à utiliser, au lieu de l'utiliser dans un test, comme l'avait montré Btkero, par exemple, un code proche de

Code:

---

1 2 3 4 5 6 7

int main(){ std::vector<std::function<void(int)>> functions{&a,&b,&c}; for(int i = 0; i<15; ++i){ functions[i%3](i); } return 0; }

---

provoquera l'affichage

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

a.exe A called with value 0 B called with value 1 C called with value 2 A called with value 3 B called with value 4 C called with value 5 A called with value 6 B called with value 7 C called with value 8 A called with value 9 B called with value 10 C called with value 11 A called with value 12 B called with value 13 C called with value 14

---

Maintenant, si tu dispose d'un ensemble d'éléments qui doivent servir de paramètre pour l'appel de ces fonctions dont on va considérer que cet ensemble d'éléments est représenté sous la forme de

Code:

---

std::vector<int> elements{3,5,10,15,9,7,2,3,45,32,64,128,35,45,54};

---

rien de plus simple : il suffira de modifier l'appel pour prendre la valeur qui trouve à l'indice représenté par le compteur, en modifiant un tout petit peu le code pour lui donner la forme de

Code:

---

1 2 3 4 5 6 7 8

int main(){ std::vector<std::function<void(int)>> functions{&a,&b,&c}; std::vector<int> elements{3,5,10,15,9,7,2,3,45,32,64,128,35,46,54}; for(int i = 0; i<15; ++i){ functions[i%3](elements[i]); } return 0; }

---

qui provoquera l'affichage de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

a.exe A called with value 3 B called with value 5 C called with value 10 A called with value 15 B called with value 9 C called with value 7 A called with value 2 B called with value 3 C called with value 45 A called with value 32 B called with value 64 C called with value 128 A called with value 35 B called with value 46 C called with value 54

---

Est-ce suffisamment proche de ce que tu cherches à faire :question:

Bonjour et merci pour ta proposition,

Il ne me semble pas que cela soit ce que je cherche à faire :

En fait imaginons que j'ai au moins 6 données d'entrée E1, E2, E3, E4, E5, E6, et que leur valeurs soient toutes = à 1.
donc.
E1=1
E2=1
E3=1
E4=1
E5=1
E6=1

J'ai 3 fonctions également, Y1=f(E)*2, Y2=f(E)*3 et Y3=f(E)*4
et donc 6 données de sortie S1,S2,S3,S4,S5,S6

Je veux que le code fasse ce qui suit et pour un nombre de données d'entrée inconnu

S1 = E1*Y1
S2 = E2*Y2
S3 = E3=Y3
S4 = E4*Y1
S5 = E5*Y2
S6 = E6*Y3

on doit donc obtenir

S1=2
S2=3
S3=4
S4=2
S5=3
S6=4

J'ai trouvé une façon de le coder dans un message précédent, je me demandais juste s'il y avait quelque chose de plus élégant.
Je n'ai pas encore eu le temps de me pencher sur la compréhension du modulo

Bonne journée
handmade

Tu cherches à utiliser un vector/array et un modulo.
Le premier est un élément de base du langage et le second une opération que l'on apprend en primaire.

N'as tu pas compris que mon algorithme fait exactement ce que tu souhaite :question:

Il me semblait pourtant bien avoir insisté sur le fait que le code devait être adapté, non :question:

La seule chose, c'est qu'il faut visiblement adapter les valeurs à tes propres besoins ;)

Citation:

---

Envoyé par handmade

Je n'ai pas encore eu le temps de me pencher sur la compréhension du modulo

---

Quand tu travailles sur des valeurs entières (comme le type int en C++) l'ordinateur va effectuer la division exactement de la même manière que ce que l'on ta expliqué lors de tes toutes premières années d'école

Citation:

---

10 / 3 = 3, reste 1

---

Code:

---

1 2 3 4

int main(){ int i = 10 / 3; std::cout<<"i = "<<i<<"\n"; }

---

va afficher ... 3.

Le modulo (représenté à l'aide de l'opérateur % va te permettre de récupérer le reste de la division des deux nombres:

Code:

---

1 2 3 4

int main(){ int i = 10 % 3; std::cout<<"i = "<<i<<"\n"; }

---

va afficher ... 1.

Note que si le dividande est un multiple du diviseur, le reste sera égal à 0 :

Code:

---

1 2 3 4

int main(){ int i = 9 % 3; std::cout<<"i = "<<i<<"\n"; }

---

va afficher ... 0.

C'est pas plus compliqué que cela!

Ceci dit, l'adaptation peut encore aller beaucoup plus loin, avec les bonnes explicatons :D

Citation:

---

Envoyé par handmade

Bonjour et merci pour ta proposition,

Il ne me semble pas que cela soit ce que je cherche à faire :

En fait imaginons que j'ai au moins 6 données d'entrée E1, E2, E3, E4, E5, E6, et que leur valeurs soient toutes = à 1.
donc.
E1=1
E2=1
E3=1
E4=1
E5=1
E6=1

---

Je traduis : je crée un tableau données de type int qui est composé comme suit :

Code:

---

std::vector<int> E{1,1,1,1,1,1};

---

Citation:

---

J'ai 3 fonctions également, Y1=f(E)*2, Y2=f(E)*3 et Y3=f(E)*4

---

Je traduis: j'ai donc d'un coté une fonction f, qui prend un entier en entrée et qui renvoie un entier. Dans un premier temps, je vais faire en sorte qu'elle ne modifie pas la valeur recue:

Code:

---

1 2 3

int f(int E){ return E; }

---

et, d'un autre coté, je veux multiplier le résultat de cette fonction par une valeur dépendant de l'indice de mon tableau E mais comprise entre 2 et 4.

Le modulo peut donc me venir en aide, mais je dois juste penser que le premier indice de mon tableau a la valeur 0 : E[0] correspond à ta valeur E1, et ainsi de suite:

Code:

---

1 2 3 4 5 6 7 8 9

for(size_t i = 0; i<E.size(); ++i){ // je parcoure l'ensemble des éléments de mon tableau int multi{i%3 + 2}; // je calcule le multiplicateur (par facilité) int result = f(E[i]) * multi; // le résultat final correspond à la multiplication du résultat de f // et du multiplicateur /* j'affiche le résultat sous la forme du calcul */ std::cout<<"S"<<i+1 // j'ai commencé à compter à partir de 0 <<" = f("<<E[i]<<") * "<<multiplicateur // la formule utilisée <<" = "<<result<<"\n"; // le résultat final }

---

Citation:

---

et donc 6 données de sortie S1,S2,S3,S4,S5,S6

---

On va les placer dans un tableau par facilité:

Code:

---

1 2 3 4 5 6 7 8

std::vector<int> S; for(size_t i = 0; i<E.size(); ++i){ // je parcoure l'ensemble des éléments de mon tableau int multi{i%3 + 2}; // je calcule le multiplicateur (par facilité) int result = f(E[i]) * multi; // le résultat final correspond à la multiplication du résultat de f // et du multiplicateur S.push_back (result) ; // on fait tout d'un coup }

---

Au final, voilà notre code, tel qu'il serait compilé:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include <iostream> #include <vector> int f(int E){ return E; } int main(){ std::vector<int> E{1,1,1,1,1,1}; // tes valeurs Ex de départ std::vector<int> S; // pour récupérer le résultat for(size_t i = 0; i< E.size(); ++i){ // pour chaque valeur comprise dans E auto mult{ i%3 + 2}; // on calcule le multiplicateur int result = static_cast<int>(mult) // parce que mult est de type size_t * f(E[i]); // que l'on multiplie par le résultat de f pour cette valeur S.push_back(result); } /* pour se rendre compte que c'est ce que l'on voulait, on provoque un affichage cohérent des valeurs   * contenues dans S   */ for(size_t i = 0; i<S.size();++i){ auto multi{i%3 + 2}; // je calcule le multiplicateur (par facilité) std::cout<<"S"<<i+1 // j'ai commencé à compter à partir de 0 <<" = f("<<E[i]<<") * "<<multi // la formule utilisée <<" = "<<S[i]<<"\n"; // le résultat final } }

---

(Ne t'en fais pas pour le static_cast, c'est pour indiquer au compilateur que je sais ce que je fais en manipulant un entier non signé de type size_t comme s'il s'agissait d'un entier "normal" de type int ;) )

Après compilation, l'exécution donnera l'affichage

Code:

---

1 2 3 4 5 6 7

a.exe S1 = f(1) * 2 = 2 S2 = f(1) * 3 = 3 S3 = f(1) * 4 = 4 S4 = f(1) * 2 = 2 S5 = f(1) * 3 = 3 S6 = f(1) * 4 = 4

---

:D non ça ne m'avait pas sauté aux yeux que cela donnait la même chose :D
J'ai honte je n'ai pas été assez attentive :oops:
Dès que j'ai un peu de temps je teste pour voir comment ça tourne, voir je remplace mon code. Merci pour ce temps que tu as pris pour détailler tes explications.
Question subsidiaire : Le modulo fonctionne avec des double?
Bonne soirée

Citation:

---

Envoyé par handmade

Question subsidiaire : Le modulo fonctionne avec des double?

---

Alors j'suis pas foutu de faire un hello world de tête en C++, mais j'te rassure. Le modulo, tout comme les 4 autres opérateurs fonctionne sur tous les types de nombre ( int,float,double). Et dans certain langage le '+' fonctionne également sur des strings(chaine de caractère). Mais pas en C++

Citation:

---

Envoyé par handmade

Question subsidiaire : Le modulo fonctionne avec des double?

---

Citation:

---

Envoyé par viper1094

j'te rassure. Le modulo, [...] fonctionne sur tous les types de nombre ( int,float,double)

---

Selon vous, c'est quoi le reste dans la division entière de 3.14 par 1.2896 ?

Citation:

---

Envoyé par Bktero

Selon vous, c'est quoi le reste dans la division entière de 3.14 par 1.2896 ?

---

Qu'est-ce que tu appelles division entière? C'est très très loin dans mes souvenirs les histoires de reste de division. Tu parles du reste de 3/1 ou du reste de 3.14/1.2896. En réponse aux deux je dirais 0 et 0.5608 :)

Une division entière est une division dont le dividande, le diviseur et le résultat sont... des valeurs entières.

Le modulo (le reste de la division de deux nombre) ne peut s'obtenir que sur une division entière.

Donc, pour répondre à la question subsidiaire : non, le modulo ne peut pas fonctionner avec des float ou avec des double, car ce ne sont pas des valeurs entières ;)

PS : le plus simple, lorsque l'on se pose ce genre de question, c'est encore d'écrire un petit code qui nous permettra de nous rendre compte de la réponse du compilateur lorsque le code sera compilé:

à la compilation, le code

Code:

---

1 2 3 4 5 6 7 8

#include <iostream> int main() { float a{3.141592}; float b{1.2896}; auto result = a % b; std::cout<<result<<"\n"; }

---

provoque de la part de Gcc l'émission du message

Code:

---

1 2 3 4

main.cpp: In function 'int main():' main.cpp:6:18 error: invalid operands of types 'float' and 'float' to binary 'operator%' auto result = a % b; ~~^~~

---

Voilà qui aurait pu te donner la réponse directement :D

Pour le modulo flottant, on utilise la fonction fmod.

https://fr.wikipedia.org/wiki/Division_euclidienne
J'ai souvenir d'avoir vu ça en CM1.

:whistle: Voilà pourquoi je devrais apprendre à me taire haha

Citation:

---

Envoyé par viper1094

:whistle: Voilà pourquoi je devrais apprendre à me taire haha

---

Mais non voyons, tu as le droit d'avoir ton opinion et de l'exprimer. Bon là, c'est juste que le compilateur n'a pas la même que toi mais c'est tout.

Ok celle là est mérité, c'est de bonne guerre :bravo:

Citation:

---

Envoyé par SimonDecoline

Mais non voyons, tu as le droit d'avoir ton opinion et de l'exprimer. Bon là, c'est juste que le compilateur n'a pas la même que toi mais c'est tout.

---

Et le pire, c'est que le compilateur sera beaucoup plus têtu que n'importe qui :ptdr: :? Avant de lui faire accepter quelque chose qu'il (le compilateur) a décidé de refuser, faudra te lever tôt, ou écrire un code qui lui convienne ;)

Bah va falloir que je me lève tot, parce que ce foutu compilateur est condescendant.

GCC a l'option -w.


A quand l'option -e ? 8O

Citation:

---

Envoyé par viper1094

Et dans certain langage le '+' fonctionne également sur des strings(chaine de caractère). Mais pas en C++

---

Il existe une opération + pour concaténer 2 chaînes de caractères. Si l'une d'elle est une std:;string.
http://www.cplusplus.com/reference/s...ing/operator+/

Bon bah catastrophe je dis n'importe quoi. Comme quoi elle est mérité mon incapacité au Hello World xd

Citation:

---

Envoyé par viper1094

Bon bah catastrophe je dis n'importe quoi. Comme quoi elle est mérité mon incapacité au Hello World xd

---

Pour te sauver un peu, si tu entendais par "chaîne de caractères" un const char *, effectivement le compilateur t'insultera si tu tente de faire une addition (à moins d'avoir surchargé au préalable l'opérateur + avec les opérandes qui vont bien) :

Citation:

---

main.cpp:6:21: error: invalid operands of types ‘const char*’ and ‘const char*’ to binary ‘operator+’

---

En effet, en C++ tu as deux "types" de chaînes de caractères, (const) char * hérité du C, et std::string. Généralement, on préfèrera utiliser/manipuler ce dernier.