// print-pattern2-challenge // Last updated: May 2018 /* Documentation Prints patterns from SoloLearn challenge. Pattern 1: 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 and so on... Pattern 2: 1 3 2 6 5 4 10 9 8 7 15 14 13 12 11 and so on... Print Pattern 3: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D and so on... Print Pattern 4: ### #### ##### ###### ##### #### ### Print Pattern 5: ###### ##### #### ### #### ##### ###### Pattern 1 Reversed: ... 121 144 169 196 225 49 64 81 100 16 25 36 4 9 1 Print Pattern 2 Reversed: ... 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 Print Pattern 3 Reversed: ... U V W X Y Z A B C D M N O P Q R S T G H I J K L C D E F A B */ #include void printPattern1(const int in_number_of_lines); // Prints first square number on first line, then the next 2 square numbers on // the next line, and so on up to in_line_numbers void printPattern2(const int in_number_of_lines); // Prints 1 on the first line, then the next 2 numbers in reverse order on the // next, and so on up to in_line_numbers void printPattern3(const int in_number_of_lines); // Prints "A B" on the first line, then the next 4 letters, then the next 6, // and so on up to in_line_numbers (resetting to 'A' and 'B' when necessary) void printPattern4(); // Prints 3 '#' characters on the first line, incrementing on each line until // reaching 6, then decrements back down to 3 void printPattern5(); // Prints 6 '#' characters on the first line, decrementing on each line until // reaching 3, then increments back up to 6 void printPattern1Reversed(const int in_number_of_lines); // Prints pattern 1 starting with what would be the last line, ending with the // 1st void printPattern2Reversed(const int in_number_of_lines); // Prints pattern 2 starting with what would be the last line, ending with the // 1st void printPattern3Reversed(const int in_number_of_lines); // Prints pattern 3 starting with what would be the last line, ending with the // 1st void printUsage(); // Prints program help and usage int main() { // Variables int number_of_lines; // Input printUsage(); std::cout << "Please enter the number of lines to print per pattern: "; std::cin >> number_of_lines; std::cout << '\n'; // Output (print patterns) printPattern1(number_of_lines); printPattern1Reversed(number_of_lines); printPattern2(number_of_lines); printPattern2Reversed(number_of_lines); printPattern3(number_of_lines); printPattern3Reversed(number_of_lines); printPattern4(); printPattern5(); // End of Program return 0; } void printPattern1(const int in_number_of_lines) { int square_root = 1; // to start with first square number // Nested for loops for adjusting and printing (square_root) for (int numbers_per_line = 1; numbers_per_line <= in_number_of_lines; numbers_per_line++) { for (int i = 0; i < numbers_per_line; i++) { std::cout << (square_root * square_root) << ' '; // prints the (square_root)th square number (numbers_per_line) times square_root++; } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printPattern2(const int in_number_of_lines) { int counter = 1; // starts with 1, the first triangular number // Nested for loops for adjusting and printing (counter) for (int numbers_per_line = 1; numbers_per_line <= in_number_of_lines; numbers_per_line++) { for (int i = 0; i < numbers_per_line; i++) { std::cout << counter << ' '; counter--; // starts printing with a triangular number*, decrementing by one // until reaching previous triangular number or 0. (*can be arranged // into an equilateral triangle). triangle numbers presumably come // from adding one more number per row, leading to a number that can // be arranged in a triangular structure. starting with the // triangular number insteading leading to it comes from printing in // reverse order at the start of each row. prints (numbers_per_line) // times } std::cout << '\n'; // new line/row counter = ((counter + numbers_per_line) + (numbers_per_line + 1)); // sets counter to next triangle number. (counter + numbers_per_line) // brings counter back to its value before the for (int i...) loop's // decrements. (numbers_per_line + 1) is the number of lines on the next // iteration adding this brings it to the next triangular number } std::cout << '\n'; } void printPattern3(const int in_number_of_lines) { int letter_position = 0; // starting with 'A' char alphabet[26] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' }; // Nested for loops for selecting and printing chars for (int letters_per_line = 2; letters_per_line <= (in_number_of_lines * 2); letters_per_line += 2) // (in_number_of_lines * 2)) because there are (2 * number_of_lines) // letters per line { for (int i = 0; i < letters_per_line; i++) { std::cout << alphabet[letter_position] << ' '; // prints letters sequentially, (letters_per_line) times letter_position++; if (letter_position > 25) { letter_position = letter_position % 26; // keeps (letter_place) in bounds of char array } } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printPattern1Reversed(const int in_number_of_lines) { int square_root; // Nested for loops for adjusting and printing squared numbers for (int numbers_per_line = in_number_of_lines; numbers_per_line > 0; numbers_per_line--) // (numbers_per_line = in_number_of_lines) starts at last line of pattern 1 { square_root = (numbers_per_line * (numbers_per_line + 1)) / 2; // sets to (numbers_per_line)th triangular number* (the LAST number we // need to square and print for this row). *((n * (n + 1)) / 2) = nth // triangular number (numbers_per_line) is the same as the line number // (i.e. row 1 has 1 number, row 2 has 2 numbers, etc.) square_root -= (numbers_per_line - 1); // sets (square_root) back so it can print the next (numbers_per_line) // numbers squared (back up to the (numbers_per_line)th triangular number // squared, which is the LAST number printed in the row) for (int i = 0; i < numbers_per_line; i++) { std::cout << (square_root * square_root) << ' '; // prints (square_root)th square number (numbers_per_line) times square_root++; } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printPattern2Reversed(const int in_number_of_lines) { int counter = (in_number_of_lines * (in_number_of_lines + 1)) / 2; // sets equal to (in_number_of_lines)th triangular number // Nested for loops for adjusting and printing counter for (int numbers_per_line = in_number_of_lines; numbers_per_line > 0; numbers_per_line--) // (numbers_per_line = in_number_of_lines) starts at last line of pattern 2 { for (int i = 0; i < numbers_per_line; i++) { std::cout << counter << ' '; // prints a decrementing counter with increasingly less numbers per // line, starting with the above assignment counter--; // keeping track of (numbers_per_line) and decrementing naturally // start the next row on the next lowest trianglular number } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printPattern3Reversed(const int in_number_of_lines) { int letter_position; char alphabet[26] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' }; for (int letters_per_line = (in_number_of_lines * 2); letters_per_line > 0; letters_per_line -= 2) // (in_number_of_lines * 2) because there are (2 * number_of_lines) letters // per line { letter_position = ((letters_per_line / 2) * ((letters_per_line / 2) + 1)) - letters_per_line; // (letters_per_line / 2) * ((letters_per_line / 2) + 1) = // (letters_per_line / 2)th triangular number. // (above) - (letters_per_line) moves (letter_position) to the first // letter (of that iteration), so it can print to the last // (letter_per_line) letters away if (letter_position > 25) { letter_position = letter_position % 26; // keeps (letter_position) in bounds } for (int i = 0; i < letters_per_line; i++) { std::cout << alphabet[letter_position] << ' '; // prints letters sequentially, letters_per_line times letter_position++; if (letter_position > 25) { letter_position = letter_position % 26; // keeps (letter_position) in bounds of char array } } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printPattern4() { // Print first 3 lines (starting with 3 '#', ending with 5) for (int characters_per_line = 3; characters_per_line < 6; characters_per_line++) { for (int i = 0; i < characters_per_line; i++) { std::cout << '#'; // prints (characters_per_line) times } std::cout << '\n'; // new line/row } // Print the last 4 lines (starting with 6 '#', ending with 3 for (int characters_per_line = 6; characters_per_line >= 3; characters_per_line--) { for (int i = 0; i < characters_per_line; i++) { std::cout << '#'; } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printPattern5() { // Print the first 3 lines (starting with 6 '#', ending with 4) for (int characters_per_line = 6; characters_per_line > 3; characters_per_line--) { for (int i = 0; i < characters_per_line; i++) { std::cout << '#'; } std::cout << '\n'; // new line/row } // Print the last 4 lines (starting with 3 '#', ending with 6) for (int characters_per_line = 3; characters_per_line <= 6; characters_per_line++) { for (int i = 0; i < characters_per_line; i++) { std::cout << '#'; } std::cout << '\n'; // new line/row } std::cout << '\n'; } void printUsage() { std::cout << "This program prints patterns from a SoloLearn challenge to\n" << "the console. It takes the number of lines for input (for\n" << "challenges 1 - 3 and their reverse).\n\n"; }