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.

[ternel]

là, on passe à un problème d'algorithme d'optimisation.

Ce n'est plus du tout le même problème.

1. Résouds le problème manuellement, avec papier et crayon, pour une liste de pièces précise.
2. prouve que tu l'a résolu,
3. Observe comment tu l'a résolu.
4. Explique le.
5. Généralise ton explication
6. Applique la à une autre liste de pièces.
7. prouve que c'est aussi une bonne solution

Alors seulement tu pourras l'expliquer à l'ordinateur (c'est ca, coder)

Concrètement, il doit exister des réponses sur internet, mais je ne sais pas quoi chercher.

[camboui]

Ceci dit, j'ai trouvé un commentaire très intéressant je suis codeur (dont C++) et mon père était menuisier.

quand je le voyais préparer ses découpes, j'imaginais (avec la vanité de
ma jeunesse) pouvoir optimiser son travail en calculant les coupes.
mais, trait après trait, en voyant qu'il avait, avant même de les
énumérer, déjà pensé à tous ses pièces, à ses marges de découpes et de
redressement (dégauchissages), je me rendais compte que je n'aurais pas
même pensé à préserver le fil du panneau ...
il est des expériences que la modélisation ne remplace pas

Comme quoi la réponse peut être très complexe