I'm solving Problem 11 from Project Euler. I have figured out the algorithm and what I would need to do. The grid is saved in a file grid.txt and its contents are-
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
The question is- What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 20x20 grid?
I know the algorithm is working right because I've tried using cout to output the nums and they show up in the right sequence. It's giving me an incorrect answer though, what could be the fault?
void problem11()
{
vector<vector<int>> grid;
ifstream stream("grid.txt");
string line;
char *tok;
if (stream.is_open())
{
while(stream.good())
{
getline(stream, line);
tok = strtok((char *)line.c_str(), " ");
vector<int> row;
while (tok != NULL)
{
int field;
stringstream ss;
ss << tok;
ss >> field;
row.push_back(field);
tok = strtok(NULL, " ");
}
grid.push_back(row);
}
stream.close();
}
unsigned long highest = 0;
/// LEFT TO RIGHT
for (int i=0; i < 20; i++) // i'th row
{
vector<int> row = grid.at(i);
for (int c=0; c < 20-3; c++) // -3 to accomodate for last
{
unsigned long prod = row.at(c) * row.at(c+1) * row.at(c+2) * row.at(c+3); // four consecutive
//cout << row.at(c) << " " << row.at(c+1) << " " << row.at(c+2) << " " << row.at(c+3) << endl;
if (prod > highest)
highest = prod;
}
}
/// TOP TO DOWN
/// This moves from left to right, then top to botom
///
for (int i=0; i < 20-3; i++) // subtract last 3
{
vector<int> row1, row2, row3, row4;
row1 = grid.at(i);
row2 = grid.at(i+1);
row3 = grid.at(i+2);
row4 = grid.at(i+3);
for (int c=0; c < 20; c++)
{
unsigned long prod = row1.at(c) * row2.at(c) * row3.at(c) * row4.at(c);
//cout << row1.at(c) << " " << row2.at(c) << " " << row3.at(c) << " " << row4.at(c) << endl;
if (prod > highest)
highest = prod;
}
}
/// DOWN DIAGONAL
/// This moves diagonally from left to right, top to bottom
for (int i=0; i < 20-3; i++) // subtract last 3
{
vector<int> row1, row2, row3, row4;
row1 = grid.at(i);
row2 = grid.at(i+1);
row3 = grid.at(i+2);
row4 = grid.at(i+3);
for (int c=0; c < 20-3; c++) // omit last 3
{
unsigned long prod = row1.at(c) * row2.at(c+1) * row3.at(c+2) * row4.at(c+3);
//cout << row1.at(c) << " " << row2.at(c+1) << " " << row3.at(c+2) << " " << row4.at(c+3) << endl;
if (prod > highest)
highest = prod;
}
}
/// UP DIAGONAL
/// This moves diagonally from left to right, bottom to top
for (int i=3; i < 20; i++) // start from 3, skipping first four
{
vector<int> row1, row2, row3, row4;
row4 = grid.at(i);
row3 = grid.at(i-1);
row2 = grid.at(i-2);
row1 = grid.at(i-3);
for (int c=0; c < 20-3; c++) // omit last 3
{
unsigned long prod = row4.at(c) * row3.at(c+1) * row3.at(c+2) * row4.at(c+3);
//cout << row4.at(c) << " " << row3.at(c+1) << " " << row2.at(c+2) << " " << row1.at(c+3) << endl;
if (prod > highest)
highest = prod;
}
}
cout << "Required: " << highest;
}
At the risk of spoiling the fun of finding the answer yourself...
Do print out the diagonals. Check visually whether they correspond to what you would expect.
As a side-note: and don't create copies of your table rows, but access them likewise: vector[rowindex][column].
EDIT --
OK now I'm going to spoil it. In a matrix of NxN, how many diagonal paths do you have? How many paths do you traverse? (Cross check this by taking a 2x2 matrix, that has 3 diagonal paths in each direction)
PS. If you take up programming seriously, when encountering a bug, validate your assumptions first.
Try the following input:
0 0 0 1 0 0 ...
0 0 1 0 0 0 ...
0 1 0 0 0 0 ...
1 0 0 0 0 0 ...
0 0 0 0 0 0 ...
.....
and do again what xtofl recommends you.
In general, if you want to reverse the logic of some operation, do it once and only once. (Or, in general, odd number of times.) Beware of replacing a<=b by b>=a, or left to right and top to bottom by right to left and bottom to top, or whatever similar.
I used Javascript to solve this problem. Please let me know if you have any doubts.
<html>
<head>
</head>
<body>
<input type="button" value="Click Me" onClick="onPress()"></input>
</body>
<script>
function onPress()
{
var arr=[
[8,2,22,97,38,15,0,40,0,75 4, 5, 7, 78, 52, 12, 50, 77,91, 8]
[49,49,99, 40,17,81, 18, 57, 60, 87,17,40,98,43,69,48,4,56, 62,0],
[81,49,31,73,55,79,14,29,93,71,40,67,53, 88, 30,3,49,13,36,65],
[52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71, 37, 2, 36, 91],
[22,31,16,71,51,67,63,89,41,92,36, 54,22,40,40,28,66, 33, 13,80],
[24,47,32,60,99,3,45,2,44,75,33,53,78,36,84, 20, 35,17,12,50],
[32,98,81,28,64,23,67,10,26,38,40, 67, 59, 54, 70, 66,18,38,64,70],
[67,26,20,68,2,62,12,20,95,63,94,39,63,8,40, 91, 66, 49, 94, 21],
[24,55,58,5,66,73,99,26,97,17,78,78,96,83,14, 88, 34, 89, 63, 72],
[21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95],
[78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56, 92],
[16,39,5,42,96,35,31,47,55, 58, 88, 24, 0, 17, 54,24,36,29,85,57],
[86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51, 54, 17, 58],
[19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89, 55, 40],
[4,52,8,83,97,35,99,16,7,97,57,32,16,26,26, 79, 33, 27, 98, 66],
[88,36,68,87,57,62,20,72,3,46,33,67,46, 55, 12, 32, 63, 93, 53, 69],
[4,42,16,73,38,25,39,11,24,94,72,18,8,46,29, 32, 40, 62, 76, 36],
[20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36, 16],
[20,73,35,29,78,31,90,1,74,31,49,71,48,86, 81, 16, 23, 57,5, 54],
[1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1, 89, 19, 67, 48]
];
var i, j, product=0, arr2=[], max;
/* Horizontal 4 digit multiplication*/
for(i=0; i<arr.length; i++)
{
for(j=0; j<17;j++)
{
product= arr[i][j]* arr[i][j+1] *arr[i][j+2] * arr[i][j+3]
arr2.push(product);
}
}
/* Vertical 4 digit multiplication*/
for(var j=0; j<arr.length; j++)
{
for(var i=0; i<17; i++)
{
product= arr[i][j] * arr[i+1][j] * arr[i+2][j] * arr[i+3][j];
arr2.push(product);
}
}
/* left to right diagonal*/
for(var j=0 ; j<17; j++)
{
for(var i=0; i<17; i++)
{
product= arr[i][j]* arr[i+1][j+1]*arr[i+2][j+2]*arr[i+3][j+3];
arr2.push(product)
}
}
/* right to left diagonal*/
for(var i=0; i<17; i++)
{
for(var j=19; j>=3; j--)
{
product= arr[i][j]*arr[i+1][j-1]*arr[i+2][j-2]*arr[i+3][j-3]
arr2.push(product);
}
}
max= Math.max.apply(Math, arr2);
console.log(max)
}
</script>
</html>
This is the code written by me. Gives the correct answer. I hope this helps....
#include <iostream>
#include <vector>
using namespace std;
void main()
{
int num_container[20][20] = {
{ 8,02,22,97,38,15,00,40,00,75,04,05,07,78,52,12,50,77,91, 8},
{49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,04,56,62,00},
{81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,03,49,13,36,65},
{52,70,95,23,04,60,11,42,69,24,68,56,01,32,56,71,37,02,36,91},
{22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80},
{24,47,32,60,99,03,45,02,44,75,33,53,78,36,84,20,35,17,12,50},
{32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70},
{67,26,20,68,02,62,12,20,95,63,94,39,63, 8,40,91,66,49,94,21},
{24,55,58,05,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72},
{21,36,23, 9,75,00,76,44,20,45,35,14,00,61,33,97,34,31,33,95},
{78,17,53,28,22,75,31,67,15,94,03,80,04,62,16,14, 9,53,56,92},
{16,39,05,42,96,35,31,47,55,58,88,24,00,17,54,24,36,29,85,57},
{86,56,00,48,35,71,89,07,05,44,44,37,44,60,21,58,51,54,17,58},
{19,80,81,68,05,94,47,69,28,73,92,13,86,52,17,77,04,89,55,40},
{04,52, 8,83,97,35,99,16,07,97,57,32,16,26,26,79,33,27,98,66},
{88,36,68,87,57,62,20,72,03,46,33,67,46,55,12,32,63,93,53,69},
{04,42,16,73,38,25,39,11,24,94,72,18, 8,46,29,32,40,62,76,36},
{20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,04,36,16},
{20,73,35,29,78,31,90,01,74,31,49,71,48,86,81,16,23,57,05,54},
{01,70,54,71,83,51,54,69,16,92,33,48,61,43,52,01,89,19,67,48},
};
int test = num_container[6][8] * num_container[7][9] * num_container[8][10] * num_container[9][11];
cout<<test<<endl;
system("pause");
int start = 0;
int end = 3;
long long mul_result = 1;
vector<long long>final_results;
/////////////////////UP/DOWN/////////////////////
for(int k=0; k<20; k++)
{
for(int i=0; i<=16; i++)
{
for(int j=start; j<=end; j++)
{
mul_result = mul_result * num_container[k][j];
if (j == end)
final_results.push_back(mul_result);
}
mul_result = 1;
start++;
end++;
}
start = 0;
end = 3;
for(int i=0; i<=16; i++)
{
for(int j=start; j<=end; j++)
{
mul_result = mul_result * num_container[j][k];
if (j == end)
final_results.push_back(mul_result);
}
mul_result = 1;
start++;
end++;
}
start = 0;
end = 3;
}
/////////////////////UP/DOWN Ends here//////////////////////
///////////////////Both Ways Diagonal Starts here//////////////////////
int current_row = 0;
for(int i=0; i<=16; i++)
{
for(int j=0; j<=16; j++)
{
current_row = i;
for(int k=start; k<=end; k++)
{
mul_result = mul_result * num_container[current_row][k];
current_row++;
if (k==end)
final_results.push_back(mul_result);
}
mul_result = 1;
start++;
end++;
}
start = 0;
end = 3;
for(int j=0; j<=16; j++)
{
current_row = i+3;
for(int k=start; k<=end; k++)
{
mul_result = mul_result * num_container[current_row][k];
current_row--;
if (k==end)
final_results.push_back(mul_result);
}
mul_result = 1;
start++;
end++;
}
start = 0;
end = 3;
}
/////////////////////Both Ways diagonal ends here///////////////////
////////////////////Compare Thning Starts here//////////////////////
long long the_big_one = 0;
for(int i=0; i<final_results.size(); i++)
{
if (final_results[i] > the_big_one)
the_big_one = final_results[i];
}
cout<<endl<<endl<<"The big one is: "<<the_big_one<<endl;
system("pause");
}
Related
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 3 years ago.
Improve this question
What would be the simplest way to reorder my number values in the second matrix with 90 being in the top left and 10 being in the bottom right? My brain is going blank and I know there has to be any easy way to go about this. Any help is appreciated tremendously!
Here's what I'm trying to achieve.
#include <iostream>
using namespace std;
void main() {
cout << "Before:" << endl;
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
int matrix[9][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,70,71,72 },
{ 73,74,75,76,77,78,79,80,81 },
{ 82,83,84,85,86,87,88,89,90 }
};
cout << matrix[i][j] << " ";
}
cout << endl;
}
cout << "After:" << endl;
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
int transMatrix[9][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,70,71,72 },
{ 73,74,75,76,77,78,79,80,81 },
{ 82,83,84,85,86,87,88,89,90 }
};
cout << transMatrix[j][i] << " ";
}
cout << endl;
}
}
You could just loop in reverese.
for (int i = 8; i >= 0; i--) {
for (int j = 8; j >= 0; j--) {
//Print element [j][i] here
}
}
Also move the matrix assignment to outside of the loop as pointed out by Federico
Let's consider the following matrix
#define ROW 3
#define COL 4
int main()
{
int mat [ROW][COL] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
//...
return 0;
}
1/ If you want the backwards matrix
int backwards_mat[ROW][COL];
for(size_t i = 0; i < ROW; ++i)
{
for(size_t j = 0; j < COL; ++j)
{
backwards_mat[i][j] = mat[ROW-1-i][COL-1-j];
}
}
2/ If you want the transposed matrix
int transposed_mat[COL][ROW]; //swap the dimensions
for(size_t i = 0; i < ROW; ++i)
{
for(size_t j = 0; j < COL; ++j)
{
transposed_mat[j][i] = mat[i][j];
}
}
If you prints the two matrices, the backwards will be:
12 11 10 9
8 7 6 5
4 3 2 1
And the transposed will be:
1 5 9
2 6 10
3 7 11
4 8 12
You should be able to easily apply this to your matrix.
Do you mean the following?
#include <iostream>
#include <utility>
int main()
{
const size_t N = 9;
int matrix[N][N] =
{
{ 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,70,71,72 },
{ 73,74,75,76,77,78,79,80,81 },
{ 82,83,84,85,86,87,88,89,90 }
};
for ( const auto &row : matrix )
{
for ( const auto &item : row ) std::cout << item << ' ';
std::cout << '\n';
}
std::cout << '\n';
for ( size_t i = 0; i < N; i++ )
{
for ( size_t j = 0; j < N - i - 1; j++ ) std::swap( matrix[i][j], matrix[N-j-1][N-i-1] );
}
for ( const auto &row : matrix )
{
for ( const auto &item : row ) std::cout << item << ' ';
std::cout << '\n';
}
std::cout << '\n';
}
The program output is
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 70 71 72
73 74 75 76 77 78 79 80 81
82 83 84 85 86 87 88 89 90
90 81 72 63 54 45 36 27 18
89 80 71 62 53 44 35 26 17
88 79 70 61 52 43 34 25 16
87 78 69 60 51 42 33 24 15
86 77 68 59 50 41 32 23 14
85 76 67 58 49 40 31 22 13
84 75 66 57 48 39 30 21 12
83 74 65 56 47 38 29 20 11
82 73 64 55 46 37 28 19 10
I did the weighted quick union with path compression(Sedgewick & Wayne) and got filled an array, let's say, id[i] in which connected components are laid according to different roots. IF id[i] == i, then i is a root. if not, id[i] is a parent of i. My question is how do I get "a list of connected components (differing roots)" from this array. I am confused of how to find root of each id because these are pointing only to immediate parent.
The following are id[i] values (parent or grandparent) in the order of i:
0 1 1 1 1 1 1 1 1 1 1 11 11 13 14 1 1 1 1 19 20 1 1 23 24 24 23 27 27 57 29 29 29 29 29 29 29 29 29 29 29 41 29 29 29 29 29 29 29 29 50 51 51 29 29 29 29 57 29 29 60 57 57 57 57 57 65 65 29 69 69 57 57 57 57 57 57 57 57 29 57 57 57 57 57 57 29 87 57 57 57 57 57 57 57 29 96 57 57 57 57 57 57 57 57 57 29 29 29 29 110 57 57 57 57 57 29 29 118 57 57 57 57 57 57 29 29 144 57 57 57 57 57 29 29 144 144 144 57 57 57 57 57 29 29 29 29 29 29 29 29 29 57 57 57 57 57 57 29 29 29 29 29 29 29 29 29 29 29 29 57 57 57 57 57 57 57
My code is:
vector<vector<short>> components() {
vector<short> root, separated;
vector<vector<short>> list;
for (int i = 0; i < id.size(); i++) {
if (i == id[i]) root.push_back(i);
else id[i] = id[id[i]];
}
for (int j = 0; j < root.size(); j++) {
separated.clear();
for (int i = 0; i < id.size(); i++) { if (root[j] == id[i]) separated.push_back(i); }
list.push_back(separated);
}
std::sort(list.begin(), list.end(), [](const vector<short> & a, const vector<short> & b) { return a.size() > b.size(); });
return list; // return a list of connected components labelled
}
///////////////////////////////////////////////////////////////////
I have managed to fix the above code as follows:
vector<vector<short>> components() {
vector<short> root, separated;
vector<vector<short>> list;
for (int i = 0; i < id.size(); i++) id[i] = find(i);
for (int i = 0; i < id.size(); i++) if (i == id[i]) root.push_back(i);
for (int j = 0; j < root.size(); j++) {
separated.clear();
for (int i = 0; i < id.size(); i++) { if (root[j] == id[i]) separated.push_back(i); }
list.push_back(separated);
}
std::sort(list.begin(), list.end(), [](const vector<short> & a, const vector<short> & b) { return a.size() > b.size(); });
return list;
}
int find(int p) {
while (p != id[p]) {
id[p] = id[id[p]];
p = id[p];
}
return p;
}
Now it is working fine.
I am trying to write code that will list and reverse all digit pairs from 01 - 99. 01-09 is easy enough since you just have to multiply it by 10. I also know at least one way to reverse a given digit, I just don't know how to properly use it with a for loop.
This is what I have so far.
for ( int num99 =1 ; num99 > 0 && num99 < 100; num99 = num99+1)
{
if (num99 <10){
temp99 = num99 * 10;
cout << temp99 << endl;
}
else {
while (num99 != 0) {
remainder99 = num99 % 10;
reverse99 = (reverse99 * 10) + remainder99;
num99 = num99 / 10;
}
cout << reverse99 << endl;
}
}
Thank you for any help.
You have to reinitialize the values of remainder99, reverse99, temp99, num99 after you have used them.
You also have to prepend 0 to the result, when you reverse 10, 20, 30 etc... to get 01, 02, 03 etc...
After making the necessary changes, your program will look like this.
#include<iostream>
using namespace std;
int main(void)
{
int remainder99 = 0;
int reverse99 = 0;
int temp99 = 0;
for ( int num99 =1 ; num99 > 0 && num99 < 100; num99 = num99+1)
{
if (num99 <10){
temp99 = num99 * 10;
cout << temp99 << endl;
}
else {
temp99 = num99;
while (num99 != 0) {
remainder99 = num99 % 10;
reverse99 = (reverse99 * 10) + remainder99;
num99 = num99 / 10;
}
if(reverse99 < 10) cout << 0;
cout << reverse99 << endl;
reverse99 = 0;
remainder99 = 0;
num99 = temp99;
}
}
return 0;
}
Output is:
10
20
30
40
50
60
70
80
90
01
11
21
31
41
51
61
71
81
91
02
12
22
32
42
52
62
72
82
92
03
13
23
33
43
53
63
73
83
93
04
14
24
34
44
54
64
74
84
94
05
15
25
35
45
55
65
75
85
95
06
16
26
36
46
56
66
76
86
96
07
17
27
37
47
57
67
77
87
97
08
18
28
38
48
58
68
78
88
98
09
19
29
39
49
59
69
79
89
99
What you are trying to do is trying to operate over the loop variable, which causes unexpected results. Instead, separate your loop variable and your num99 variable like this:
for (int i = 1; i < 100; i++) {
int num99 = i;
if (num99 < 10) {
temp99 = num99 * 10;
cout << temp99 << endl;
} else {
remainder99 = num99 % 10;
num99 = num99 / 10;
if (remainder99 == 0) {
cout<<"0"<<num99<<endl;
} else {
reverse99 = remainder99 * 10 + num99;
cout << reverse99 << endl;
}
}
}
I have also taken the liberty of assuming that when you reverse the two digit numbers like 10, 20, etc, you want the output to be 01, 02, like that, if that is not what is expected by you, you can remove the if condition.
There are lot of issues with mentioned code like
Here reverse99 * 10 what is initial value of reverse99 ? Assign it as 0.
Here num99 = num99 / 10; you are modifying original num99 which outer loop variable, instead of this assign num99 to some temporary variable & do operation with that temporary variable.
Sample Code
int main(void) {
int temp99 = 0,remainder99 = 0, reverse99 = 0/* must initialize with 0 */ ;
for ( int num99 =1 ; num99 > 0 && num99 < 100; num99 += 1) {
if (num99 <10){
temp99 = num99 * 10;
std::cout << num99 << std::endl;
}
else {
reverse99 = 0;/*make it as 0 again for every iteration */
temp99 = num99; /* assign loop variable to temp99 & do the operation with that */
while (temp99 != 0) {
remainder99 = temp99 % 10;
reverse99 = (reverse99 * 10) + remainder99;
temp99 /= 10;
}
std::cout << reverse99 << std::endl;
}
}
return 0;
}
A C++11 oriented solution:
#include <vector>
#include <iostream>
#include <numeric>
#include <algorithm>
int main()
{
std::vector<int> in(99);
std::iota(in.begin(), in.end(), 1);
std::for_each(in.begin(), in.end(), [](int& i)
{
i = (i % 10)*10 + (i / 10);
}
);
for (const auto& val : in)
{
std::string out = std::to_string(in);
if (out.size() == 1)
{
out = '0' + out;
}
std::cout << out << std::endl;
}
return 0;
}
For the following program I am unable to get increasing order and decreasing order in sync. As you can see in output increasing and decreasing order are not same.
Program :
#include <iostream>
#include <vector>
#include <algorithm>
#include<stdio.h>
using namespace std;
struct box{
vector<int> dim;
int index;
box(vector<int> temp, int ind)
{
dim = temp;
index = ind;
}
bool operator<(const box &rhs) const
{
for(int i = 0; i < dim.size(); i++)
{
if(dim[i] >= rhs.dim[i])
{
return false;
}
}
return true;
}
void print()
{
for(int i = 0 ; i < dim.size(); i++)
{
cout<<dim[i]<<"\t";
}
cout<<endl;
}
};
int main( )
{
int n,k;
while(scanf("%d %d", &k, &n) == 2){
vector<box> arr;
vector<box> newarr;
for(int i = 0; i < k ; i++)
{
vector<int> temp;
for(int j = 0; j < n ; j++)
{
int a;
cin>>a;
temp.push_back(a);
std::sort(temp.begin(), temp.end());
}
arr.push_back(box(temp,i+1));
newarr.push_back(box(temp,i+1));
}
std::sort(arr.begin(), arr.end());
cout<<"Increasing Order"<<endl;
for(int i =0 ; i < k ; i++)
{
arr[i].print();
}
std::sort(newarr.rbegin(), newarr.rend());
cout<<"Decreasing Order"<<endl;
for(int i =0 ; i < k ; i++)
{
newarr[i].print();
}
}
return 0;
}
Input :
27 2
39 26
63 17
64 46
75 13
26 25
21 45
15 22
41 41
98 92
27 81
37 65
39 25
53 50
72 55
12 42
66 65
10 96
90 90
93 77
24 70
64 49
87 79
33 99
59 11
49 43
43 31
76 85
My Output:
Increasing Order
12 42
24 70
25 39
11 59
15 22
25 26
21 45
41 41
31 43
43 49
37 65
46 64
50 53
17 63
26 39
33 99
49 64
90 90
77 93
10 96
65 66
55 72
13 75
27 81
76 85
79 87
92 98
Decreasing Order
76 85
33 99
92 98
79 87
77 93
90 90
10 96
65 66
55 72
27 81
37 65
50 53
46 64
49 64
43 49
41 41
31 43
26 39
24 70
17 63
13 75
11 59
25 26
21 45
12 42
25 39
15 22
Just write
bool operator<(const box &rhs) const
{
return dim < rhs.dim;
}
You can directly use std::vector::operator< (it will do lexicographically compare), example:
std::vector<int> a = {0,1,2};
std::vector<int> b = {1,2,3};
std::cout << (a < b);
outputs 1.
Here you can find vector implements also other operators: =,!=,<,<=,>,>=
void allocateTriangle(int ** & twoDArray, int numRows);
void printTriangle(int ** twoDArray, int numRows);
void growToSquare(int ** & twoDArray, int numRows);
void printSquare(int ** & twoDArray, int numRows);
using namespace std;
int main(int argc, char ** argv){
srand((unsigned int)time(NULL));
int ** twoDArray;
int numRows = 10;
allocateTriangle(twoDArray, numRows);
cout << "******* Triangle array *******" << endl;
printTriangle(twoDArray, numRows);
growToSquare(twoDArray, numRows);
cout << "******* Sqaure array *******" << endl;
printSquare(twoDArray, numRows);
return 0;
}
void allocateTriangle(int ** & twoDArray, int numRows) {
twoDArray = new int*[numRows];
for (int x = 0; x < numRows; x++){
twoDArray[x] = new int[x];
for (int y = 0; y <= x; y++){
twoDArray[x][y] = rand() % 100;
}
}
}
void printTriangle(int ** twoDArray, int numRows){
for (int x = 0; x < numRows; x++){
for (int y = 0; y <= x; y++){
cout << setw(5);
cout << twoDArray[x][y];
}
cout << endl;
}
}
void growToSquare(int ** & twoDArray, int numRows) {
for (int x = 0; x < numRows; x++){
int *tempArray = new int[x];
*tempArray = *twoDArray[x];
--> delete [] twoDArray[x];
twoDArray[x] = new int[numRows];
for (int y = 0; y < numRows; y++){
if (y <= x)
twoDArray[x][y] = tempArray[y];
else
twoDArray[x][y] = rand() % 100;
}
}
}
void printSquare(int ** & twoDArray, int numRows){
for (int x = 0; x < numRows; x++){
for (int y = 0; y <= numRows; y++){
cout << setw(5);
if (y <= x)
cout << twoDArray[x][y];
else if (y - 1 == x)
cout << " ";
else
cout << twoDArray[x][y - 1];
}
cout << endl;
}
}
The arrow is pointing to where this program likes to crash. Giving me a Heap Corruption, I've spent the last 6 hours looking at this and other posts, I got nothing.
The main gets to growToSquare() and when I try to 'resize' the 2D array by deletion and allocation again, it stopes at deletion. I've commented out other lines to code to see if something else is triggering, nada.
Any words of advice? (I am using Visual studio 2013)
WhozCraig spotted it, in his comment above.
y <= x should be y < x, in multiple places in this code. – WhozCraig
Imagine that numRows is 1 here, for the sake of simplicity. Follow the code logic in that simple case.
void allocateTriangle(int ** & twoDArray, int numRows) {
twoDArray = new int*[numRows];
for (int x = 0; x < numRows; x++){
twoDArray[x] = new int[x];
for (int y = 0; y <= x; y++){
twoDArray[x][y] = rand() % 100;
}
}
}
Here is the code that would execute, which assigns to a zero-length array.
twoDArray = new int*[1];
twoDArray[0] = new int[0];
twoDArray[0][0] = rand() % 100;
Memory has now been corrupted.
Plausible Solution for Triangle Allocation
Though there a about a half-dozen different ways to calculate the indices, this way is likely the easiest to understand.
void allocateTriangle(int ** & twoDArray, int numRows)
{
twoDArray = new int*[numRows];
for (int x = 0; x < numRows; x++)
{
twoDArray[x] = new int[x+1]; // NOTE: size
for (int y = 0; y <= x; y++)
twoDArray[x][y] = rand() % 100;
}
}
void printTriangle(int ** twoDArray, int numRows)
{
for (int x = 0; x < numRows; cout << endl, ++x)
for (int y = 0; y <= x; y++)
cout << setw(5) << twoDArray[x][y];
}
This allows you to keep your indexing (mostly) while sizing the allocations to appropriate lengths.
Growing a Triangle Into A Square
Similarly, the following will extend your triangle into a square. Note: you can invoke this on something already extended to a square. It will simply re-random-generate the right-half diagonal when doing so (and rather expensively at that).
void growToSquare(int ** & twoDArray, int numRows)
{
for (int x = 0; x < numRows; x++)
{
int *tempArray = new int[numRows];
for (int y=0; y<=x; ++y)
tempArray[y] = twoDArray[x][y];
for (int y=x+1; y<numRows; ++y)
tempArray[y] = rand() % 100;
delete [] twoDArray[x];
twoDArray[x] = tempArray;
}
}
void printSquare(int ** & twoDArray, int numRows)
{
for (int x = 0; x < numRows; cout << endl, ++x)
for (int y = 0; y < numRows; y++)
cout << setw(5) << twoDArray[x][y];
}
Output
Using the above methods, your output will look something like this. Obviously the random nature will result in different values, but the important thing is the bottom-left portion of the square retains the original triangle.
******* Triangle array *******
80
80 1
45 93 28
19 96 90 7
38 70 23 26 98
97 26 98 48 37 97
77 25 43 0 28 84 90
95 78 48 16 23 30 14 64
14 29 83 60 7 83 14 77 94
79 1 43 55 22 14 80 34 40 53
******* Sqaure array *******
80 10 62 17 62 94 62 47 87 3
80 1 56 67 56 91 85 51 25 8
45 93 28 9 42 57 95 56 19 42
19 96 90 7 46 67 42 77 53 73
38 70 23 26 98 53 22 34 69 3
97 26 98 48 37 97 8 18 53 55
77 25 43 0 28 84 90 7 82 43
95 78 48 16 23 30 14 64 94 33
14 29 83 60 7 83 14 77 94 75
79 1 43 55 22 14 80 34 40 53