Bonjour à tous,

Je suis actuellement en train de codé un programme se basant sur la gamme de résistance E24. Le but du code est simple, on entre une valeur de résistance et le programme nous donne la ou les 2 résistance équivalente/la plus proche.  voici ce que j'ai déjà codé :

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double Tab_E24[24];
double Tab_Serie[576];
double Tab_Deriv[576];
int i, i2, i3, i_bis, i2_bis, i3_bis = 0;
int A;

int main ()
{
    Tab_E24[0] = 10;
    Tab_E24[1] = 11;
    Tab_E24[2] = 12;
    Tab_E24[3] = 13;
    Tab_E24[4] = 15;
    Tab_E24[5] = 16;
    Tab_E24[6] = 18;
    Tab_E24[7] = 20;
    Tab_E24[8] = 22;
    Tab_E24[9] = 24;
    Tab_E24[10] = 27;
    Tab_E24[11] = 30;
    Tab_E24[12] = 33;
    Tab_E24[13] = 36;
    Tab_E24[14] = 39;
    Tab_E24[15] = 43;
    Tab_E24[16] = 47;
    Tab_E24[17] = 51;
    Tab_E24[18] = 56;
    Tab_E24[19] = 62;
    Tab_E24[20] = 68;
    Tab_E24[21] = 75;
    Tab_E24[22] = 82;
    Tab_E24[23] = 91;
    for (i = 0; i < 24; i = i + 1)
    {
       for (i2 = 0; i2 < 24; i2 = i2 + 1)
       {
           Tab_Serie[i3] = (Tab_E24[i] + Tab_E24[i2])/10;
           i3 = i3 + 1;
       }
    }
    for (i_bis = 0; i_bis < 24; i_bis = i_bis + 1)
    {
       for (i2_bis = 0; i2_bis < 24; i2_bis = i2_bis + 1)
       {
           Tab_Deriv[i3_bis] = ((Tab_E24[i_bis] * Tab_E24[i2_bis])/(Tab_E24[i_bis] + Tab_E24[i2_bis]))/10;
           i3_bis = i3_bis + 1;
       }
    }
}

Mais mon problème est que je ne sais pas si c'est possible de trouver dans mes deux tableaux(de 576 valeurs chacun) la valeur la plus proche en fonction de la valeur de la résistance donnée...

J’espère que vous pourrez m'aider

-
Edité par ethanvernet 11 février 2019 à 14:48:19

je saisi pas trop ce que tu tentes de faire

mais je reconnait ds ton code que tu testes toutes les possibilités, il ne te reste plus qu'a enregistrer la différence la plus faible si j'ai bien compris ou a couper la boucle avec "break" si tu trouves la même valeur.

ensuite il faudrait que tu reçoive un argument (via scanf ou argument normal) aussi pour voir quelle valeur tu recherches et ça devait le faire

Je ne sas pas si j'ai été bien claire dans un premier temps je vais entrer une valeur de résistance et tester si il y a une correspondance entre les valeurs de mes tableaux si il n'y en a pas il me faut la valeur la plus proche de celle donné dans le scanf,et voici le code maintenant :

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int Val_puissance(float Val_Resistance);

int Puissance = 0;
float Resistance = 0;
float Tab_E24[24];
double Tab_Serie[576];
double Tab_Deriv[576];
int i, i2, i3, i_bis, i2_bis, i3_bis = 0;

int Val_puissance(float Val_Resistance)
{
    int Exposant = 0;
    while(Val_Resistance > 10)
    {
        Val_Resistance = Val_Resistance / 10;
        Exposant = Exposant + 1;
    }
    return Exposant;
}

int main ()
{
    scanf("%f", &Resistance);
    Puissance = Val_puissance(Resistance);

    Tab_E24[0] = 10, Tab_E24[1] = 11, Tab_E24[2] = 12, Tab_E24[3] = 13, Tab_E24[4] = 15, Tab_E24[5] = 16, Tab_E24[6] = 18, Tab_E24[7] = 20, Tab_E24[8] = 22, Tab_E24[9] = 24, Tab_E24[10] = 27, Tab_E24[11] = 30, Tab_E24[12] = 33, Tab_E24[13] = 36, Tab_E24[14] = 39,Tab_E24[15] = 43, Tab_E24[16] = 47, Tab_E24[17] = 51, Tab_E24[18] = 56, Tab_E24[19] = 62, Tab_E24[20] = 68, Tab_E24[21] = 75, Tab_E24[22] = 82,Tab_E24[23] = 91;

    for (i = 0; i < 24; i = i + 1)
    {
       for (i2 = 0; i2 < 24; i2 = i2 + 1)
       {
           Tab_Serie[i3] = (Tab_E24[i] + Tab_E24[i2])/10;
           i3 = i3 + 1;
       }
    }
    for (i_bis = 0; i_bis < 24; i_bis = i_bis + 1)
    {
       for (i2_bis = 0; i2_bis < 24; i2_bis = i2_bis + 1)
       {
           Tab_Deriv[i3_bis] = (Tab_E24[i_bis] * Tab_E24[i2_bis])/(Tab_E24[i_bis] + Tab_E24[i2_bis])/10;
           i3_bis = i3_bis + 1;
       }
    }
}

Pour expliquer le problème, le mieux est de donner un exemple simple.

BobyLaCourgette a proposé une solution, est-elle satisfaisante ?

robun a écrit:

Pour expliquer le problème, le mieux est de donner un exemple simple.

BobyLaCourgette a proposé une solution, est-elle satisfaisante ?

J'essaye actuellement de la mettre en oeuvre mais je ne sais pas vraiment comment le coder, ce que je voudrais ce serais une fonction qui renvoie la valeur la plus proche d'une valeur dans un tableaux (ici la valeur la plus proche de Resistance et voici ou en est le code:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int Val_puissance(float Val_Resistance);

int Puissance = 0;
float Resistance = 0;
float Tab_E24[24];
float Tab_Val_E24[24];
double Tab_Serie[576];
double Tab_Deriv[576];
int i, i1, i2, i3, i_bis, i2_bis, i3_bis = 0;

int Val_puissance(float Val_Resistance)
{
    int Exposant = 0;
    while(Val_Resistance > 10)
    {
        Val_Resistance = Val_Resistance / 10;
        Exposant = Exposant + 1;
    }
    return Exposant;
}

int main ()
{
    scanf("%f", &Resistance);
    Puissance = Val_puissance(Resistance);

    Tab_E24[0] = 10, Tab_E24[1] = 11, Tab_E24[2] = 12, Tab_E24[3] = 13, Tab_E24[4] = 15, Tab_E24[5] = 16, Tab_E24[6] = 18, Tab_E24[7] = 20, Tab_E24[8] = 22, Tab_E24[9] = 24, Tab_E24[10] = 27, Tab_E24[11] = 30, Tab_E24[12] = 33, Tab_E24[13] = 36, Tab_E24[14] = 39,Tab_E24[15] = 43, Tab_E24[16] = 47, Tab_E24[17] = 51, Tab_E24[18] = 56, Tab_E24[19] = 62, Tab_E24[20] = 68, Tab_E24[21] = 75, Tab_E24[22] = 82,Tab_E24[23] = 91;
    for (i = 0; i < 24; i = i + 1)
    {
        Tab_Val_E24[i] = Tab_E24[i]/10 * pow(10, Puissance);
        if (Resistance == Tab_Val_E24[i])
            {
                printf("La resistance equivalente est egal a %f * 10^%d\n", Tab_E24[i], Puissance);
            }
        else
            {
                //fonction déterminant la valeur la plus proche
            }
    }
    for (i1 = 0; i1 < 24; i1 = i1 + 1)
    {
        for (i2 = 0; i2 < 24; i2 = i2 + 1)
        {
            Tab_Serie[i3] = ((Tab_E24[i1] + Tab_E24[i2])/10) * pow(10, Puissance);

            if (Resistance == Tab_Serie[i3])
            {
                printf("La resistance equivalente est egal a (%f + %f)* 10^%d\n", Tab_E24[i1], Tab_E24[i2], Puissance);
            }
            else
            {
                //fonction déterminant la valeur la plus proche
            }
            i3 = i3 + 1;
        }
    }
    for (i_bis = 0; i_bis < 24; i_bis = i_bis + 1)
    {
        for (i2_bis = 0; i2_bis < 24; i2_bis = i2_bis + 1)
        {
            Tab_Deriv[i3_bis] = ((Tab_E24[i_bis] * Tab_E24[i2_bis])/(Tab_E24[i_bis] + Tab_E24[i2_bis])/10) * pow(10, Puissance);

            if (Resistance == Tab_Deriv[i3_bis])
            {
                printf("La resistance equivalente est egal a ((%f * %f)/(%f + %f)) * 10^%d", Tab_E24[i_bis], Tab_E24[i2_bis], Tab_E24[i_bis], Tab_E24[i2_bis], Puissance);
            }
            else
            {
                //fonction déterminant la valeur la plus proche
            }
            i3_bis = i3_bis + 1;
        }
    }
}

-
Edité par ethanvernet 12 février 2019 à 11:51:20

je vais l'expliquer simplement

je rentre une valeur x, et j'ai un tableau de x donnée, dans ce tableau de x donnée, je regarde si il y a une valeur qui correspond avec celle rentrer précédemment, si il n'y en pas le programme doit me renvoyer la valeur la plus proche dans le tableau de celle donné.

Je cherche une fonction me permettant de faire ceci (voir les commentaires dans le code plus haut)

j'espere avoir suffisament simplifier mon probleme

OK, j'ai relu les commentaires, c'est vrai qu'ils sont clairs.

Je pense que ton algorithme n'est pas bon. Tu fais :

Pour chaque élément du tableau :
    S'il est égal à la valeur saisie, affiche "OK"
    Sinon chercher le plus proche

Mais pour chercher le plus proche, il faut parcourir le tableau, or on est déjà en plein parcours...

Ce qu'il faudrait plutôt faire, c'est parcourir le tableau pour chercher l'élément le plus proche, et si cet élément est en fait égal, eh bien on le précisera (ce sera un cas particulier). Donc l'algorithme sera ;

x = valeur saisie par l'utilisateur
distance-min = (+infini, ou bien une valeur maxi qui a un sens d'après le problème concret)

/* Recherche de l'élément le plus proche */
Pour chaque élément i du tableau :
    y = valeur de cet élément
    distance-courante = |y - x|    // si cette quantité est nulle, on pourrait mettre un break...
    Si distance-courante < distance-min alors :
        distance-min = distance-courante
        i-min = i    // indice de l'élément le plus proche
        y-min = y    // valeur de l'élément le plus proche

Si distance-min == 0 :
    Afficher "L'élément %d est identique", i-min
sinon :
    Afficher "L'élément %d est le plus proche et vaut %d", i-min, y-min

-
Edité par robun 12 février 2019 à 16:08:12

robun a écrit:

OK, j'ai relu les commentaires, c'est vrai qu'ils sont clairs.

Je pense que ton algorithme n'est pas bon. Tu fais :

Pour chaque élément du tableau :
    S'il est égal à la valeur saisie, affiche "OK"
    Sinon chercher le plus proche

Mais pour chercher le plus proche, il faut parcourir le tableau, or on est déjà en plein parcours...

Ce qu'il faudrait plutôt faire, c'est parcourir le tableau pour chercher l'élément le plus proche, et si cet élément est en fait égal, eh bien on le précisera (ce sera un cas particulier). Donc l'algorithme sera ;

x = valeur saisie par l'utilisateur
distance-min = (+infini, ou bien une valeur maxi qui a un sens d'après le problème concret)

/* Recherche de l'élément le plus proche */
Pour chaque élément i du tableau :
    y = valeur de cet élément
    distance-courante = |y - x|    // si cette quantité est nulle, on pourrait mettre un break...
    Si distance-courante < distance-min alors :
        distance-min = distance-courante
        i-min = i    // indice de l'élément le plus proche
        y-min = y    // valeur de l'élément le plus proche

Si distance-min == 0 :
    Afficher "L'élément %d est identique", i-min
sinon :
    Afficher "L'élément %d est le plus proche et vaut %d", i-min, y-min

-
Edité par robun il y a environ 17 heures

Merci,

je comprend comment je vais m'y prendre