Now uses stringstreams

1Codealot · 1Codealot · commit ef383e37996b · 2023-12-19T07:11:26.000Z
diff --git a/src/NxNMoveGen.hpp b/src/NxNMoveGen.hpp
@@ -3,7 +3,7 @@ This code is here to deprecate the original Scrambles.hpp and stringCleanup.hpp
 */
 #pragma once
 
-#include <string>
+#include <sstream>
 #include <random>
 
 inline std::random_device rng;
@@ -81,7 +81,7 @@ inline void createMove(puzzle_move &newMove, const char moveType)
     }
 }
 
-inline std::string getRepresentation(const puzzle_move *pMove)
+static inline std::string getRepresentation(const puzzle_move *pMove)
 {
     std::string finalMove;
     finalMove += pMove->base;
@@ -107,3 +107,8 @@ inline std::string getRepresentation(const puzzle_move *pMove)
 
     return finalMove;
 }
+
+std::ostringstream& operator<< (std::ostringstream& oss, const puzzle_move& pMove){
+    oss << getRepresentation(&pMove);
+    return oss;
+}
diff --git a/src/Scrambles.hpp b/src/Scrambles.hpp
@@ -56,7 +56,7 @@ You need a minimum of 2 references to a move struct.
 
 static std::string Two_By_Two()
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     const int moveCount = getRandomNum(9, 13);
@@ -71,15 +71,15 @@ static std::string Two_By_Two()
             createMove(Move, '2');
         } while (!canUseMove(&PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + ' ';
+        scramble << Move << ' ';
         PrevMove = Move; // Don't forget this!! :DDDDDDDDDD
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Three_By_Three(const bool blind)
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     puzzle_move TwoPrevMove{};
@@ -102,7 +102,7 @@ static std::string Three_By_Three(const bool blind)
             createMove(Move, '3');
         } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + ' ';
+        scramble << Move << ' ';
         TwoPrevMove = PrevMove;
         PrevMove = Move; //
     }
@@ -117,12 +117,12 @@ static std::string Three_By_Three(const bool blind)
             } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
             Move.wsize = '2';
-            scramble += getRepresentation(&Move) + ' ';
+            scramble << Move << ' ';
             TwoPrevMove = PrevMove;
             PrevMove = Move;
         }
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string FMC()
@@ -135,6 +135,8 @@ static std::string FMC()
     const puzzle_move U_Prime{'U', '\'', ' '};
     const puzzle_move F{'F', ' ', ' '};
 
+    // This is unchanged because for some reason c++ doesn't like it when I do scramble << R_Prime << ' '.
+    // No it's not because I'm using a std::string instead of a std::ostringstream.
     scramble += getRepresentation(&R_Prime) + ' ' + getRepresentation(&U_Prime) + ' ' + getRepresentation(&F) + ' ';
 
     puzzle_move Move = F;
@@ -171,7 +173,7 @@ static std::string FMC()
 
 static std::string Four_By_Four(bool blind)
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     puzzle_move TwoPrevMove{};
@@ -195,7 +197,7 @@ static std::string Four_By_Four(bool blind)
             createMove(Move, '4');
         } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + " ";
+        scramble << Move << " ";
         TwoPrevMove = PrevMove;
         PrevMove = Move; //
     }
@@ -204,25 +206,25 @@ static std::string Four_By_Four(bool blind)
     {
         for (int k = 0; k < cubeRotateCount; k++)
         {
-            scramble += ('x' + k);
+            scramble << (char)('x' + k);
             int dir = getRandomNum(1, 3);
             if (dir == 2)
             {
-                scramble += '2';
+                scramble << '2';
             }
             else if (dir == 3)
             {
-                scramble += '\'';
+                scramble << '\'';
             }
-            scramble += ' ';
+            scramble << ' ';
         }
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Five_By_Five(bool blind)
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     puzzle_move TwoPrevMove{};
@@ -245,7 +247,7 @@ static std::string Five_By_Five(bool blind)
             createMove(Move, '5');
         } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + " ";
+        scramble << Move << " ";
         TwoPrevMove = PrevMove;
         PrevMove = Move; //
     }
@@ -260,17 +262,17 @@ static std::string Five_By_Five(bool blind)
             } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
             Move.wsize = '3';
-            scramble += getRepresentation(&Move) + ' ';
+            scramble << Move << ' ';
             TwoPrevMove = PrevMove;
             PrevMove = Move;
         }
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Six_By_Six()
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     puzzle_move TwoPrevMove{};
@@ -293,16 +295,16 @@ static std::string Six_By_Six()
             createMove(Move, '6');
         } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + " ";
+        scramble << Move << " ";
         TwoPrevMove = PrevMove;
         PrevMove = Move; //
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Seven_By_Seven()
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     puzzle_move TwoPrevMove{};
@@ -325,16 +327,16 @@ static std::string Seven_By_Seven()
             createMove(Move, '7');
         } while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + " ";
+        scramble << Move << " ";
         TwoPrevMove = PrevMove;
         PrevMove = Move; //
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Skewb()
 {
-    std::string scramble;
+    std::ostringstream scramble;
     puzzle_move Move{};
     puzzle_move PrevMove{};
     const int moveCount = getRandomNum(9, 13);
@@ -349,60 +351,60 @@ static std::string Skewb()
             createMove(Move, 'S');
         } while (!canUseMove(&PrevMove, &Move));
 
-        scramble += getRepresentation(&Move) + ' ';
+        scramble << Move << ' ';
         PrevMove = Move; // Don't forget this!! :DDDDDDDDDD
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Megaminx()
 {
     bool Dpp;
-    std::string scramble;
+    std::ostringstream scramble;
 
     for (int i = 0; i < 5; i++)
     {
         for (int n = 0; n < 7; n++)
         {
-            scramble += "R";
+            scramble << "R";
             if (getRandomNum(0, 1) == 0)
             {
-                scramble += "++ ";
+                scramble << "++ ";
             }
             else
             {
-                scramble += "-- ";
+                scramble << "-- ";
             }
 
-            scramble += "D";
+            scramble << "D";
             if (getRandomNum(0, 1) == 0)
             {
-                scramble += "++ ";
+                scramble << "++ ";
                 Dpp = true;
             }
             else
             {
-                scramble += "-- ";
+                scramble << "-- ";
                 Dpp = false;
             }
         }
         if (Dpp)
         {
-            scramble += "U \n";
+            scramble << "U \n";
         }
         else
         {
-            scramble += "U' \n";
+            scramble << "U' \n";
         }
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Pyraminx()
 {
     constexpr char tips[] = {'u', 'l', 'r', 'b'};
-    std::string scramble;
-    scramble += Skewb();
+    std::ostringstream scramble;
+    scramble << Skewb();
 
     for (int i = 0; i < 3; i++)
     {
@@ -412,54 +414,55 @@ static std::string Pyraminx()
         }
         else if (direction == 2)
         {
-            scramble += tips[i];
-            scramble += " ";
+            scramble << tips[i];
+            scramble << " ";
         }
         else if (direction == 3)
         {
-            scramble += tips[i];
-            scramble += "' ";
+            scramble << tips[i];
+            scramble << "' ";
         }
     }
-    return scramble;
+    return scramble.str();
 }
 
 static std::string Clock()
 {
     const std::string hours[] = {"5-", "4-", "3-", "2-", "1-", "0+", "1+", "2+", "3+", "4+", "5+", "6+"};
-    std::string scramble = "UR" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "DR" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "DL" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "UL" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "U" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "R" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "D" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "L" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "ALL" + hours[getRandomNum(0, 11)] + " " + "y2" + " ";
-    scramble += "U" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "R" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "D" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "L" + hours[getRandomNum(0, 11)] + " ";
-    scramble += "ALL" + hours[getRandomNum(0, 11)] + " ";
+    std::ostringstream scramble;
+    scramble << "UR" << hours[getRandomNum(0, 11)] << " "
+    << "DR" << hours[getRandomNum(0, 11)] << " "
+    << "DL" << hours[getRandomNum(0, 11)] << " "
+    << "UL" << hours[getRandomNum(0, 11)] << " "
+    << "U" << hours[getRandomNum(0, 11)] << " "
+    << "R" << hours[getRandomNum(0, 11)] << " "
+    << "D" << hours[getRandomNum(0, 11)] << " "
+    << "L" << hours[getRandomNum(0, 11)] << " "
+    << "ALL" << hours[getRandomNum(0, 11)] << " " << "y2" << " "
+    << "U" << hours[getRandomNum(0, 11)] << " "
+    << "R" << hours[getRandomNum(0, 11)] << " "
+    << "D" << hours[getRandomNum(0, 11)] << " "
+    << "L" << hours[getRandomNum(0, 11)] << " "
+    << "ALL" << hours[getRandomNum(0, 11)] << " ";
 
     if (getRandomNum(0, 1) == 1)
     {
-        scramble += "UR ";
+        scramble << "UR ";
     }
     if (getRandomNum(0, 1) == 1)
     {
-        scramble += "DR ";
+        scramble << "DR ";
     }
     if (getRandomNum(0, 1) == 1)
     {
-        scramble += "DL ";
+        scramble << "DL ";
     }
     if (getRandomNum(0, 1) == 1)
     {
-        scramble += "UL ";
+        scramble << "UL ";
     }
 
-    return scramble;
+    return scramble.str();
 }
 
 // Use this one
diff --git a/src/main.cpp b/src/main.cpp
@@ -1,7 +1,6 @@
 #include "cmdLineParser.hpp"
 #include "Scrambles.hpp"
 #include "fileIO.hpp"
-#include "outputting.hpp"
 
 int main(int argc, char const *argv[])
 {
diff --git a/src/outputting.hpp b/src/outputting.hpp
@@ -180,4 +180,5 @@ void outputVersion()
     std::cout << "Scramble outputs ⅓ of the screen + avg to right" << std::endl;
 	std::cout << "Moved the outputting code to another file." << std::endl;
 	std::cout << "Fixed a bug if something was of length 0." << std::endl;
+	std::cout << "Used std::stringstream instead of std::string" << std::endl;
 }

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ This code is here to deprecate the original Scrambles.hpp and stringCleanup.hpp`
`3`	`3`	`*/`
`4`	`4`	`#pragma once`
`5`	`5`
`6`		`-#include <string>`
	`6`	`+#include <sstream>`
`7`	`7`	`#include <random>`
`8`	`8`
`9`	`9`	`inline std::random_device rng;`
`@@ -81,7 +81,7 @@ inline void createMove(puzzle_move &newMove, const char moveType)`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-inline std::string getRepresentation(const puzzle_move *pMove)`
	`84`	`+static inline std::string getRepresentation(const puzzle_move *pMove)`
`85`	`85`	`{`
`86`	`86`	`std::string finalMove;`
`87`	`87`	`finalMove += pMove->base;`
`@@ -107,3 +107,8 @@ inline std::string getRepresentation(const puzzle_move *pMove)`
`107`	`107`
`108`	`108`	`return finalMove;`
`109`	`109`	`}`
	`110`	`+`
	`111`	`+std::ostringstream& operator<< (std::ostringstream& oss, const puzzle_move& pMove){`
	`112`	`+ oss << getRepresentation(&pMove);`
	`113`	`+ return oss;`
	`114`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ You need a minimum of 2 references to a move struct.`
`56`	`56`
`57`	`57`	`static std::string Two_By_Two()`
`58`	`58`	`{`
`59`		`- std::string scramble;`
	`59`	`+ std::ostringstream scramble;`
`60`	`60`	`puzzle_move Move{};`
`61`	`61`	`puzzle_move PrevMove{};`
`62`	`62`	`const int moveCount = getRandomNum(9, 13);`
`@@ -71,15 +71,15 @@ static std::string Two_By_Two()`
`71`	`71`	`createMove(Move, '2');`
`72`	`72`	`} while (!canUseMove(&PrevMove, &Move));`
`73`	`73`
`74`		`- scramble += getRepresentation(&Move) + ' ';`
	`74`	`+ scramble << Move << ' ';`
`75`	`75`	`PrevMove = Move; // Don't forget this!! :DDDDDDDDDD`
`76`	`76`	`}`
`77`		`- return scramble;`
	`77`	`+ return scramble.str();`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`static std::string Three_By_Three(const bool blind)`
`81`	`81`	`{`
`82`		`- std::string scramble;`
	`82`	`+ std::ostringstream scramble;`
`83`	`83`	`puzzle_move Move{};`
`84`	`84`	`puzzle_move PrevMove{};`
`85`	`85`	`puzzle_move TwoPrevMove{};`
`@@ -102,7 +102,7 @@ static std::string Three_By_Three(const bool blind)`
`102`	`102`	`createMove(Move, '3');`
`103`	`103`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`104`	`104`
`105`		`- scramble += getRepresentation(&Move) + ' ';`
	`105`	`+ scramble << Move << ' ';`
`106`	`106`	`TwoPrevMove = PrevMove;`
`107`	`107`	`PrevMove = Move; //`
`108`	`108`	`}`
`@@ -117,12 +117,12 @@ static std::string Three_By_Three(const bool blind)`
`117`	`117`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`118`	`118`
`119`	`119`	`Move.wsize = '2';`
`120`		`- scramble += getRepresentation(&Move) + ' ';`
	`120`	`+ scramble << Move << ' ';`
`121`	`121`	`TwoPrevMove = PrevMove;`
`122`	`122`	`PrevMove = Move;`
`123`	`123`	`}`
`124`	`124`	`}`
`125`		`- return scramble;`
	`125`	`+ return scramble.str();`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`static std::string FMC()`
`@@ -135,6 +135,8 @@ static std::string FMC()`
`135`	`135`	`const puzzle_move U_Prime{'U', '\'', ' '};`
`136`	`136`	`const puzzle_move F{'F', ' ', ' '};`
`137`	`137`
	`138`	`+ // This is unchanged because for some reason c++ doesn't like it when I do scramble << R_Prime << ' '.`
	`139`	`+ // No it's not because I'm using a std::string instead of a std::ostringstream.`
`138`	`140`	`scramble += getRepresentation(&R_Prime) + ' ' + getRepresentation(&U_Prime) + ' ' + getRepresentation(&F) + ' ';`
`139`	`141`
`140`	`142`	`puzzle_move Move = F;`
`@@ -171,7 +173,7 @@ static std::string FMC()`
`171`	`173`
`172`	`174`	`static std::string Four_By_Four(bool blind)`
`173`	`175`	`{`
`174`		`- std::string scramble;`
	`176`	`+ std::ostringstream scramble;`
`175`	`177`	`puzzle_move Move{};`
`176`	`178`	`puzzle_move PrevMove{};`
`177`	`179`	`puzzle_move TwoPrevMove{};`
`@@ -195,7 +197,7 @@ static std::string Four_By_Four(bool blind)`
`195`	`197`	`createMove(Move, '4');`
`196`	`198`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`197`	`199`
`198`		`- scramble += getRepresentation(&Move) + " ";`
	`200`	`+ scramble << Move << " ";`
`199`	`201`	`TwoPrevMove = PrevMove;`
`200`	`202`	`PrevMove = Move; //`
`201`	`203`	`}`
`@@ -204,25 +206,25 @@ static std::string Four_By_Four(bool blind)`
`204`	`206`	`{`
`205`	`207`	`for (int k = 0; k < cubeRotateCount; k++)`
`206`	`208`	`{`
`207`		`- scramble += ('x' + k);`
	`209`	`+ scramble << (char)('x' + k);`
`208`	`210`	`int dir = getRandomNum(1, 3);`
`209`	`211`	`if (dir == 2)`
`210`	`212`	`{`
`211`		`- scramble += '2';`
	`213`	`+ scramble << '2';`
`212`	`214`	`}`
`213`	`215`	`else if (dir == 3)`
`214`	`216`	`{`
`215`		`- scramble += '\'';`
	`217`	`+ scramble << '\'';`
`216`	`218`	`}`
`217`		`- scramble += ' ';`
	`219`	`+ scramble << ' ';`
`218`	`220`	`}`
`219`	`221`	`}`
`220`		`- return scramble;`
	`222`	`+ return scramble.str();`
`221`	`223`	`}`
`222`	`224`
`223`	`225`	`static std::string Five_By_Five(bool blind)`
`224`	`226`	`{`
`225`		`- std::string scramble;`
	`227`	`+ std::ostringstream scramble;`
`226`	`228`	`puzzle_move Move{};`
`227`	`229`	`puzzle_move PrevMove{};`
`228`	`230`	`puzzle_move TwoPrevMove{};`
`@@ -245,7 +247,7 @@ static std::string Five_By_Five(bool blind)`
`245`	`247`	`createMove(Move, '5');`
`246`	`248`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`247`	`249`
`248`		`- scramble += getRepresentation(&Move) + " ";`
	`250`	`+ scramble << Move << " ";`
`249`	`251`	`TwoPrevMove = PrevMove;`
`250`	`252`	`PrevMove = Move; //`
`251`	`253`	`}`
`@@ -260,17 +262,17 @@ static std::string Five_By_Five(bool blind)`
`260`	`262`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`261`	`263`
`262`	`264`	`Move.wsize = '3';`
`263`		`- scramble += getRepresentation(&Move) + ' ';`
	`265`	`+ scramble << Move << ' ';`
`264`	`266`	`TwoPrevMove = PrevMove;`
`265`	`267`	`PrevMove = Move;`
`266`	`268`	`}`
`267`	`269`	`}`
`268`		`- return scramble;`
	`270`	`+ return scramble.str();`
`269`	`271`	`}`
`270`	`272`
`271`	`273`	`static std::string Six_By_Six()`
`272`	`274`	`{`
`273`		`- std::string scramble;`
	`275`	`+ std::ostringstream scramble;`
`274`	`276`	`puzzle_move Move{};`
`275`	`277`	`puzzle_move PrevMove{};`
`276`	`278`	`puzzle_move TwoPrevMove{};`
`@@ -293,16 +295,16 @@ static std::string Six_By_Six()`
`293`	`295`	`createMove(Move, '6');`
`294`	`296`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`295`	`297`
`296`		`- scramble += getRepresentation(&Move) + " ";`
	`298`	`+ scramble << Move << " ";`
`297`	`299`	`TwoPrevMove = PrevMove;`
`298`	`300`	`PrevMove = Move; //`
`299`	`301`	`}`
`300`		`- return scramble;`
	`302`	`+ return scramble.str();`
`301`	`303`	`}`
`302`	`304`
`303`	`305`	`static std::string Seven_By_Seven()`
`304`	`306`	`{`
`305`		`- std::string scramble;`
	`307`	`+ std::ostringstream scramble;`
`306`	`308`	`puzzle_move Move{};`
`307`	`309`	`puzzle_move PrevMove{};`
`308`	`310`	`puzzle_move TwoPrevMove{};`
`@@ -325,16 +327,16 @@ static std::string Seven_By_Seven()`
`325`	`327`	`createMove(Move, '7');`
`326`	`328`	`} while (!canUseMove(&TwoPrevMove, &PrevMove, &Move));`
`327`	`329`
`328`		`- scramble += getRepresentation(&Move) + " ";`
	`330`	`+ scramble << Move << " ";`
`329`	`331`	`TwoPrevMove = PrevMove;`
`330`	`332`	`PrevMove = Move; //`
`331`	`333`	`}`
`332`		`- return scramble;`
	`334`	`+ return scramble.str();`
`333`	`335`	`}`
`334`	`336`
`335`	`337`	`static std::string Skewb()`
`336`	`338`	`{`
`337`		`- std::string scramble;`
	`339`	`+ std::ostringstream scramble;`
`338`	`340`	`puzzle_move Move{};`
`339`	`341`	`puzzle_move PrevMove{};`
`340`	`342`	`const int moveCount = getRandomNum(9, 13);`
`@@ -349,60 +351,60 @@ static std::string Skewb()`
`349`	`351`	`createMove(Move, 'S');`
`350`	`352`	`} while (!canUseMove(&PrevMove, &Move));`
`351`	`353`
`352`		`- scramble += getRepresentation(&Move) + ' ';`
	`354`	`+ scramble << Move << ' ';`
`353`	`355`	`PrevMove = Move; // Don't forget this!! :DDDDDDDDDD`
`354`	`356`	`}`
`355`		`- return scramble;`
	`357`	`+ return scramble.str();`
`356`	`358`	`}`
`357`	`359`
`358`	`360`	`static std::string Megaminx()`
`359`	`361`	`{`
`360`	`362`	`bool Dpp;`
`361`		`- std::string scramble;`
	`363`	`+ std::ostringstream scramble;`
`362`	`364`
`363`	`365`	`for (int i = 0; i < 5; i++)`
`364`	`366`	`{`
`365`	`367`	`for (int n = 0; n < 7; n++)`
`366`	`368`	`{`
`367`		`- scramble += "R";`
	`369`	`+ scramble << "R";`
`368`	`370`	`if (getRandomNum(0, 1) == 0)`
`369`	`371`	`{`
`370`		`- scramble += "++ ";`
	`372`	`+ scramble << "++ ";`
`371`	`373`	`}`
`372`	`374`	`else`
`373`	`375`	`{`
`374`		`- scramble += "-- ";`
	`376`	`+ scramble << "-- ";`
`375`	`377`	`}`
`376`	`378`
`377`		`- scramble += "D";`
	`379`	`+ scramble << "D";`
`378`	`380`	`if (getRandomNum(0, 1) == 0)`
`379`	`381`	`{`
`380`		`- scramble += "++ ";`
	`382`	`+ scramble << "++ ";`
`381`	`383`	`Dpp = true;`
`382`	`384`	`}`
`383`	`385`	`else`
`384`	`386`	`{`
`385`		`- scramble += "-- ";`
	`387`	`+ scramble << "-- ";`
`386`	`388`	`Dpp = false;`
`387`	`389`	`}`
`388`	`390`	`}`
`389`	`391`	`if (Dpp)`
`390`	`392`	`{`
`391`		`- scramble += "U \n";`
	`393`	`+ scramble << "U \n";`
`392`	`394`	`}`
`393`	`395`	`else`
`394`	`396`	`{`
`395`		`- scramble += "U' \n";`
	`397`	`+ scramble << "U' \n";`
`396`	`398`	`}`
`397`	`399`	`}`
`398`		`- return scramble;`
	`400`	`+ return scramble.str();`
`399`	`401`	`}`
`400`	`402`
`401`	`403`	`static std::string Pyraminx()`
`402`	`404`	`{`
`403`	`405`	`constexpr char tips[] = {'u', 'l', 'r', 'b'};`
`404`		`- std::string scramble;`
`405`		`- scramble += Skewb();`
	`406`	`+ std::ostringstream scramble;`
	`407`	`+ scramble << Skewb();`
`406`	`408`
`407`	`409`	`for (int i = 0; i < 3; i++)`
`408`	`410`	`{`
`@@ -412,54 +414,55 @@ static std::string Pyraminx()`
`412`	`414`	`}`
`413`	`415`	`else if (direction == 2)`
`414`	`416`	`{`
`415`		`- scramble += tips[i];`
`416`		`- scramble += " ";`
	`417`	`+ scramble << tips[i];`
	`418`	`+ scramble << " ";`
`417`	`419`	`}`
`418`	`420`	`else if (direction == 3)`
`419`	`421`	`{`
`420`		`- scramble += tips[i];`
`421`		`- scramble += "' ";`
	`422`	`+ scramble << tips[i];`
	`423`	`+ scramble << "' ";`
`422`	`424`	`}`
`423`	`425`	`}`
`424`		`- return scramble;`
	`426`	`+ return scramble.str();`
`425`	`427`	`}`
`426`	`428`
`427`	`429`	`static std::string Clock()`
`428`	`430`	`{`
`429`	`431`	`const std::string hours[] = {"5-", "4-", "3-", "2-", "1-", "0+", "1+", "2+", "3+", "4+", "5+", "6+"};`
`430`		`- std::string scramble = "UR" + hours[getRandomNum(0, 11)] + " ";`
`431`		`- scramble += "DR" + hours[getRandomNum(0, 11)] + " ";`
`432`		`- scramble += "DL" + hours[getRandomNum(0, 11)] + " ";`
`433`		`- scramble += "UL" + hours[getRandomNum(0, 11)] + " ";`
`434`		`- scramble += "U" + hours[getRandomNum(0, 11)] + " ";`
`435`		`- scramble += "R" + hours[getRandomNum(0, 11)] + " ";`
`436`		`- scramble += "D" + hours[getRandomNum(0, 11)] + " ";`
`437`		`- scramble += "L" + hours[getRandomNum(0, 11)] + " ";`
`438`		`- scramble += "ALL" + hours[getRandomNum(0, 11)] + " " + "y2" + " ";`
`439`		`- scramble += "U" + hours[getRandomNum(0, 11)] + " ";`
`440`		`- scramble += "R" + hours[getRandomNum(0, 11)] + " ";`
`441`		`- scramble += "D" + hours[getRandomNum(0, 11)] + " ";`
`442`		`- scramble += "L" + hours[getRandomNum(0, 11)] + " ";`
`443`		`- scramble += "ALL" + hours[getRandomNum(0, 11)] + " ";`
	`432`	`+ std::ostringstream scramble;`
	`433`	`+ scramble << "UR" << hours[getRandomNum(0, 11)] << " "`
	`434`	`+ << "DR" << hours[getRandomNum(0, 11)] << " "`
	`435`	`+ << "DL" << hours[getRandomNum(0, 11)] << " "`
	`436`	`+ << "UL" << hours[getRandomNum(0, 11)] << " "`
	`437`	`+ << "U" << hours[getRandomNum(0, 11)] << " "`
	`438`	`+ << "R" << hours[getRandomNum(0, 11)] << " "`
	`439`	`+ << "D" << hours[getRandomNum(0, 11)] << " "`
	`440`	`+ << "L" << hours[getRandomNum(0, 11)] << " "`
	`441`	`+ << "ALL" << hours[getRandomNum(0, 11)] << " " << "y2" << " "`
	`442`	`+ << "U" << hours[getRandomNum(0, 11)] << " "`
	`443`	`+ << "R" << hours[getRandomNum(0, 11)] << " "`
	`444`	`+ << "D" << hours[getRandomNum(0, 11)] << " "`
	`445`	`+ << "L" << hours[getRandomNum(0, 11)] << " "`
	`446`	`+ << "ALL" << hours[getRandomNum(0, 11)] << " ";`
`444`	`447`
`445`	`448`	`if (getRandomNum(0, 1) == 1)`
`446`	`449`	`{`
`447`		`- scramble += "UR ";`
	`450`	`+ scramble << "UR ";`
`448`	`451`	`}`
`449`	`452`	`if (getRandomNum(0, 1) == 1)`
`450`	`453`	`{`
`451`		`- scramble += "DR ";`
	`454`	`+ scramble << "DR ";`
`452`	`455`	`}`
`453`	`456`	`if (getRandomNum(0, 1) == 1)`
`454`	`457`	`{`
`455`		`- scramble += "DL ";`
	`458`	`+ scramble << "DL ";`
`456`	`459`	`}`
`457`	`460`	`if (getRandomNum(0, 1) == 1)`
`458`	`461`	`{`
`459`		`- scramble += "UL ";`
	`462`	`+ scramble << "UL ";`
`460`	`463`	`}`
`461`	`464`
`462`		`- return scramble;`
	`465`	`+ return scramble.str();`
`463`	`466`	`}`
`464`	`467`
`465`	`468`	`// Use this one`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`#include "cmdLineParser.hpp"`
`2`	`2`	`#include "Scrambles.hpp"`
`3`	`3`	`#include "fileIO.hpp"`
`4`		`-#include "outputting.hpp"`
`5`	`4`
`6`	`5`	`int main(int argc, char const *argv[])`
`7`	`6`	`{`
Original file line number	Diff line number	Diff line change
`@@ -180,4 +180,5 @@ void outputVersion()`
`180`	`180`	`std::cout << "Scramble outputs ⅓ of the screen + avg to right" << std::endl;`
`181`	`181`	`std::cout << "Moved the outputting code to another file." << std::endl;`
`182`	`182`	`std::cout << "Fixed a bug if something was of length 0." << std::endl;`
	`183`	`+ std::cout << "Used std::stringstream instead of std::string" << std::endl;`
`183`	`184`	`}`