7.7 — Intro to loops and while statements

By Alex on June 22nd, 2007 | last modified by Alex on April 30th, 2021

Introduction to loops

And now the real fun begins -- in the next set of lessons, we’ll cover loops. Loops are control flow constructs that allow a piece of code to execute repeatedly until some condition is met. Loops add a significant amount of flexibility into your programming toolkit, allowing you to do many things that would otherwise be difficult.

For example, let’s say you wanted to print all the numbers between 1 and 10. Without loops, you might try something like this:

1 2 3 4 5 6 7 8

#include <iostream>   int main() {     std::cout << "1 2 3 4 5 6 7 8 9 10";     std::cout << " done!";     return 0; }

While that’s doable, it becomes increasingly less so as you want to print more numbers: what if you wanted to print all the numbers between 1 and 1000? That would be quite a bit of typing! But such a program is writable in this way because we know at compile time how many numbers we want to print.

Now, let’s change the parameters a bit. What if we wanted to ask the user to enter a number and then print all the numbers between 1 and the number the user entered? The number the user will enter isn’t knowable at compile-time. So how might we go about solving this?

While statements

The while statement (also called a while loop) is the simplest of the three loop types that C++ provides, and it has a definition very similar to that of an if statement:

while (condition)
    statement;

A while statement is declared using the while keyword. When a while statement is executed, the condition is evaluated. If the condition evaluates to true, the associated statement executes.

However, unlike an if statement, once the statement has finished executing, control returns to the top of the while statement and the process is repeated. This means a while statement will keep looping for as long as the condition evaluates to true.

Let’s take a look at a simple while loop that prints all the numbers from 1 to 10:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream>   int main() {     int count{ 1 };     while (count <= 10)     {         std::cout << count << ' ';         ++count;     }       std::cout << "done!";       return 0; }

This outputs:

1 2 3 4 5 6 7 8 9 10 done!

Let’s take a closer look at what this program is doing. First, count is initialized to 1, which is the first number we’ll print. The condition count <= 10 is true, so the statement executes. In this case, our statement is a block, so all the statements in the block will execute. The first statement in the block prints 1 and a space, and the second increments count to 2. Control now returns back to the top of the while statement, and the condition is evaluated again. 2 <= 10 evaluates to true, so the code block is executed again. The loop will repeatedly execute until count is 11, at which point 11 <= 10 will evaluate to false, and the statement associated with the loop will be skipped. At this point, the loop is done.

While this program is a bit more code than typing all the numbers between 1 and 10, consider how easy it would be to modify the program to print all the numbers between 1 and 1000: all you'd need to do is change count <= 10 to count <= 1000.

While statements that evaluate to false initially

Note that if the condition initially evaluates to false, the associated statement will not execute at all. Consider the following program:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream>   int main() {     int count{ 15 };     while (count <= 10)     {         std::cout << count << ' ';         ++count;     }       std::cout << "done!";       return 0; }

The condition 15 <= 10 evaluates to false, so the associated statement is skipped. The program continues, and the only thing printed is done!.

Infinite loops

On the other hand, if the expression always evaluates to true, the while loop will execute forever. This is called an infinite loop. Here is an example of an infinite loop:

1 2 3 4 5 6 7 8 9 10 11 12

#include <iostream>   int main() {     int count{ 1 };     while (count <= 10) // this condition will never be false     {         std::cout << count << ' '; // so this line will repeatedly execute     }       return 0; // this line will never execute }

Because count is never incremented in this program, count <= 10 will always be true. Consequently, the loop will never terminate, and the program will print "1 1 1 1 1"... forever.

Intentional infinite loops

We can declare an intentional infinite loop like this:

1 2 3 4

while (true) {   // this loop will execute forever }

The only way to exit an infinite loop is through a return statement, a break statement, an exit statement, a goto statement, an exception being thrown, or the user killing the program.

Here's a silly example demonstrating this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <iostream>   int main() {       while (true) // infinite loop     {         std::cout << "Loop again (y/n)? ";         char c{};         std::cin >> c;           if (c == 'n')             return 0;     }       return 0; }

This program will continuously loop until the user enters n as input, at which point the if statement will evaluate to true and the associated return 0; will cause function main() to exit, terminating the program.

It is common to see this kind of loop in web server applications that run continuously and service web requests.

Best practice

Favor while(true) for intentional infinite loops.

Loop variables

Often, we want a loop to execute a certain number of times. To do this, it is common to use a loop variable, often called a counter. A loop variable is an integer that is used to count how many times a loop has executed. In the examples above, the variable count is a loop variable.

Loop variables are often given simple names, such as i, j, or k. However, if you want to know where in your program a loop variable is used, and you use the search function on i, j, or k, the search function will return half your program! For this reason, some developers prefer loop variable names like iii, jjj, or kkk. Because these names are more unique, this makes searching for loop variables much easier, and helps them stand out as loop variables. An even better idea is to use "real" variable names, such as count, or a name that gives more detail about what you're counting (e.g. userCount).

Loop variables should be signed

Loop variables should almost always be signed, as unsigned integers can lead to unexpected issues. Consider the following code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <iostream>   int main() {     unsigned int count{ 10 };       // count from 10 down to 0     while (count >= 0)     {         if (count == 0)         {             std::cout << "blastoff!";         }         else         {             std::cout << count << ' ';         }         --count;     }       return 0; }

Take a look at the above example and see if you can spot the error. It's not very obvious.

It turns out, this program is an infinite loop. It starts out by printing 10 9 8 7 6 5 4 3 2 1 blastoff! as desired, but then goes off the rails, and starts counting down from 4294967295. Why? Because the loop condition count >= 0 will never be false! When count is 0, 0 >= 0 is true. Then --count is executed, and count wraps around back to 4294967295 (Assuming 32-bit integers). And since 4294967295 >= 0 is true, the program continues. Because count is unsigned, it can never be negative, and because it can never be negative, the loop won't terminate.

Best practice

Loop variables should be of type (signed) int.

Doing something every N iterations

Each time a loop executes, it is called an iteration.

Often, we want to do something every 2nd, 3rd, or 4th iteration, such as print a newline. This can easily be done by using the modulus operator on our counter:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include <iostream>   // Iterate through every number between 1 and 50 int main() {     int count{ 1 };     while (count <= 50)     {         // print the number (pad numbers under 10 with a leading 0 for formatting purposes)         if (count < 10)         {             std::cout << '0';         }           std::cout << count << ' ';           // if the loop variable is divisible by 10, print a newline         if (count % 10 == 0)         {             std::cout << '\n';         }                      // increment the loop counter         ++count;     }       return 0; }

This program produces the result:

01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50

Nested loops

It is also possible to nest loops inside of other loops. In the following example, the inner loop and outer loop each have their own counters. However, note that the loop expression for the inner loop makes use of the outer loop's counter as well!

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <iostream>   // Loop between 1 and 5 int main() {     int outer{ 1 };     while (outer <= 5)     {         // loop between 1 and outer         int inner{ 1 };         while (inner <= outer)         {             std::cout << inner << ' ';             ++inner;         }           // print a newline at the end of each row         std::cout << '\n';         ++outer;     }       return 0; }

This program prints:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Quiz time

Question #1

In the above program, why is variable inner declared inside the while block instead of immediately following the declaration of outer?

Show Solution

Variable inner is declared inside the while block so that it is recreated (and reinitialized to 1) each time the outer loop executes. If variable inner were declared before the outer while loop, its value would never be reset to 1, or we'd have to do it with an assignment statement. Furthermore, because variable inner is only used inside the outer while loop block, it makes sense to declare it there. Remember, declare your variables in the smallest scope possible!

Question #2

Write a program that prints out the letters a through z along with their ASCII codes.

Show Hint

To print characters as integers, you have to use a static_cast.

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <iostream>   int main() {     char myChar{ 'a' };     while (myChar <= 'z')     {         std::cout << myChar << ' ' << static_cast<int>(myChar) << '\n';         ++myChar;     }       return 0; }

Question #3

Invert the nested loops example so it prints the following:

5 4 3 2 1
4 3 2 1
3 2 1
2 1
1

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <iostream>   // Loop between 5 and 1 int main() { int outer{ 5 }; while (outer >= 1) { // loop between inner and 1 int inner{ outer }; while (inner >= 1)         { std::cout << inner-- << ' ';         }   // print a newline at the end of each row std::cout << '\n'; --outer; }   return 0; }

Question #4

Now make the numbers print like this:

        1
      2 1
    3 2 1
  4 3 2 1
5 4 3 2 1

Hint: Figure out how to make it print like this first:

X X X X 1
X X X 2 1
X X 3 2 1
X 4 3 2 1
5 4 3 2 1

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// Thanks to Shiva for this solution #include <iostream>   int main() { // There are 5 rows, we can loop from 1 to 5 int outer{ 1 };   while (outer <= 5) { // Row elements appear in descending order, so start from 5 and loop through to 1 int inner{ 5 };   while (inner >= 1) { // The first number in any row is the same as the row number // So number should be printed only if it is <= the row number, space otherwise if (inner <= outer) std::cout << inner << ' '; else std::cout << "  "; // extra spaces purely for formatting purpose   --inner; }   // A row has been printed, move to the next row std::cout << '\n';   ++outer; }   return 0; }

7.8 -- Do while statements

Index

7.6 -- Goto statements

C++ Tutorial |  Print This Post

412 comments to 7.7 — Intro to loops and while statements

• toasted melon

  June 4, 2021 at 1:25 pm · Reply

  i think this might be a more simplified answer for question 4 based off what we learned so far if im wrong please tell me, why.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  int main() {     // determines the number of lines produced by the function     int outer{ 1 };     while (outer <= 5)     {         //determines how many spaces are placed before output, values must be less then outer for formating         int count{ 4 };           while (count >= outer)         {             std::cout << "  ";//doublespaced for formating, other wise it's a pyramid             --count;         }           //prints the numaric values based off of outer value         int inner{ 1 };         while (inner <= outer)         {             std::cout << inner << " ";             ++inner;         }         //ends the line then increases outer values so more numbers are printed in a line         std::cout << '\n';         ++outer;              }     return 0; }

  • André Mark

    June 5, 2021 at 8:31 am · Reply

    Yeah, this worked, this was very helpful for me to follow especially as I am new to JS, and C++ and learning as I go along by following more experienced jedi coders

• toasted melon

  June 4, 2021 at 1:13 pm · Reply

  i think this might be a more condensed answer for question 4 based off what we learned so far. if I'm wrong please tell me.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  int q3() {     // determines the number of lines produced by the function     int outer{ 1 };     while (outer <= 5)     {         //determines how many spaces are placed before output, values must be less then outer for formating         int count{ 4 };           while (count >= outer)         {             std::cout << "  ";//doublespaced for formating, other wise it's a pyramid             --count;         }           //prints the numaric values based off of outer value         int inner{ 1 };         while (inner <= outer)         {             std::cout << inner << " ";             ++inner;         }         //ends the line then increases outer values so more numbers are printed in a line         std::cout << '\n';         ++outer;              }     return 0; }

• tip

  June 4, 2021 at 4:28 am · Reply

  In the intentional infinite loops, why should I favor

  1	while(true)

  as a best practice instead of putting directly the break condition in the while parenthesis?

  • bb

    June 4, 2021 at 12:05 pm · Reply

    Because that makes your intention clear. Otherwise people who read your code will wonder if you intended an infinite loop or you messed up.

• Armando IG

  June 3, 2021 at 2:24 pm · Reply

  Hello, my solution for question #4 was different from the one showed up, it still worked but I would like some feedback on my code to see if it is less optimal than the target solution.
  Thanks in advance.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  #include <iostream>   int main() {     constexpr int iterations {5};       int outer{1};     while (outer <= iterations)     {         int inner {1};         int spaces {iterations - outer};         while (inner <= outer)         {             while (spaces >= 1)             {                 std::cout << "  ";                 --spaces;             }             std::cout << inner++ << ' ';         }         std::cout << '\n';         ++outer;     }       return 0; }

• frog

  May 17, 2021 at 2:36 am · Reply

  Hello, thanks for the tutorials. The number triangles were great exercises.

  This might not really matter, but wouldn't the example this lesson is using produce an extra whitespace (' ') at the right-end of each row just before new line ('\n')?

  If it matters, I suggest printing the inner variable first for each row and then start the loop which prints whitespace first and then the inner variable. Something like this:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  // Loop between 1 and 5 int main() {     int outer{ 1 };     while (outer <= 5)     {                  int inner{ 1 };         std::cout << inner++; // print 1 first           // loop between 2 and outer         while (inner <= outer)         {             std::cout << ' ' << inner++;         }           // print a newline at the end of each row         std::cout << '\n';         ++outer;     }       return 0; }

• Rwondo bislungo

  May 15, 2021 at 10:09 am · Reply

  My solution for the excercise:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  #include <iostream>   // Loop between 1 and 5 int main() {     int outer{ 5 };     while (outer >= 1)     {         // loop between 1 and outer         int inner{ 5 };         while (inner >= outer)         {             std::cout << inner << ' ';             --inner;         }           // print a newline at the end of each row         std::cout << '\n';         --outer;     }       return 0; }

• UnknownLearner

  May 8, 2021 at 5:09 am · Reply

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

  /*     In my approach I used next method:     I imagined output how a rect that divided to a two triangles.     The main idea I that I make one triangle with numbers and second one filled with 'missing' space-elements */   #include <iostream>   int main() {     int columnCounter{ 5 };       int outerCounter{ 1 };     while (outerCounter <= columnCounter)     {         int innerCounter{ outerCounter };                    //  For declare mark whitespace I evaluate should it be or not.         //  Also, we should know general count of numbers minus count of integers in line.           int whiteSpace{ columnCounter - innerCounter };           while (whiteSpace > 0)         {             std::cout << "  ";             --whiteSpace;         }           //  When whitespaces is no need anymore in the line we printing an integer.         while (innerCounter >= 1)         {               std::cout << innerCounter-- << " ";         }         std::cout << '\n';         ++outerCounter;     }       return 0; }

• James C

  April 30, 2021 at 8:31 am · Reply

  Single space in second example is using double quotes, may want to use single quotes.

• Mynah

  April 29, 2021 at 12:29 am · Reply

  Nested loops are hard :(

  • Alex

    April 29, 2021 at 4:03 pm · Reply

    Yeah, they definitely take some getting used to. Using a debugger and watching the loop execute can be helpful to understand what it's doing.

• Evelyn Ann Grace

  April 27, 2021 at 4:38 pm · Reply

  my solution to question 2,3,4 are as follow

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  // problem 2     for (short i = 'a' - 1; i <= 'z'; i++) {         std::cout << i << " ASCII: " << static_cast<char>(i) << "\n";     }       //problem 2     for (short i = 5; i >= 1; i--) {         for (short j = i; j >= 1; j--) {             std::cout << j << " ";         }         std::cout << "\n";     }       //problem 3     for (short i = 1; i <= 5; i++) {         for (short j = 5; j >= 1; j--) {             if (j > i) {                 std::cout << "X ";                 continue;             }             std::cout << j << " ";         }         std::cout << "\n";     }

• sjon85

  April 25, 2021 at 1:29 pm · Reply

  Lots of fun! This is my solution:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  #include <iostream>   int main() {     int lines{ 1 };     while (lines <= 5)     {         int spaces{ lines};         while ((5 - spaces) >= 1)         {             std::cout << "  ";             ++spaces;         }         int numbers{ lines };         while (numbers >= 1)         {             std::cout << numbers << ' ';             --numbers;         }         std::cout << '\n';         ++lines;     }     return 0; }

• Ahmed

  April 19, 2021 at 6:29 pm · Reply

  bro you should've given us more examples about nested loops before the quiz, I currently feel so stupid because I couldn't solve the quiz within 20 mins and it's making me feel really disappointed and mad at myself.

• johnnyp

  April 13, 2021 at 12:48 am · Reply

  Using the ternary if statement for question 4

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  #include <iostream>   int main() {     int N {5};          int row {1};     while (row <= N) {         int col {N};         while (col > 0) {             auto c = (col > row) ? ' ' : '0' + col;             std::cout << static_cast<char>(c) << ' ';             --col;         }         std::cout << '\n';         ++row;     }     return 0; }

• Ladyoftheroundtable

  April 11, 2021 at 10:34 am · Reply

  Quick comment, but the hint on question 4 started visible to me. I figured it out before noticing, but only just. I think it would be better to leave it as a hidden hint for those that want to puzzle through a new way of formatting.

  • Alex

    April 12, 2021 at 9:57 am · Reply

    Updated to hide the hint behind a click. Thanks!

• Deva_B.D.M.

  April 10, 2021 at 10:49 pm · Reply

  1	std::cout << "  ";

  or

  1	std::cout << ' ' << ' ';

  which one has better performance???

  • Alex

    April 12, 2021 at 9:49 am · Reply

    Likely the former, as it uses one less << operator.

    • Deva_B.D.M.

      April 12, 2021 at 8:48 pm · Reply

      thanks!!!!

• Rayyan Khan

  April 6, 2021 at 6:48 pm · Reply

  I found an elegant solution for question 3!

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  void printInvertedNested() {     int outer{ 5 };     while (outer >= 1)     {         int inner{outer};         while (inner >= 1)         {                          std::cout << inner << ' ';             --inner;         }           std::cout << '\n';         --outer;     } }

• dodo

  April 6, 2021 at 12:40 pm · Reply

  Damn, i couldn't do it on my own, and spent nearly 15 minutes for understanding what the last quiz does. Impressive as it is, I'm feeling down for not being able to do it. The last time i stopped programming was also due to my inability to understand loops.

  • akithetsar

    April 7, 2021 at 6:06 am · Reply

    Don't worry, loops are not easy to understand, I remember learning loops for the first time and it was not easy, I did understand how one loop works, but nested was a problem, I suggest you re-read this chapter one more time, then go to every code snippet where there is nested loops and try to go one statement and say out loud what it is doing(even for variable initialization, so you can understand why you initialize it before or inside the loop), do it 10 times, and if it still doesn't click, dw that doesn't mean you will never be good at programming, just continue until you get to for loops, then do the same thing above, if you still don't understand try this vid: https://www.youtube.com/watch?v=1LCBssxhduU it is an illustration of a nested loop i believe(didn't really watch it so i might be wrong). Hope this helps

  • Alex

    April 7, 2021 at 1:37 pm · Reply

    The debugger can be a useful educational tool here. If you set up watches on the loop variable(s) and then step through and watch the loop execute line by line, it will help give you some insight into what's going on.

  • Spectrillius

    April 7, 2021 at 11:49 pm · Reply

    Well, the way I see it, that's why there's a show solution button right?
    If you don't understand something with the information given, then there's no shame in hitting the show solution button, provided you understand it afterwards.
    Otherwise, I would review the lesson or previous lessons if they're relevant.

• John

  March 23, 2021 at 10:51 am · Reply

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  #include <iostream> int main() {     int outer{1};     while(outer <= 5)     {         int inner{5};         while(inner >= 1)         {             if((inner - outer) <= 0)             {                 std::cout << inner;             }             else             {                 std::cout << ' ';             }             std::cout << ' ';             --inner;         }         std::cout << '\n';         ++outer;     }     return 0; }

• Roxana

  March 20, 2021 at 6:38 am · Reply

  Hi, can I get some help. If I want to multiply the digits in a number input by the user and have as a result only one digit how to do it to get it right. I am thinking the below but something is not quiet there:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include <iostream> using namespace std;   int main() {     int n, produs = 1;     cin >> n;     while(n > 0){         produs = produs * (n % 10);         n /= 10;         if(produs > 10){             n = produs;             produs = 1;         }     } cout << produs;     return 0; }

• pickino

  February 28, 2021 at 6:52 pm · Reply

  hello! what if i put a assignment inside the condition of the while loop, since an assignment is not some expression that we can say is false or true, how the loop gonna handle this for exemple? :

  int a=5;
  int b;
  while (a=b)
  {
  /*do something ..*/

  }

  (by the way , i'm not intending to put an equality operator == )

• Firas Saleh

  February 7, 2021 at 4:22 am · Reply

  Here's my take on it.

  Suboptimal, but i think it's good to share the different versions. I still have a long way to go :))

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

  #include <iostream> int main() {     int spaces{ 5 };     int space_input{ 1 };     //Tjek # spaces     while (spaces >= space_input)     {         std::cout << "  ";         ++space_input;         static int num{ 1 };         static int line{ 2 };             // Print 1-5             while (spaces == space_input)             {                                                   if (num >= 1)                 {                     std::cout << num;                                          int difference{ 1 };                     int line_check{ line };                     while (line_check >= 3)                     {                         std::cout << ' ' << num - difference;                         --line_check;                         ++difference;                     }                                            std::cout << '\n';                 }                                space_input = line;                 ++line;                 ++num;                              }        }     return 0; }

• nuth vireak

  February 4, 2021 at 8:16 am · Reply

  Question #4
  Hello NASCARDRIVER or ALEX. Please check my code

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  #include <iostream>   int main() {       int outer{ 1 };     while (outer <= 5) {           int inner{ 5 };         while (inner >= 1) {               if (inner > outer)                 std::cout << 'X' << ' ';             else                 std::cout << inner << ' ';           --inner;           }       std::cout << '\n';       ++outer;       }       return 0; }

• nav

  February 2, 2021 at 11:05 am · Reply

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  #include <iostream> int main() {     char i{ 'a' };           while (i <= 'e')           {               char j{ 'e' };                 while (j >= 'a')               {                   if (j > i)                       std::cout << " ";                   else                       std::cout << j;                   j--;               }                 i++;               std::cout << '\n';             }   }

• brainy

  January 30, 2021 at 8:40 am · Reply

  Yikes I really overcomplicated that 2nd question.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include <iostream>   int main() {       char c{0};      int iii{0};       while (c < 64) {           ++c;     }         while ( c < 90 && iii < 26) {             ++iii;             ++c;     std::cout << c << " has the ASCII value of: " << static_cast<int>(c) << '\n';           }       }

• Spero

  January 29, 2021 at 4:31 am · Reply

  What a great quiz! It was tough and fun at the same time. My answer for Q4 was so different that I went back and looked at everyone else's answers just to see all the different things people came up with. Alex's is for sure the best but it's just so interesting to see all the different ways people think. Thanks for all that you do!

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  int main() {     int outer{1};     while (outer <= 5)     {         int inner{ outer };         int inner2{ outer };         while (inner >=1)         {             while (inner2 <= 4)             {                 std::cout << "  ";                 ++inner2;             }             if (inner == outer)                 std::cout << inner;             else             std::cout << ' ' << inner;               --inner;         }         ++outer;         std::cout << '\n';     }     return 0; }

• SuperNoob

  January 28, 2021 at 5:52 am · Reply

  Hello NASCARDRIVER or ALEX! Could you recommend me a good website (like learncpp!) to learn data structure and algorithm?