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

**handmade** · 01/07/2019, 20h49

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

**Bousk** · 02/07/2019, 00h58

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.

**handmade** · 02/07/2019, 09h33

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 :

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

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

**Bktero** · 02/07/2019, 09h36

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

Exemple :

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
#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 :

**handmade** · 02/07/2019, 09h53

Bonjour et merci,

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

**handmade** · 02/07/2019, 10h18

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 :

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
		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

**Bysbobo** · 02/07/2019, 10h46

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 :

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
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

**handmade** · 02/07/2019, 11h04

Merci Bysbobo

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

**koala01** · 02/07/2019, 11h30

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 :

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

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

)

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

Code :

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

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 :

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

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 :

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
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 :

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

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 :

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

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 :

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
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

**handmade** · 03/07/2019, 13h33

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

**Bousk** · 03/07/2019, 14h27

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.

**koala01** · 03/07/2019, 15h35

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

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

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

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

10 / 3 = 3, reste 1

Code :

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

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 :

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

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 :

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

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

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 :

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

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

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 :

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

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 :

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

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
}

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

On va les placer dans un tableau par facilité:

Code :

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

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 :

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
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 :

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

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

**handmade** · 03/07/2019, 23h00

non ça ne m'avait pas sauté aux yeux que cela donnait la même chose

J'ai honte je n'ai pas été assez attentive

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

**viper1094** · 04/07/2019, 02h11

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++

**Bktero** · 04/07/2019, 09h37

Envoyé par handmade

Question subsidiaire : Le modulo fonctionne avec des double?

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 ?

**handmade** · 04/07/2019, 10h16

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

**koala01** · 04/07/2019, 11h45

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 :

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

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 :

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

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;
                  ~~^~~