/* Read please: For some reason sololearn sometimes throws a compilation error at the screen or says "No output". So if you see it, it's not my code. Just re-run the code a few times. Or copy pasta is to http://cpp.sh/ Also don't make line 1 too big, because sololearn is too slow to draw many cubes. --- Edit: I removed the regex so the compilation error should occur less... or not at all :) Instructions: line 1: The string to encrypt / decrypt ( spaces are allowed ) line 2: Rotation instructions. Example 1: Sololearn 0:2U:RF':3L:1D,1:L:R' Example 2: Lorem Ipsum 0:D:L:U:U,1:D:L:U,0:U Rotation Explanation: The rotation starts with an integer, representing the index. 0: means the cube at index 0 Following the cube's index is a ':' Next up are the rotations preceded by a number( optional ) indicating the number of times that rotation is done. 2U means Turn up twice RF' means Right Inverse Flip 3L means Turn left 3 times. 1D means Turn down once. Each rotation is seperated by a ':' When you are finished with the index and want to go to another index, end the rotation by placing a comma ',' in between and repeat. Possible Rotations: R: Right Rotation L: Left Rotation R': Right Inverse Rotation L': Left Inverse Rotation U: Up rotation D: Down rotation U': Up Inverse Rotation D': Down Inverse Rotation RF: Right Flip LF: Left Flip RF': Right Inverse Flip LF': Left Inverse Flip Set DISPLAY_TURNS to 0 to disable the display of cube flips. Set DISPLAY_CUBES to 0 to disable cube display all together. */ #define DISPLAY_CUBES 1 #if DISPLAY_CUBES == 1 #define DISPLAY_TURNS 1 #define MAX_TURN_DISPLAY 5 // Only display this many turns, because sololearn is suuuper slow :( #endif #include #include #include #include #include #include namespace Dennis { namespace Utility { ////// /// \brief Transforms a string to uppercase ////// std::string toupper( const std::string& s ) { std::string r; std::transform( s.begin(), s.end(), std::back_inserter( r ), ::toupper ); return r; } ////// /// \brief Splits a string into tokens at the given seperator ////// std::vector split( const std::string& s, char seperator ) { std::vector tokens; std::istringstream ss{ s }; std::string temp; while( std::getline( ss, temp, seperator ) ) { tokens.push_back( temp ); } return tokens; } } class Cube final { private: /// Number of points in the cube constexpr static unsigned POINTS = 8; /// Char used in the padding of unused space constexpr static char PADDING_CHAR = 0; /// Just different names to make a bit more sense of things using RotationMatrix = std::array; using Code = std::string; /// I like working with enum classes more than strings, /// mostly because they are faster enum class Rotation : char { None, Right, Left, Right_Inverse, Left_Inverse, Right_Flip, Left_Flip, Right_Inverse_Flip, Left_Inverse_Flip, Up, Down, Up_Inverse, Down_Inverse, }; /// Gives CubeArray access to Cube's private parts ( pun intended ) friend class CubeArray; public: /////// /// \brief constructor /////// Cube( const std::string& s ) : mCode( s ) /// Some compilers give an error if trying to initialize the array at the definition instead of the constructor initializer list , mRotation{ 0, 1, 2, 3, 4, 5, 6, 7 } /// Starting rotation { } /////// /// \brief Rotate the cube in the given direction /////// void rotate( const Rotation& direction ) { /// Stores the new rotation, because without it it would just override data. RotationMatrix newRotation; /// I use .at() instead of [] because .at() throws an exception if not found const RotationMatrix& rotation = RotationMatrices.at( direction ); for( unsigned p = 0; p < POINTS; ++p ) { newRotation[rotation[p]] = mRotation[p]; } mRotation = newRotation; } /////// /// \brief Reads the contents of the cube /////// std::string code() const { std::ostringstream oss; for( const RotationMatrix::size_type& r_index : mRotation ) { if( mCode[r_index] != PADDING_CHAR ) oss << mCode[r_index]; } return oss.str(); } /////// /// \brief Allows stuff like std::cout << cube; /// /// I like std::cout << cube; a bit more than cube.print(); or something similar. /////// friend std::ostream& operator<<( std::ostream& os, const Cube& o ) { std::string output; for( const auto& i : o.mRotation ) { output += ( o.mCode[i] == PADDING_CHAR ) ? ' ' : o.mCode[i]; } return os << " " << output[5] << "----" << output[6] << '\n' << " /| /|\n" << output[1] << "-+--" << output[2] << " |\n" << "| " << output[4] << "--+-" << output[7] << '\n' << "|/ |/\n" << output[0] << "----" << output[3]; } private: /////// /// \brief Returns a rotation based on the string /////// static Rotation stringToRotation( const std::string& s ) noexcept { std::string upper = Utility::toupper( s ); if( upper == "R" ) return Rotation::Right; if( upper == "L" ) return Rotation::Left; if( upper == "R'" ) return Rotation::Right_Inverse; if( upper == "L'" ) return Rotation::Left_Inverse; if( upper == "RF" ) return Rotation::Right_Flip; if( upper == "LF" ) return Rotation::Left_Flip; if( upper == "RF'" ) return Rotation::Right_Inverse_Flip; if( upper == "LF'" ) return Rotation::Left_Inverse_Flip; if( upper == "U" ) return Rotation::Up; if( upper == "D" ) return Rotation::Down; if( upper == "U'" ) return Rotation::Up_Inverse; if( upper == "D'" ) return Rotation::Down_Inverse; return Rotation::None; } /////// /// \brief Returns a string based on the rotation /////// static std::string rotationToString( const Rotation& rotation ) noexcept { switch( rotation ) { case Rotation::Right: return "Right"; case Rotation::Left: return "Left"; case Rotation::Right_Inverse: return "Right Inverse"; case Rotation::Left_Inverse: return "Left Inverse"; case Rotation::Right_Flip: return "Right Flip"; case Rotation::Left_Flip: return "Left Flip"; case Rotation::Right_Inverse_Flip: return "Right Inverse Flip"; case Rotation::Left_Inverse_Flip: return "Left Inverse Flip"; case Rotation::Up: return "Up"; case Rotation::Down: return "Down"; case Rotation::Up_Inverse: return "Up Inverse"; case Rotation::Down_Inverse: return "Down Inverse"; } return "None"; } /////// /// \brief Returns the inverse of a rotation /////// static Rotation inverseRotation( const Rotation& rotation ) noexcept { switch( rotation ) { case Rotation::Right: return Rotation::Right_Inverse; case Rotation::Left: return Rotation::Left_Inverse; case Rotation::Right_Inverse: return Rotation::Right; case Rotation::Left_Inverse: return Rotation::Left; case Rotation::Right_Flip: return Rotation::Right_Inverse_Flip; case Rotation::Left_Flip: return Rotation::Left_Inverse_Flip; case Rotation::Right_Inverse_Flip: return Rotation::Right_Flip; case Rotation::Left_Inverse_Flip: return Rotation::Left_Flip; case Rotation::Up: return Rotation::Up_Inverse; case Rotation::Down: return Rotation::Down_Inverse; case Rotation::Up_Inverse: return Rotation::Up; case Rotation::Down_Inverse: return Rotation::Down; } return Rotation::None; } private: /// Stores the indices of each rotation( 3, 2, ... ) means index 0 -> index 3, index 1 -> 2, etc const static std::map RotationMatrices; /// The text stored in the cube const Code mCode; /// The result of all the rotations RotationMatrix mRotation; }; const std::map Cube::RotationMatrices { { Rotation::Right , { 3, 2, 6, 7, 0, 1, 5, 4 } }, // Right rotation { Rotation::Left_Inverse , { 3, 2, 6, 7, 0, 1, 5, 4 } }, // left inverse rotation { Rotation::Left , { 4, 5, 1, 0, 7, 6, 2, 3 } }, // Left rotation { Rotation::Right_Inverse , { 4, 5, 1, 0, 7, 6, 2, 3 } }, // Right inverse rotation { Rotation::Left_Flip , { 3, 0, 1, 2, 7, 4, 5, 6 } }, // Left flip { Rotation::Right_Inverse_Flip, { 3, 0, 1, 2, 7, 4, 5, 6 } }, // Right inverse flip { Rotation::Right_Flip , { 1, 2, 3, 0, 5, 6, 7, 4 } }, // Right flip { Rotation::Left_Inverse_Flip , { 1, 2, 3, 0, 5, 6, 7, 4 } }, // Left inverse flip { Rotation::Up , { 1, 5, 6, 2, 0, 4, 7, 3 } }, // Up rotation { Rotation::Down_Inverse , { 1, 5, 6, 2, 0, 4, 7, 3 } }, // Down inverse rotation { Rotation::Down , { 4, 0, 3, 7, 5, 1, 2, 6 } }, // Down rotation { Rotation::Up_Inverse , { 4, 0, 3, 7, 5, 1, 2, 6 } }, // Up inverse rotation }; class CubeArray final { private: /// Some aliasses to make things make more sense using Container = std::vector; using size_type = Container::size_type; /// Internal data for rotations struct RotationData { std::size_t index = -1; int numberOfRotations = 1; Cube::Rotation rotation = Cube::Rotation::None; }; public: /////// /// \brief constructor /////// CubeArray( const std::string& s ) { makeCubes( s ); } /////// /// \brief Takes in the string of rotations, reads it and execute the rotations /////// void rotate( const std::string& direction ) { std::vector data = parse( direction ); rotate( data ); } /////// /// \brief Takes in the string of rotations, reads it, reverses it and executes the rotations /////// void reverseRotate( const std::string& direction ) { std::vector data = parse( direction ); for( RotationData& i : data ) { i.rotation = Cube::inverseRotation( i.rotation ); } std::reverse( data.begin(), data.end() ); rotate( data ); } /////// /// \brief Reads the contents of all the cubes /////// std::string code() const { std::ostringstream oss; for( const Cube& i : mCubes ) { oss << i.code(); } return oss.str(); } /////// /// \brief Allows accessing individual cubes /////// Cube& operator[]( size_type index ) { return mCubes[ index ]; } /////// /// \brief Allows accessing individual cubes /// const version /////// const Cube& operator[]( size_type index ) const { return mCubes[ index ]; } /////// /// \brief Returns the number of cubes in the array /////// size_type size() const noexcept { return mCubes.size(); } private: /////// /// \brief Splits the input among the cubes /////// void makeCubes( const std::string& s ) { const size_type SIZE = s.size(); for( size_type i = 0; i < SIZE; i += Cube::POINTS ) { std::string token = s.substr( i, Cube::POINTS ); while( token.size() < Cube::POINTS ) token += Cube::PADDING_CHAR; Cube cube( token ); mCubes.push_back( cube ); } } /////// /// \brief The actual rotation /////// void rotate( const std::vector& rotationData ) { for( const RotationData& i : rotationData ) { #if DISPLAY_TURNS == 1 if( mCurrentDisplay < MAX_TURN_DISPLAY ) { std::cout << "Rotating cube at index: " << i.index << " " << Cube::rotationToString( i.rotation ) << " " << i.numberOfRotations << " times.\n"; } #endif for( int j = 0; j < i.numberOfRotations; ++j ) { mCubes[ i.index ].rotate( i.rotation ); } #if DISPLAY_TURNS == 1 if( mCurrentDisplay < MAX_TURN_DISPLAY ) { std::cout << mCubes[ i.index ] << '\n'; } else { std::cout << "...\n"; } ++mCurrentDisplay; #endif } } /////// /// \brief Parses the input and spits out a vector of RotationData /////// std::vector parse( const std::string& s ) { std::vector r; /// Holds the rotations for each index std::vector tokens = Utility::split( s, ',' ); for( const auto& token : tokens ) { /// Holds the rotation at the index std::vector rotations = Utility::split( token, ':' ); RotationData data; /// If the first character is a non integer then how should I know which index the rotations are for? /// Also handles negatives if( rotations[0].empty() || !isdigit( rotations[0][0] ) ) throw std::invalid_argument( "\nInvalid index given: " + rotations[0] ); /// Index is at index 0 of the rotations, otherwise an exception would have been thrown already data.index = std::stoi( rotations[0] ); /// Entered index is out of bounds, negatives are already handled at this point if( data.index >= size() ) throw std::invalid_argument( "\nInvalid index given: " + std::to_string( data.index ) + " while the size is: " + std::to_string( size() ) ); /// An index has been entered but no rotation is given if( rotations.size() == 1 ) throw std::invalid_argument( "\nNo rotation following the index: " + std::to_string( data.index ) ); for( int i = 1; i < rotations.size(); ++i ) { const std::string& sr = rotations[i]; /// Used to read the numbers, numberEnd is at 1 past the last digit. int numberEnd = 0; for( ; numberEnd < sr.size() && isdigit( sr[numberEnd] ); ++numberEnd ); /// Means the string only had digits, therefore there are no rotations if( numberEnd == sr.size() ) throw std::invalid_argument( "\nInvalid rotation, the given rotation only exists of numbers: " + sr ); data.numberOfRotations = ( numberEnd ) ? std::stoi( sr.substr( 0, numberEnd ) ) : 1; /// 0 would mean no rotation and no rotation = no encryption. /// Same if the number is divisible by 4, but I'm not gonna give an error for that. if( data.numberOfRotations == 0 ) throw std::invalid_argument( "\nInvalid number of rotations given: 0 at index: " + std::to_string( data.index ) ); data.rotation = Cube::stringToRotation( sr.substr( numberEnd ) ); /// An invalid rotation has been entered if( data.rotation == Cube::Rotation::None ) throw std::invalid_argument( "\nInvalid rotation given: " + sr.substr( numberEnd ) ); r.push_back( data ); } } return r; } private: /// The container with cubes Container mCubes; #if DISPLAY_TURNS == 1 /// Keeps track of how many the cube rotation display int mCurrentDisplay = 0; #endif }; } int main() { // === Input === std::string s; std::getline( std::cin, s ); std::string rotation; std::getline( std::cin, rotation ); if( rotation.empty() ) { throw std::invalid_argument( "\nDid you forget to enter the rotation(s)?\nPlease read the instructions." ); } // === /Input === Dennis::CubeArray arr( s ); std::cout << "Entered rotation: " << rotation << "\n\n"; // === Output === #if DISPLAY_CUBES == 1 std::cout << "Initial state:\n\n"; for( int i = 0; i < arr.size(); ++i ) std::cout << "Cube " << i << '\n' << arr[i] << '\n'; std::cout << "\n\n\nEncrypting:\n\n"; #endif // === /Output === arr.rotate( rotation ); // === Output === std::cout << "\nEncrypted: " << arr.code() << "\n"; #if DISPLAY_CUBES == 1 std::cout << "\n\n\n"; for( int i = 0; i < arr.size(); ++i ) std::cout << "Cube " << i << '\n' << arr[i] << '\n'; std::cout << "\n\n\nDecrypting:\n\n"; #endif // === /Output === arr.reverseRotate( rotation ); // === Output === std::cout << "\nDecrypted: " << arr.code() << '\n'; // === /Output === return 0; } #define PC_INPUT_NOT_WORKING_WORKAROUND(s) std::cin >> s;

Crypto Cube Contest