Changing fixed size array to vector - c++

Question

A given file contains pairs of . Then take a toss-up two-digit number (called X), and compute the win/loss amount. The win/loss rule is if the input number matches X, then it’s a win and the winning total is (amount * 70); otherwise, it’s a loss of (-amount).
For example: [ticket.txt]
09 10
13 15
25 21
If the toss-up number is 09, the win/loss amount of the ticket is (10 * 70 - 15 - 21 = 664)
If the toss-up number is 42, the win/loss amount of the ticket is (-10 - 15 - 21 = -46).
While reading file by arrays has a fixed size. What I mean is that what if the file ticket.txt doesn't have specific size. Can someone help me to change reading file by array to vector or something else doesn't have fixed size.
For example: [ticket.txt]
09 10
13 15
25 21
.. ..
#include <iostream>
#include <fstream>
using namespace std;
int line1[100]; // array that can hold 100 numbers for 1st column
int line2[100]; // array that can hold 100 numbers for 2nd column
int main()
{
int winNum, winAmount = 0, lostAmount = 0, result = 0;
int num = 0; // num start at 0
ifstream inFile;
inFile.open("Ticket.txt"); //open File
if (inFile.fail())
{
cout << "Fail to open the file" << endl;
return 1;
}
int myArray[3][2];
for(int i = 0; i < 3; i++)
for(int j = 0; j < 2; j++)
inFile >> myArray[i][j];
cout << "Numbers from File: " << endl;
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 2; j++)
{
cout << myArray[i][j] << " ";
}
cout << "\n";
}
cout << endl;
cout << "Enter the toss-up number: "; // enter the win number
cin >> winNum;
for(int i = 0; i< 3;i++)
{
if (myArray[i][0] == winNum)
{
winAmount = myArray[i][1] * 70; // number user choose = win number, winAmount = winAmount * 70 - lostAmount
}
else
{
lostAmount = lostAmount + myArray[i][1]; //number user choose != win number, the amount will be -lost amounts
}
}
result = winAmount - lostAmount;
cout << result;
cout << endl << endl;
system("pause");
return 0;
}

Answer 1

There are a bunch of different ways to approach this problem.
One could make a vector of vectors
std::vector<std::vector<int>> myArray;
but this is pretty wasteful. Only the inner dimension is variable in size, so a quick improvement is
std::vector<std::array<int, 2>> myArray;
Loading myArray can be pretty simple, depending on how much verification you want to include. Here it is with minimal verification:
int number,amount;
while (inFile >> number >> amount)
{
myArray.push_back({number,amount});
}
This will loop until two ints can't be read, be it because of the end of the file or garbage in the file. It is also easily fooled by a file with the worn number of columns . Better approaches use std::getline to get whole lines and make sure exactly two valid numbers and nothing else is on each line.
The rest of your code is unchanged.
But there may be a better way to do this, Consider
a) The loss amount never changes. You can precompute it and eliminate the loop in the event of a loss.
b) Extending on that, you can eliminate part of the loop on a win. The loss amount contains the winning number use the loss amount minus the winning amount. In other words,
winnings = amount * 70 - (loss - amount)
Which is the same as
winnings = amount * 70 - loss + amount
or
winnings = amount * 71 - loss
So we can stop looking as soon as we find a win and only do one calculation.
c) We can eliminate any need for a look-up loop with a std::map.
Reading in the file into a std::map is similar:
std::map<int, int> myMap;
int number,amount;
int loss = 0;
while (inFile >> number >> amount)
{
myMap[number] = amount; // map the amount to the number
loss += amount;
}
and look-up is something like
int result = 0;
auto found = myMap.find(winNum); // look in the map for a number
if (found != myMap.end()) // number is in the map
{
result = 71* found->second; // take the winnings plus one extra to counterbalance
// number's addition to the losses
}
result -= loss; //remove the loss
The calculation loop is completely eliminated and less code is almost always better. Code that's not there has zero bugs. Unless it not being there IS a bug, but that's a different problem.
Note: For small files this approach will be SLOWER. std::map has a much lower time complexity than iterating a std::vector, but each of those iterations it has to perform can be much more expensive.
Documentation on std::array
Documentation on std::vector
Documentation on std::map