Discussion :

[PTuner]

Bonjour,
Je recherche une fonction de type round() qui m'arrondirait un entier au nombre inférieur le plus proche (de la largeur) c'est pour un programme de découpe de panneaux en acier. Sachant que j'ai dans une liste des longueurs à respecter de type 1370 1250 1500. Quelqu'un connaitrait une fonction ou une méthode pour le faire? Je connais la fonction floor () mais elle ne répond pas exactement à mon problème puisque je veux renvoyer un nombre de la base et non un entier inconnu.

[Bousk]

Salut,

je veux renvoyer un nombre de la base et non un entier inconnu.

Tu veux dire que tu as une liste de valeurs et veux retourner la plus élevée sous une valeur donnée ?
Avec tes exemples 1370, 1250 & 1500, si tu as 1501 tu veux 1500, mais si tu as 1499 tu veux 1370 ?

Y'a pas de fonction magique pour ça, mais une simple suite de if fait l'affaire.

[Bktero]

Une petite lookup table ?

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
25
26
27
28
#include <iostream>
#include <array>
using namespace std;
 
int near(int value)
{
    static array<int, 4> lookup_table = {100, 1250, 1370, 1500};
 
    for (int i = lookup_table.size() - 1; i >= 0; --i)
    {
        int neared = lookup_table[i];
        if (neared <= value)
        {
            return neared;
        }
    }
 
    return 0;
}
 
int main()
{
    cout << near(42) << endl;
    cout << near(242) << endl;
    cout << near(1250) << endl;
    cout << near(1255) << endl;
    cout << near(9999) << endl;
}

0
100
1250
1250
1500

[PTuner]

Oui c'est ça je suis en train de coder ç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
//traitement
        for (std::list<int>::iterator it = longeurspieces.begin();it != longeurspieces.end();++it)
        {
           for (std::list<int>::iterator itt = entre.begin(); itt != entre.end();++itt)
            {
 
                cout << "actuel" << *itt << endl;
                if (*it <= *itt)
                {
                    longeurspiecesfinal.push_front(*it);//std::find(entre.begin(), entre.end(), i);
                }
                cout << "avant" << *it << endl;
 
        }

En fait si la valeur correspond à cette condition je la mets dans une autre liste dans l'ordre de la saisie

liste saisie de l'utilisateur********liste base de longeurs*********liste de longeurs

1500(1) *********************1379(1)*********************1379(1)
2000(2) *********************4879(2)*********************1379(2)
4000(3) *********************1105(3)*********************1379(3)

basez vous plutôt sur 1379 4879 1105 du coup.

[PTuner]

J'ai utilisé ta méthode bktero mais ça ne me renvoie rien voire ça ferme l'appli voici le code modifiée pour mon utilisation:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
int near(int value)
{
    static array<int, 3> lookup_table = {1105,1379,4879};
 
    for (int i = lookup_table.size() - 1; i >= 0; --i)
    {
        int neared = lookup_table[i];
        if (neared <= value)
        {
            return neared;
        }
    }
 
    return NULL;
}
 
int main()
{
    std::list<int> entre {};
    std::list<int> ::iterator it = entre.begin();
    const int longm(8000);
    int p(0);
    int nb(0);
    int longeurs(0);
    int prec(0);
    std::string type("");
    int valeurs(0);
    std:list<int> longeurspieces {1379,4879,1105};
 
 
 
    if (entre.empty())
    {
        int i = 0;
        //saisie de la liste
        //entre.push_front();
        cout << "Entre le nombre de longeurs à saisir :" << endl;
        cin >> nb;
        cout << "Entrez le type de piece" << endl;
        cin >> type;
 
        while(i < nb)
        {
            ++i;
 
            cout << "Entre la largeur du panneau " << " {" << i << "} "<< endl;
            cin >> p;
            entre.push_front(p);
            //if (p == 8000)
            //{
                //cout << "Longeur max atteinte !" << endl;
            //}
 
 
        }
        entre.reverse();
        //entre.sort(greater<int>());
 
 
 
        //traitement
        for (std::list<int>::iterator itt = entre.begin(); itt != entre.end();++itt)
            {
 
                cout << near(*itt) << endl;
 
 
            }
}

[camboui]

Euh... si si, il existe un algo qui fait ça et qui existe depuis la nuit des temps en C++
std::upper_bound

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
#include <iostream>
#include <array>
int bound(int value)
{
    static std::array<int, 4> longueurpieces = {100, 1250, 1370, 1500};
	auto found = std::upper_bound(longueurpieces.begin(), longueurpieces.end(), value);
	if (found != longueurpieces.begin())
		return *(found-1);
	else
		return 0;
}
 
int main()
{
    std::cout << bound(42) << std::endl;
    std::cout << bound(242) << std::endl;
    std::cout << bound(1250) << std::endl;
    std::cout << bound(1255) << std::endl;
    std::cout << bound(9999) << std::endl;
    return 0;
}

[PTuner]

Sorry les gars j'avais oublié le getch(); ça marche nickel camboui

[PTuner]

Excusez moi encore
Vous auriez une idée du coup après avoir saisi tout ça et avoir sélectionne les pièces grâce à la fonction les pièces égales ou inférieures les plus proches de refaire tourner tout ça dans une boucle pour minimiser les pertes car là dans le cas 2000 j'aurai 621mm x 1379 mm de perte soit environ 80 m de surface du panneau.