Removed 'ghost' files

Reviewed-on: #13

Dockerfile

@@ -1,11 +1,17 @@
-FROM gcc:latest
+FROM gcc:latest AS build
 
 WORKDIR /app
 
-COPY rolls.txt /app/
 COPY include/* /app/include/
 COPY src/* /app/src/
 
 RUN g++ src/*.cpp -o Bowling
 
+FROM debian:sid-slim
+
+WORKDIR /app
+
+COPY --from=build /app/Bowling Bowling
+COPY rolls.txt /app/
+
 CMD ["./Bowling", "rolls.txt"]

README.md

@@ -2,6 +2,7 @@
 
 To run the project, simply follow these steps: 
 1. `git clone https://git.rbwr.dk/owner/Bowling.git`
+2. `cd Bowling/`
 2. `docker build -t bowling .`
 3. `docker run --rm bowling`
 

include/FileHelper.h

@@ -1,13 +0,0 @@
-#ifndef FILEHELPER_H
-#define FILEHELPER_H
-
-class FileHelper {
-    public:
-        FileHelper() = default;
-        
-        ~FileHelper() = default;
-        
-        static bool fileExists(char *path);
-};
-
-#endif

include/FileReader.h

@@ -1,18 +0,0 @@
-#ifndef FILEREADER_H
-#define FILEREADER_H
-
-#include <string>
-#include <vector>
-
-using namespace std;
-
-class FileReader {
-    public:
-        FileReader() = default;
-        
-        ~FileReader() = default;
-        
-        static string getFile(char *path);
-};
-
-#endif

include/FileUtils.h

@@ -0,0 +1,19 @@
+#ifndef FILEUTILS_H
+#define FILEUTILS_H
+
+#include <string>
+#include <vector>
+
+using namespace std;
+
+class FileUtils {
+    public:
+        FileUtils() = default;
+        
+        ~FileUtils() = default;
+        
+        static string getFile(char *path);
+        static bool fileExists(char *path);
+};
+
+#endif

include/Frame.h

@@ -0,0 +1,11 @@
+#ifndef FRAME_H
+#define FRAME_H
+
+#include <vector>
+using namespace std;
+
+struct Frame {
+    vector<int> Roll;
+};
+
+#endif

include/NumberHelper.h

@@ -1,19 +0,0 @@
-#ifndef NUMBERHELPER_H
-#define NUMBERHELPER_H
-
-#include <string>
-#include <vector>
-
-using namespace std;
-
-class NumberHelper {
-    public:
-        NumberHelper() = default;
-        
-        ~NumberHelper() = default;
-        
-        static vector<int> getRolls(string csv);
-};
-
-
-#endif

include/NumberUtils.h

@@ -0,0 +1,28 @@
+#ifndef NUMBERUTILS_H
+#define NUMBERUTILS_H
+
+#include <string>
+#include <vector>
+#include "../include/Frame.h"
+
+using namespace std;
+
+class NumberUtils {
+    public:
+        NumberUtils() = default;
+        
+        ~NumberUtils() = default;
+        
+        static vector<int> getRolls(const string& csv);
+        static bool validateRolls(const vector<int>& rolls);
+        static vector<Frame> createFrames(const vector<int>& rolls);
+    
+    private:
+        static Frame createStrikeFrame(int i);
+        static Frame createFreeFrame(int i, int j);
+        static Frame createBonusFrame(int i, int j, int k);
+        static bool isNumber(const std::string& str);
+};
+
+
+#endif

include/PrintFrames.h

@@ -2,6 +2,8 @@
 #define PRINTFRAMES_H
 
 #include <vector>
+#include <string>
+#include "../include/Frame.h"
 
 using namespace std;
 
@@ -11,8 +13,12 @@ class PrintFrames {
         
         ~PrintFrames() = default;
         
-        static void printHeader(vector<int> rolls);
+        
-        static void printValue(vector<int> rolls);
+        static void printResult(const vector<Frame>& frames);
+        
+    private:
+        static void printHeader();
+        static string parseValue(const vector<Frame>& frames);
 };
 
 #endif

include/ScoreCalculator.h

@@ -3,6 +3,7 @@
 
 #include <string>
 #include <vector>
+#include "../include/Frame.h"
 
 using namespace std;
 
@@ -12,7 +13,7 @@ class ScoreCalculator {
         
         ~ScoreCalculator() = default;
         
-        static int getScore(vector<int> rolls);
+        static int getScore(const vector<Frame>& frames);
 };
 
 #endif

rolls1.txt

@@ -1 +0,0 @@
-10, 3, 2, 2, 3, 5, 4, 9, 1, 2, 5, 3, 2, 4, 2, 3, 3, 4, 6

src/FileHelper.cpp

@@ -1,13 +0,0 @@
-#include "../include/FileHelper.h"
-#include <sys/stat.h>
-
-bool FileHelper::fileExists(char *path){
-    struct stat s;
-    
-    // Check if file exists, and if it isn't a folder.
-    if (stat(path, &s) == 0 && !(s.st_mode & S_IFDIR)){
-        return true;
-    }
-    
-    return false;
-}

src/FileReader.cpp

@@ -1,15 +0,0 @@
-#include "../include/FileReader.h"
-#include <string>
-#include <fstream>
-
-string FileReader::getFile(char *path){
-    ifstream file(path);
-    
-    string line;
-    
-    getline(file, line);
-    
-    file.close();
-    
-    return line;
-}

src/FileUtils.cpp

@@ -0,0 +1,28 @@
+#include "../include/FileUtils.h"
+#include <string>
+#include <fstream>
+#include <sys/stat.h>
+
+bool FileUtils::fileExists(char *path){
+    struct stat s;
+    
+    // Check if file exists, and if it isn't a folder.
+    if (stat(path, &s) == 0 && !(s.st_mode & S_IFDIR)){
+        return true;
+    }
+    
+    return false;
+}
+
+string FileUtils::getFile(char *path){
+    ifstream file(path);
+    
+    string line;
+    
+    // There is only one line in the file
+    getline(file, line);
+    
+    file.close();
+    
+    return line;
+}

src/NumberHelper.cpp

@@ -1,17 +0,0 @@
-#include "../include/NumberHelper.h"
-#include <string>
-#include <sstream>
-#include <vector>
-
-vector<int> NumberHelper::getRolls(string csv){
-    vector<int> rolls;
-    stringstream ss(csv);
-    string number;
-    
-    // Get number from the CSV file, split by comma, and convert to int.
-    while (getline(ss, number, ',')) {
-        rolls.push_back(stoi(number));
-    }
-    
-    return rolls;
-}

src/NumberUtils.cpp

@@ -0,0 +1,140 @@
+#include "../include/NumberUtils.h"
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <cctype>
+
+vector<int> NumberUtils::getRolls(const string& csv){
+    vector<int> rolls;
+    stringstream ss(csv);
+    string number;
+    
+    // Get number from the CSV file, split by comma, and convert to int.
+    while (getline(ss, number, ',')) {
+        if (!isNumber(number)) {
+            cerr << number << " is not a number.";
+            break;
+        }
+        
+        rolls.push_back(stoi(number));
+    }
+    
+    return rolls;
+}
+
+bool NumberUtils::validateRolls(const vector<int>& rolls){
+    int rollCount = rolls.size();
+    
+    for (int i = 0; i < rollCount; ++i) {
+        if (rolls[i] > 10 || rolls[i] < 0) {
+            cerr << "Number: " << rolls[i] << " is invalid.";
+            return false;
+        }
+    }
+    
+    // A game can not have less than 12 rolls, and more than 21.
+    if (rollCount < 12 || rollCount > 21) {
+        cerr << "Incorrect amount of rolls.";
+        return false;
+    }
+    
+    // 10th frame rule.
+    if (rollCount == 21) {
+        if (rolls[18] != 10 && rolls[18] + rolls[19] != 10) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+vector<Frame> NumberUtils::createFrames(const vector<int>& rolls){
+    vector<Frame> frame;
+        
+    int roll = 0;
+    
+    while (roll != rolls.size()) {
+        // Strike
+        if (rolls[roll] == 10) {
+            // If we're on our last frame, and roll a strike, we're given two bonus rolls.
+            if (roll + 3 == rolls.size() && rolls[roll - 3] == 10) {
+                frame.push_back(createBonusFrame(rolls[roll], rolls[roll + 1], rolls[roll + 2]));
+                break;
+            }
+            
+            frame.push_back(createStrikeFrame(10));
+            
+            roll += 1;
+        }
+        
+        // Spare
+        else if (rolls[roll] + rolls[roll + 1] == 10) {
+            // If we're on our last frame, and roll a spare, we're given a bonus roll.
+            if (roll + 3 == rolls.size()) {
+                frame.push_back(createBonusFrame(rolls[roll], rolls[roll + 1], rolls[roll + 2]));
+                break;
+            }
+            
+            frame.push_back(createFreeFrame(rolls[roll], rolls[roll + 1]));
+            
+            roll += 2;
+        }
+        
+        // Open Frame
+        else {
+            frame.push_back(createFreeFrame(rolls[roll], rolls[roll + 1]));
+            
+            roll += 2;
+        }
+    }
+    
+    return frame;
+}
+
+Frame NumberUtils::createStrikeFrame(int i){
+    struct Frame frame = Frame();
+    
+    vector<int> rolls;
+    
+    rolls.push_back(i);
+    
+    frame.Roll = rolls;
+    
+    return frame;
+}
+
+Frame NumberUtils::createFreeFrame(int i, int j){
+    struct Frame frame = Frame();
+    
+    vector<int> rolls;
+    
+    rolls.push_back(i);
+    rolls.push_back(j);
+    
+    frame.Roll = rolls;
+    
+    return frame;
+}
+
+Frame NumberUtils::createBonusFrame(int i, int j, int k){
+    struct Frame frame = Frame();
+    
+    vector<int> rolls;
+    
+    rolls.push_back(i);
+    rolls.push_back(j);
+    rolls.push_back(k);
+    
+    frame.Roll = rolls;
+    
+    return frame;
+}
+
+bool NumberUtils::isNumber(const std::string& str){
+    for (size_t i = 0; i < str.size(); ++i) {
+        if (!isdigit(str[i]) && !isspace(str[i])) return false;
+    }
+    
+    return true;
+}

src/PrintFrames.cpp

@@ -1,116 +1,132 @@
 #include "../include/PrintFrames.h"
 #include <iostream>
+#include <sstream>
 
-void PrintFrames::printHeader(vector<int> rolls){
+void PrintFrames::printResult(const vector<Frame>& frames) {
-    int frame = 0;
+    printHeader();
-    int i = 1;
+    cout << parseValue(frames);
+}
 
-    while (true) {
+void PrintFrames::printHeader() {
-        cout << "|";
+    cout << "| f1 | f2 | f3 | f4 | f5 | f6 | f7 | f8 | f9 | f10   |" << endl;
+}
 
+string PrintFrames::parseValue(const vector<Frame>& frames) {
+    stringstream ss;
+    
+    // There can only be 10 frames.
+    for (int i = 0; i < 10; i++) {
+        ss << "|";
         // Strike
-        if (rolls[frame] == 10) {
+        if (frames[i].Roll[0] == 10) {
-            // If we're on our last frame, and roll a strike, we're given two bonus rolls.
+            if (frames[i].Roll.size() == 3) {
-            if (frame + 3 == rolls.size() && rolls[frame - 3] == 10) {
+                ss << "X, ";
-                cout << " f" << i << "   |" << endl;
+                
-                break;
+                if (frames[i].Roll[1] == 10 && frames[i].Roll[2] == 10) {
+                    ss << "X, X";
+                }
+                else if (frames[i].Roll[1] != 10 && frames[i].Roll[2] == 10) {
+                    ss << frames[i].Roll[1] << ", X  ";
+                }
+                else if (frames[i].Roll[1] == 10 && frames[i].Roll[2] != 10) {
+                    ss << "X, " << frames[i].Roll[2] << "  ";
+                }
+                else if (frames[i].Roll[1] == 10 && frames[i].Roll[2] == 0) {
+                    ss << frames[i].Roll[1] << ", -  ";
+                }
+                else if (frames[i].Roll[1] == 0 && frames[i].Roll[2] == 10) {
+                    ss << "-, " << frames[i].Roll[2] << "  ";
+                }
+                else if (frames[i].Roll[1] != 10 && frames[i].Roll[2] == 0) {
+                    ss << frames[i].Roll[1] << ", -  ";
+                }
+                else if (frames[i].Roll[1] == 0 && frames[i].Roll[2] != 10) {
+                    ss << "-, " << frames[i].Roll[2] << "  ";
                 }
                 
-            cout << " f" << i << " ";
+                continue;
-            frame += 1;
+            }
+            
+            // If the next frame has 3 or 2 rolls, then take those 2.
+            if (frames[i + 1].Roll.size() > 1) {
+                if (frames[i + 1].Roll[0] == 10 && frames[i + 1].Roll[1] != 10) {
+                    ss << "X, " << frames[i + 1].Roll[0] << "  ";
+                }
+                else if (frames[i + 1].Roll[0] != 10 && frames[i + 1].Roll[1] == 10) {
+                    ss << frames[i + 1].Roll[1] << ", X";
+                } else {
+                    if (frames[i + 1].Roll[0] + frames[i + 1].Roll[1] == 10) {
+                        ss << "X, " << frames[i + 1].Roll[0] << ", /";
+                    }
+                    else if (frames[i + 1].Roll[0] == 0 && frames[i + 1].Roll[1] != 0) {
+                        ss << "X, " << "-, " << frames[i + 1].Roll[1];
+                    }
+                    else if (frames[i + 1].Roll[0] != 0 && frames[i + 1].Roll[1] == 0) {
+                        ss << "X, " << frames[i + 1].Roll[0] << ", -";
+                    } else {
+                        ss << "X,  ";
+                    }
+                }
+                
+                continue;
+            }
+            
+            // Both next frames, that are not the last, are 10.
+            ss << "X   ";
+            
+            continue;
         }
         
         // Spare
-        else if (rolls[frame] + rolls[frame + 1] == 10) {
+        if (frames[i].Roll[0] + frames[i].Roll[1] == 10) {
-            // If we're on our last frame, and roll a spare, we're given a bonus roll.
+            if (frames[i].Roll.size() == 3) {
-            if (frame + 3 == rolls.size() && rolls[frame] + rolls[frame + 1] == 10)
+                if (frames[i].Roll[0] == 0 && frames[i].Roll[1] != 10  && frames[i].Roll[2] != 10) {
-            {
+                    if (frames[i].Roll[2] == 0) {
-                cout << " f" << i << "   |" << endl;
+                        ss << "-, /, -";
-                break;
+                    } else {
+                        ss << "-, " << frames[i].Roll[1] << frames[i].Roll[2];
+                    }
+                }
+                else if (frames[i].Roll[0] == 0 && frames[i].Roll[1] == 10 && frames[i].Roll[2] != 10) {
+                    if (frames[i].Roll[2] == 0) {
+                        ss << "-, /, -";
+                    } else {
+                        ss << "-, /, " << frames[i].Roll[2];
+                    }
+                }
+                else if (frames[i].Roll[0] == 0 && frames[i].Roll[1] == 10 && frames[i].Roll[2] == 10) {
+                    ss << "-, /, X";
+                } else {
+                    ss << frames[i].Roll[0] << ", /, " << frames[i].Roll[2];
                 }
                 
-            cout << " f" << i << " ";
+                continue;
-            frame += 2;
             }
             
-        // Open Frame
+            ss << frames[i].Roll[0] << ", /";
-        else {
+            continue;
-            cout << " f" << i << " ";
-            frame += 2;
         }
         
-        ++i;
+        // Open frame
+        if (i == 9) {
+            ss << frames[i].Roll[0] << ", " << frames[i].Roll[1] << "   ";
+        } else {
+            if (frames[i].Roll[0] == 0 && frames[i].Roll[1] == 0) {
+                ss << "-, -";
+            }
+            else if (frames[i].Roll[0] == 0 && frames[i].Roll[1] != 0) {
+                ss << "-, " << frames[i].Roll[1];
+            }
+            else if (frames[i].Roll[0] != 0 && frames[i].Roll[1] == 0) {
+                ss << frames[i].Roll[0] << ", -";
+            } else {
+                ss << frames[i].Roll[0] << ", " << frames[i].Roll[1];
+            }
+        }
+    }
     
-        // No more frames
+    ss << "|";
-        if (frame == rolls.size()) {
+    ss << endl;
-            cout << "|" << endl;
+    
-            break;
+    return ss.str();
-        }
-    }
-}
-
-void PrintFrames::printValue(vector<int> rolls){
-    int frame = 0;
-    
-    while (true) {
-        cout << "|";
-        
-        // Strike
-        if (rolls[frame] == 10) {
-            // If we're on our last frame, and roll a strike, we're given two bonus rolls.
-            if (frame + 3 == rolls.size() && rolls[frame - 3] == 10) {
-                if (rolls[frame + 1] == 10 && rolls[frame + 2] == 10) {
-                    cout << "X, X, X|" << endl;
-                }
-                else if (rolls[frame + 1] == 0 && rolls[frame + 2] == 0) {
-                    cout << "X, -, -|" << endl;
-                }
-                else if (rolls[frame + 1] == 0) {
-                    cout << "X, -, " << rolls[frame + 2] << "|" << endl;
-                }
-                else if (rolls[frame + 2] == 0) {
-                    cout << "X, " << rolls[frame + 1] << ", -|" << endl;
-                }
-                else {
-                    cout << "X, " << rolls[frame + 1] << ", " << rolls[frame + 2] << "|" << endl;
-                }
-                
-                break;
-            }
-            
-            cout << "X   ";
-            frame += 1;
-        }
-        
-        // Spare
-        else if (rolls[frame] + rolls[frame + 1] == 10) {
-            // If we're on our last frame, and roll a spare, we're given a bonus roll.
-            if (frame + 3 == rolls.size() && rolls[frame] + rolls[frame + 1] == 10)
-            {
-                cout << rolls[frame] << ", /" << ", " << rolls[frame + 1] << "|" << endl;
-                break;
-            }
-            
-            cout << rolls[frame] << ", /";
-            frame += 2;
-        }
-        
-        // Open Frame
-        else {
-            if (rolls[frame] == 0) {
-                cout << "-" << ", " << rolls[frame + 1];
-            }
-            else if (rolls[frame + 1] == 0) {
-                cout << rolls[frame] << ", -";
-            }
-            
-            cout << "" << rolls[frame] << ", " << rolls[frame + 1];
-            frame += 2;
-        }
-        
-        if (frame == rolls.size()) {
-            cout << " |" << endl;
-            break;
-        }
-    }
 }

src/ScoreCalculator.cpp

@@ -1,45 +1,42 @@
 #include "../include/ScoreCalculator.h"
+#include "../include/Frame.h"
 
-int ScoreCalculator::getScore(vector<int> rolls) {
+int ScoreCalculator::getScore(const vector<Frame>& frames) {
     int score = 0;
-    int frame = 0;
     
-    while (true) {
+    // There can only be 10 frames.
+    for (int i = 0; i < 10; i++) {
         // Strike
-        if (rolls[frame] == 10) {
+        if (frames[i].Roll[0] == 10) {
-            // If we're on our last frame, and roll a strike, we're given two bonus rolls.
+            if (frames[i].Roll.size() == 3) {
-            if (frame + 3 == rolls.size() && rolls[frame - 3] == 10) {
+                score += frames[i].Roll[0] + frames[i].Roll[1] + frames[i].Roll[2];
-                score += 10 + rolls[frame + 1] + rolls[frame + 2];
+                continue;
-                break;
             }
             
-            score += 10 + rolls[frame + 1] + rolls[frame + 2];
+            // If the next frame has 3 or 2 rolls, then take those 2.
-            frame += 1;
+            if (frames[i + 1].Roll.size() > 1) {
+                score += frames[i].Roll[0] + frames[i + 1].Roll[0] + frames[i + 1].Roll[1];
+                continue;
+            }
+            
+            // Both next frames, that are not the last, are 10.
+            score += frames[i].Roll[0] + frames[i + 1].Roll[0] + frames[i + 2].Roll[0];
+            continue;
         }
         
         // Spare
-        else if (rolls[frame] + rolls[frame + 1] == 10) {
+        if (frames[i].Roll[0] + frames[i].Roll[1] == 10) {
-            // If we're on our last frame, and roll a spare, we're given a bonus roll.
+            if (frames[i].Roll.size() == 3) {
-            if (frame + 3 == rolls.size() && rolls[frame] + rolls[frame + 1] == 10)
+                score += frames[i].Roll[0] + frames[i].Roll[1] + frames[i].Roll[2];
-            {
+                continue;
-                score += 10 + rolls[frame + 1];
-                break;
             }
             
-            score += 10 + rolls[frame + 2];
+            score += 10 + frames[i + 1].Roll[0];
-            frame += 2;
+            continue;
         }
         
-        // Open Frame
+        // Open frame
-        else {
+        score += frames[i].Roll[0] + frames[i].Roll[1];
-            score += rolls[frame] + rolls[frame + 1];
-            frame += 2;
-        }
-        
-        // No more frames
-        if (frame == rolls.size()) {
-            break;
-        }
     }
     
     return score;

src/main.cpp

@@ -1,8 +1,7 @@
 #include <iostream>
 #include <string>
-#include "../include/FileReader.h"
+#include "../include/FileUtils.h"
-#include "../include/FileHelper.h"
+#include "../include/NumberUtils.h"
-#include "../include/NumberHelper.h"
 #include "../include/ScoreCalculator.h"
 #include "../include/PrintFrames.h"
 
@@ -14,18 +13,23 @@ int main(int argc, char *argv[]) {
         return 0;
     }
     
-    if (!FileHelper::fileExists(argv[1])) {
+    if (!FileUtils::fileExists(argv[1])) {
         cerr << "Filepath: " << argv[1] << " doesn't exist.";
         return 0;
     }
     
-    string file = FileReader::getFile(argv[1]);
+    string file = FileUtils::getFile(argv[1]);
-    vector<int> rolls = NumberHelper::getRolls(file);
+    vector<int> rolls = NumberUtils::getRolls(file);
     
-    PrintFrames::printHeader(rolls);
+    if (!NumberUtils::validateRolls(rolls)) {
-    PrintFrames::printValue(rolls);
+        return 0;
+    }
     
-    int score = ScoreCalculator::getScore(rolls);
+    vector<Frame> frames = NumberUtils::createFrames(rolls);
+    
+    PrintFrames::printResult(frames);
+    
+    int score = ScoreCalculator::getScore(frames);
     cout << "Score: " << score << endl;
     
     return 0;

test rolls/rolls2.txt

@@ -0,0 +1 @@
+10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10

test rolls/rolls3.txt

@@ -0,0 +1 @@
+5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5

test rolls/rolls4.txt

@@ -0,0 +1 @@
+5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10, 10, 10, 5, 5

test rolls/rolls5.txt

@@ -0,0 +1 @@
+5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 10, 10