Python if else, for loop, and range() Exercises with Solutions

• Decide on the row count, which is 5, because the pattern contains five rows.
• Run the outer loop 5 times using a for loop and the range() function.
• Run the inner loop i+1 times using a for loop and the range() function.
• In the first iteration of the outer loop, the inner loop will execute one time.
• In the second iteration of the outer loop, the inner loop will execute two times.
• In the third iteration of the outer loop, the inner loop will execute three times, and so on, until row 5.
• Print the value of j in each iteration of the inner loop (j is the inner loop iterator variable).
• Display an empty line at the end of each iteration of the outer loop (an empty line after each row).

Approach 1: Use for loop and range() function

• Create a variable s and initialize it to 0 to store the sum of all numbers.
• Use Python 3’s built-in input() function to take input from the user.
• Convert the user’s input to an integer type using the int() constructor and save it to a variable n.
• Run loop n times using for loop and range() function
• In each iteration of the loop, add the current number (i) to the variable s.
• Use the print() function to display the value of the variable s on the screen.

Approach 2: Use the built-in function sum(). The sum() function calculates the addition of all numbers from 1 to a given number.

You can use a simple for loop to generate the multiplication table for a specific number.

• Set n = 2.
• Use for loop to iterate the first 10 natural numbers (From 1 to 10)
• In each iteration, multiply the current number by 2 ( p = n*i). Now print p

Also See: Create Multiplication Table in Python

• Use a for loop to iterate through each item in the list.
• Use a break statement to exit the loop if the current number is greater than 500.
• Use the continue statement to skip the current number and move to the next if the current number is greater than 150.
• Use the condition number % 5 == 0 to check if the number is divisible by 5.

• Set counter = 0
• Run while loop till number != 0
• In each iteration of a loop
  • Reduce the last digit from the number using floor division ( number = number // 10)
  • Increment counter by 1
• print counter after loop execution is completed

• Setting the row value to 5 is crucial, as the pattern we’re working with has five rows.
• Using a for loop and the range() function, create an outer loop that iterates through numbers from 1 to 5.
• The outer loop controls the number of iterations of the inner loop. For each outer loop iteration, the number of inner loop iterations is reduced by i, the outer loop’s current number.
• In each iteration of the inner loop, print the iterator variable of the inner loop (j).

Note:

• In the first iteration of the outer loop, the inner loop executes five times.
• In the second iteration of the outer loop, the inner loop executes four times.
• In the last iteration of the outer loop, the inner loop will execute only once.

Approach 1: Use the built-in function reversed() to reverse the list

Approach 2: Use for loop and the len() function

• Get the size of a list using the len(list1) function.
• Use a for loop and reversed(range()) to iterate through index numbers in reverse order, starting from length-1 down to 0. In each iteration, i will be reduced by 1.
• In each iteration, print list items using list1[i]. i is the current value of the index.

Python allows us to use an else block with a for loop like the if statement. The loop can have the else block, which will be executed when it terminates normally. See else block in for loop.

Think about what defines a prime number. Then, consider how you can check that property for each number within the given range using a loop. You might need another loop inside to help with the check.

• Iterate through each number in the given range.
• For each number, assume it’s prime initially.
• Check for divisibility from 2 up to the square root of the number.
• If divisible by any number in this range, it’s not prime.
• If the inner loop completes without finding a divisor and the number is greater than 1, then it’s prime.
• Print the numbers identified as prime.
• Remember to handle numbers less than or equal to 1.

• Set num1 = 0 and num2 = 1 (first two numbers of the sequence)
• Run the loop 10 times
• In each iteration
  • print num1 as the current number of the sequence
  • Add the last two numbers to get the following number result = num1 + num2
  • update values of num1 and num2. Set num1 = num2 and num2 = result

• Set variable factorial = 1 to store the factorial of a given number
• Iterate numbers starting from 1 to the given number n using for loop and range() function. (here, the loop will run five times because n is 5)
• In each iteration, multiply the factorial by the current number and assign it again to a factorial variable (factorial = factorial *i)
• After the loop completes, print factorial

• Initialize a variable to store the reversed number (set it to 0 initially).
• Use a while loop that continues as long as the original number is greater than 0.
• Inside the loop:
  • Extract the last digit of the original number using the modulo operator (% 10).
  • Update the reversed number: multiply it by 10 and then add the extracted last digit.
  • Update the original number by integer division (// 10) to remove the last digit.
• After the loop finishes, the reversed number variable will hold the reversed integer.

Use list slicing. List slicing in Python is a powerful way to extract a portion (a sublist) of a list based on a specified range of indices. It allows you to create new lists containing elements from a specific starting point up to (but not including) a specific ending point in the original list.  

• Iterate numbers from 1 to n using for loop and range() function
• In each iteration of a loop, calculate the cube of a current number (i) by multiplying itself three times (cube = i * i* i)

• Initialize a variable sum with the base number.
• Initialize a variable current_term with the base number.
• Loop n-1 times (since the first term is already accounted for in the initialization).
• Inside the loop:
  • Update current_term: multiply it by 10 and add the base number.
  • Add the updated current_term to the sum.
• After the loop, the sum variable will hold the result.

Use two for loops. The first loop will print the upper pattern, and the second loop will print the lower pattern.

First Pattern:

* 
* * 
* * * 
* * * * 
* * * * * 

Second Pattern:

* * * * 
* * * 
* * 
*

Use nested loop, where one loop is placed inside another.

• The outer loop iterates through the rows (numbers 1 to 10).
• The inner loop iterates through the columns (numbers 1 to 10) to calculate and display the product of the numbers.

You need to use two nested loop inside a single loop.

Think about how the numbers are arranged in each row and how that arrangement changes from one row to the next. Consider these points:

1. Row Number: Notice that the behavior of the numbers in a row depends on whether the row number is odd or even.
2. Number of Elements per Row: The first row has one number, the second has two, the third has three, and so on. The ith row contains i numbers.
3. Odd Rows: In odd-numbered rows (1st, 3rd, 5th, etc.), the numbers are printed in increasing order.
4. Even Rows: In even-numbered rows (2nd, 4th, etc.), the numbers are printed in decreasing order.
5. Starting Number: You need to keep track of the starting number for each row. Observe how the last number of one row relates to the first number of the next row.

Try to use these observations to build your logic row by row. You’ll likely need a loop that iterates through the rows, and inside that loop, you’ll have different logic based on whether the current row is odd or even.

You need to use nested loop ( a loop inside another loop)

1. Write Outer Loop:
   • Iterates over each element in the input nested_list.
2. Write Inner Loop:
   • Check If the element is a list, iterate through the sublist and append each item to flat_list.
   • Otherwise, append the element directly to flat_list.
3. After processing all elements, return the flattened list.

• Get Number and treat the Number as a Sequence of Digits.
• Handle the sign (maybe take the absolute value).
• Convert the (absolute) number to a string.
• Initialize variables to store the largest and smallest digits (perhaps with the first digit of the string converted to an integer).
• Loop through the remaining characters of the string (starting from the second character).
• Inside the loop:
  • Convert the current character to an integer.
  • Compare it with the current largest and smallest, updating if necessary.
• Return or print the largest and smallest digits.