how to develop an algorithm of read10 integer from the keyboard inthe range of 0up to 100 and how many the are larger than 50 and display the sum
1. Start the program
2. Set up a counter variable to keep track of the number of integers that are larger than 50
3. Set up a variable to keep track of the sum of the integers
4. Set up a loop to read 10 integers from the keyboard
5. For each integer read, check if it is within the range of 0 to 100
6. If the integer is not within the range, prompt the user to enter an integer within the range
7. If the integer is within the range, check if it is larger than 50
8. If the integer is larger than 50, increment the counter variable
9. Add the integer to the sum variable
10. After reading all 10 integers, display the number of integers that are larger than 50 and the sum of all the integers
11. End the program
Here is the Python implementation of the algorithm:
counter = 0
sum = 0
for i in range(10):
num = int(input("Enter an integer between 0 and 100: "))
while num < 0 or num > 100:
num = int(input("Number not within range. Enter an integer between 0 and 100: "))
if num > 50:
counter += 1
sum += num
print("Number of integers larger than 50:", counter)
print("Sum of all integers:", sum)
how-to-write-flowchart-read-10-integer-from-the-key-board-in-the-range-0-up-to-100-and-count-how-many-them-are-largest-than-50--and-display-the-result
Here is a possible flowchart for this algorithm:
Note that the flowchart assumes that the user knows how to input integers and that the input is valid (i.e., an integer between 0 and 100). If the input is not valid, the program should prompt the user to enter a valid input before continuing with the loop.
Also note that the flowchart uses a decision symbol to check if each integer is larger than 50, and an accumulation symbol to keep track of the counter and sum variables. Finally, the flowchart displays the counter and sum variables after the loop is completed.
how-to-drow-flowchart-read-10-integer-from-the-key-board-in-the-range-0-up-to-100-and-count-how-many-them-are-largest-than-50--and-display-the-result
Here is a basic flowchart for the algorithm:
Note that the flowchart assumes that the user knows how to input integers and that the input is valid (i.e., an integer between 0 and 100). If the input is not valid, the program should prompt the user to enter a valid input before continuing with the loop.
Also note that the flowchart uses a decision symbol to check if each integer is larger than 50, and an accumulation symbol to keep track of the counter and sum variables. Finally, the flowchart displays the counter and sum variables after the loop is completed.
To develop an algorithm that reads 10 integers from the keyboard within the range of 0 up to 100, and counts how many are larger than 50 while displaying the sum, you can follow these steps:
1. Initialize a variable `count` to 0 and a variable `sum` to 0.
2. Create a loop that will iterate 10 times.
3. Inside the loop, prompt the user to enter an integer from the keyboard and store it in a variable `num`.
4. Check if `num` is within the range of 0 up to 100 (inclusive). If it is not, go back to step 3.
5. Increment `count` by 1.
6. Add `num` to `sum`.
7. Check if `num` is larger than 50. If it is, go to step 5.
8. After the loop ends, display the value of `count` as the number of integers larger than 50.
9. Display the value of `sum` as the sum of the entered integers.
Here's a basic Python implementation of the algorithm:
``` python
count = 0
sum = 0
for _ in range(10):
num = int(input("Enter an integer between 0 and 100: "))
while num < 0 or num > 100:
num = int(input("Invalid input! Enter an integer between 0 and 100: "))
count += 1
sum += num
if num > 50:
count_greater_than_50 += 1
print("Number of integers larger than 50:", count)
print("Sum of entered integers:", sum)
```
Please note that the implementation above assumes that the user will always enter valid integers. Additional error handling can be added to handle invalid input if required.
To develop an algorithm for reading 10 integers from the keyboard in the range of 0 up to 100, and finding how many are larger than 50, as well as displaying their sum, you can follow these steps:
1. Initialize a variable, let's say `count`, to keep track of the count of integers larger than 50. Set it to 0.
2. Initialize a variable, let's say `sum`, to keep track of the sum of the integers larger than 50. Set it to 0.
3. Create a loop that will execute 10 times to read the 10 integers from the keyboard.
4. Within the loop, read an integer from the keyboard and store it in a variable, let's say `num`.
5. Check if the value of `num` is within the range of 0 to 100.
6. If `num` is less than 0 or greater than 100, display an error message and ask the user to input a valid integer. Then, go back to step 4 to read the input again.
7. If `num` is larger than 50, increment the value of `count` by 1.
8. Add the value of `num` to the current value of `sum`.
9. After the loop finishes executing, display the value of `count` (which represents the count of integers larger than 50) and the value of `sum` (which represents their sum).
Here's a Python example of the algorithm:
```
count = 0
sum = 0
for i in range(10):
num = int(input("Enter an integer (0-100): "))
if num < 0 or num > 100:
print("Invalid input. Please enter a valid integer.")
continue
if num > 50:
count += 1
sum += num
print("Count of integers larger than 50:", count)
print("Sum of integers larger than 50:", sum)
```
You can implement this algorithm in other programming languages by following the same logical steps.