The output of the vector that you helped me make is a little hard to read.
Can you help me make it a little more readable like:
Input:
Enter number of different sizes: 5
and the inputs are :
35 x 2.36
23 x 1.23
12 x 4.23
16 x 8.25
15 x 2.89
and the output is a long list like:
Bar 1: 8.250 2.890
Bar 2: 8.250 2.890
Bar 3: 8.250 2.890
Bar 4: 8.250 2.890
Bar 5: 8.250 2.890
Bar 6: 8.250 2.890
Bar 7: 8.250 2.890
Bar 8: 8.250 2.890
Bar 9: 8.250 2.890
Bar 10: 8.250 2.890
Bar 11: 8.250 2.890
Bar 12: 8.250 2.890
Bar 13: 8.250 2.890
Bar 14: 8.250 2.890
Bar 15: 8.250 2.890
Bar 16: 8.250 2.890
Bar 17: 8.250 2.890
Bar 18 8.250 2.360 1.230 2.360
Bar 19: 4.230 4.230 2.360
Bar 20: 4.230 4.230 2.360
Bar 21: 4.230 4.230 2.360
Bar 22: 4.230 4.230 2.360
Bar 23: 4.230 4.230 2.360
Bar 24: 4.230 4.230 2.360 and so on

So instead of this if I could say.
1. You cut 17 bars by 8.250 and 2.890
2. You cut 1 bar 8.250 2.360 1.230 2.360
3. You cut 6 bars 4.230 4.230 2.360
Because usually you have hundreds of measures and an output like that is very unreadable.
Thank you

``````#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>
#include <algorithm>
#include <numeric>
/* Get the number of different lengths from the user */

struct Cut{
unsigned number;
double length;
};

int main () {

std::vector< Cut > allCuts;
Cut currentCut;
unsigned numberOfSizes;
std::cout << "Enter number of different sizes: ";
std::cin >> numberOfSizes;

/* Now get the actual numbers and lengths from the user */
for(unsigned i = 0; i < numberOfSizes; ++i){
//currentCut = new Cut;
std::cout << "Enter new cut: <number> <length>" << std::endl;
std::cin >> currentCut.number >> currentCut.length;
/* Check that the length is sensible */
if((currentCut.length <= 0) || (currentCut.length > 12)){
std::cerr << "Error length must be in the range (0,12]" << std::endl;
--i;
}
else
allCuts.push_back(currentCut);
}

/* Now put all the cuts into a single large vector */
std::vector< double > lengths;
for(unsigned i = 0; i < allCuts.size(); ++i){
for(unsigned j = 0; j < allCuts[i].number; ++j)
lengths.push_back(allCuts[i].length);
}

/* Sort the vector */
std::sort(lengths.begin(), lengths.end());

/* Make a place to put the lengths to cut from each bar */
const unsigned NEW_BAR_LENGTH = 12;
std::vector< std::vector< double > >bars;
std::vector< double > currentBar;
double remainingLength = NEW_BAR_LENGTH;

/* Now keep going through the lengths vector until all the cuts are accounted for */
while(lengths.size() > 0){
/* start at the longest length that needs to be cut ... */
std::vector< double >::iterator it = lengths.end() - 1;
/* Go until the smallest length that's needed is reached */
while(it >= lengths.begin()){
/* Check if the current length will fit */
if(*it < remainingLength){ /* If it will... */
/* ... Add it to the current bar and remove it from the list to be fitted */
currentBar.push_back(*it);
/* Update the amount of the bar remaining */
remainingLength -= *it;
/* Remove the current element from the lengths vector */
lengths.erase(it);
}
/* Check that we didn't just remove the last element */
if(lengths.size() > 0){
/* length is the shortest length cut that we still need to get
if this is more than the remaining amount of the current bar,
then we should finish this bar and start a new one, check for
this now */
if(lengths > remainingLength){
/* Reset the remaining length */
remainingLength = NEW_BAR_LENGTH;
/* Add this completed bar to the vector of bars */
bars.push_back(currentBar);
/* Clear the current bar */
currentBar.clear();
/* Exit this loop and start on the new bar */
break;
}
}
--it;
}
}

double totalWaste = 0.0;
for(unsigned i = 0; i < bars.size(); ++i){
std::cout << "Bar " << std::setw(2) << i + 1 << ":\t";
for(unsigned j = 0; j < bars[i].size(); ++j)
std::cout << std::setprecision(3) << std::fixed << bars[i][j] << " ";
std::cout << std::endl;
std::partial_sum(bars[i].begin(), bars[i].end(), bars[i].begin());
totalWaste += NEW_BAR_LENGTH - bars[i].back();
}

/* Print a summary */
std::cout << "===============================" << std::endl;
std::cout << "Bars used:\t" << bars.size() << std::endl;
std::cout << "Total waste:\t" << totalWaste << " m" << std::endl;
std::cout << "Waste/Bar:\t" << totalWaste/bars.size() << " m" << std::endl;
std::cout << "===============================" << std::endl;
system("pause");
return 0;
}``````

OK, you probably shouldn't aim a forum question at a particular user, since that user may

1. Not be checking the forum that week

Better to make a post with a title that describes you problem, such as "Count identical …

## All 2 Replies

OK, you probably shouldn't aim a forum question at a particular user, since that user may

1. Not be checking the forum that week

Better to make a post with a title that describes you problem, such as "Count identical vectors" or something like that.

As for your problem, the simplest way to do it would be to use `std::unique()` to find the number of different types of bar to cut, and then use `std::count()` to find the number of each bar:

``````/* Find the number of different types of bar to cut */
std::vector< std::vector< double > > uniqueBars(allBars.size());
std::vector< std::vector< double > > it = std::unique_copy(allBars.begin(), allBars.end(), uniqueBars.begin());
uniqueBars.resize(it - uniqueBars.begin());

/* Count how many of each type we need */
std::vector< unsigned > numbers(uniqueBars.size());
for(unsigned i = 0; i < numbers.size(); ++i)
numbers[i] = std::count(uniqueBars.begin(), uniqueBars.end(), uniqueBars[i]);``````

Some warnings:

1. I haven't tested this at all, just wrote it in here
2. `std::unique` only counts the consecutive elements that are equal, so this isn't very robust. You would have to write a new version of `unique()` to do this properly, but I'll leave that up to you!

A better way to do it might be with a combination of `std::stringstream` and `std::map`

Thank you.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of 1.19 million developers, IT pros, digital marketers, and technology enthusiasts learning and sharing knowledge.