ROMERO, CYBERT S.
BSIT 2-C
Task 1: Basic Calculator
Algorithm to perform basic arithmetic operations: addition, subtraction, multiplication, and division.
Step 1: Define the inputs:
- Input two numbers, num1 and num2.
- Input the desired operation: add, subtract, multiply, or divide.
Step 2: Check the operation:
- If the operation is add, calculate result = num1 + num2.
- If the operation is subtract, calculate result = num1 – num2.
- If the operation is multiply, calculate result = num1 * num2.
- If the operation is divide:
- Check if num2 is not 0.
- If num2 is not 0, calculate result = num1 / num2.
- Otherwise, display an error message: “Division by zero is not allowed.”
Step 3: Display the result of the operation.
Final Step: End the algorithm.
Task 2: Area of a Circle
Algorithm to calculate the area of a circle given the radius.
Step 1: Define the input:
- Input the radius of the circle, r.
Step 2: Calculate the area:
- Use the formula: area = π * r * r.
- (Take π as 3.14159).
Step 3: Display the calculated area.
Final Step: End the algorithm.
Task 3: Convert Fahrenheit to Celsius
Algorithm to convert temperature from Fahrenheit to Celsius.
Step 1: Define the input:
- Input the temperature in Fahrenheit, F.
Step 2: Convert Fahrenheit to Celsius:
- Use the formula: C = (F – 32) * 5 / 9.
Step 3: Display the temperature in Celsius, `C`.
Final Step: End the algorithm.
Task 4: Simple Interest
Algorithm to calculate simple interest.
Step 1: Define the inputs:
- Input the principal amount, P.
- Input the rate of interest, R (as a percentage).
- Input the time period, T (in years).
Step 2: Calculate the simple interest:
- Use the formula: SI = (P * R * T) / 100.
Step 3: Display the calculated simple interest, SI.
Final Step: End the algorithm.
Task 5: BMI Calculator
Algorithm to calculate Body Mass Index (BMI).
Step 1: Define the inputs:
- Input the weight of the person, weight (in kilograms).
- Input the height of the person, height (in meters).
Step 2: Calculate the BMI:
- Use the formula: BMI = weight / (height * height).
Step 3: Display the BMI value.
Step 4 (Optional): Provide a BMI classification:
- If BMI < 18.5, display “Underweight”.
- If 18.5 <= BMI <= 24.9, display “Normal weight”.
- If 25 <= BMI <= 29.9, display “Overweight”.
- If BMI >= 30, display “Obesity”.
Final Step: End the algorithm.
Task 6: Even or Odd
Algorithm to check whether a number is even or odd.
Step 1: Define the input:
- Input a number, num.
Step 2: Check if the number is even:
- If num % 2 == 0, then it is even.
- Otherwise, it is odd.
Step 3: Display the result (“Even” or “Odd”).
Final Step: End the algorithm.
Task 7: Leap Year Checker
Algorithm to check whether a year is a leap year.
Step 1: Define the input:
- Input the year, year.
Step 2: Check if the year is a leap year:
- If year % 4 == 0:
- Check if year % 100 == 0:
- If year % 400 == 0, it is a leap year.
- Otherwise, it is not a leap year.
- Otherwise, it is a leap year.
- Otherwise, it is not a leap year.
Step 3: Display the result (“Leap year” or “Not a leap year”).
Final Step: End the algorithm.
Task 8: Largest of Three Numbers
Algorithm to find the largest of three numbers.
Step 1: Define the inputs:
- Input three numbers, a, b, and c.
Step 2: Compare the numbers:
- If a > b and a > c, then a is the largest.
- Else if b > a and b > c, then b is the largest.
- Otherwise, c is the largest.
Step 3: Display the largest number.
Final Step: End the algorithm.
Task 9: Pass or Fail
Algorithm to check if a student passes or fails.
Step 1: Define the inputs:
- Input the score of the student, score.
- Define the passing score as 60.
Step 2: Check if the student passes:
- If score >= 60, display “Pass”.
- Otherwise, display “Fail”.
Final Step: End the algorithm.
Task 10: Voting Eligibility
Algorithm to check if a person is eligible to vote.
Step 1: Define the input:
- Input the age of the person, age.
Step 2: Check eligibility:
- If age >= 18, display “Eligible to vote”.
- Otherwise, display “Not eligible to vote”.
Final Step: End the algorithm.
Task 11: Print Multiplication Table
Algorithm to print the multiplication table of a number.
Step 1: Define the inputs:
- Input a number, num.
- Input the range, range_limit (e.g., 10).
Step 2: Initialize a counter:
- Set I = 1.
Step 3: Loop through the range:
- While I <= range_limit:
- Calculate result = num * i.
- Display the result in the format num x I = result.
- Increment i by 1.
Step 4: End the loop when I > range_limit.
Final Step: End the algorithm.
### **Task 12: Sum of Natural Numbers**
**Algorithm to find the sum of the first `n` natural numbers.**
**Step 1:** Define the input:
- Input a positive integer, `n`.
**Step 2:** Initialize the sum:
- Set `sum = 0`.
**Step 3:** Loop through the numbers:
- For `I = 1` to `n`:
- Add `i` to `sum`.
**Step 4:** Display the total sum.
**Final Step:** End the algorithm.
### **Task 13: Factorial of a Number**
**Algorithm to find the factorial of a number.**
**Step 1:** Define the input:
- Input a non-negative integer, `n`.
**Step 2:** Initialize the factorial:
- Set `factorial = 1`.
**Step 3:** Loop through the numbers:
- For `I = 1` to `n`:
- Multiply `factorial` by `i`.
**Step 4:** Display the calculated factorial.
**Final Step:** End the algorithm.
### **Task 14: Prime Number Checker**
**Algorithm to check if a number is prime.**
**Step 1:** Define the input:
- Input a number, `num`.
**Step 2:** Initialize a flag:
- Set `is_prime = true`.
**Step 3:** Check divisibility:
- If `num <= 1`, set `is_prime = false`.
- Otherwise, for `I = 2` to `sqrt(num)`:
- If `num % I == 0`, set `is_prime = false` and break.
**Step 4:** Display the result:
- If `is_prime = true`, display “Prime”.
- Otherwise, display “Not Prime”.
**Final Step:** End the algorithm.
### **Task 15: Fibonacci Sequence**
**Algorithm to print the first `n` Fibonacci numbers.**
**Step 1:** Define the input:
- Input the number of terms, `n`.
**Step 2:** Initialize the first two terms:
- Set `a = 0`, `b = 1`.
**Step 3:** Display the first two terms:
- Print `a` and `b`.
**Step 4:** Generate the sequence:
- For `I = 3` to `n`:
- Calculate `next_term = a + b`.
- Print `next_term`.
- Update `a = b` and `b = next_term`.
**Final Step:** End the algorithm.
### **Task 16: Sum of Array Elements**
**Algorithm to find the sum of all elements in an array.**
**Step 1:** Define the input:
- Input an array, `arr` of size `n`.
**Step 2:** Initialize the sum:
- Set `sum = 0`.
**Step 3:** Loop through the array:
- For each element `num` in `arr`:
- Add `num` to `sum`.
**Step 4:** Display the total sum.
**Final Step:** End the algorithm.
### **Task 17: Find Maximum in an Array**
**Algorithm to find the maximum element in an array.**
**Step 1:** Define the input:
- Input an array, `arr` of size `n`.
**Step 2:** Initialize the maximum:
- Set `max = arr[0]`.
**Step 3:** Loop through the array:
- For each element `num` in `arr`:
- If `num > max`, update `max = num`.
**Step 4:** Display the maximum value.
**Final Step:** End the algorithm.
### **Task 18: Reverse an Array**
**Algorithm to reverse the elements of an array.**
**Step 1:** Define the input:
- Input an array, `arr` of size `n`.
**Step 2:** Initialize two pointers:
- Set `start = 0` and `end = n – 1`.
**Step 3:** Swap elements:
- While `start < end`:
- Swap `arr[start]` and `arr[end]`.
- Increment `start` by 1.
- Decrement `end` by 1.
**Step 4:** Display the reversed array.
**Final Step:** End the algorithm.
### **Task 19: Sort an Array**
**Algorithm to sort an array in ascending order (using Bubble Sort).**
**Step 1:** Define the input:
- Input an array, `arr` of size `n`.
**Step 2:** Loop through the array:
- For `I = 0` to `n-1`:
- For `j = 0` to `n-i-2`:
- If `arr[j] > arr[j+1]`, swap `arr[j]` and `arr[j+1]`.
**Step 3:** Display the sorted array.
**Final Step:** End the algorithm.
### **Task 20: Count Even and Odd Numbers in an Array**
**Algorithm to count even and odd numbers in an array.**
**Step 1:** Define the input:
- Input an array, `arr` of size `n`.
**Step 2:** Initialize counters:
- Set `even_count = 0` and `odd_count = 0`.
**Step 3:** Loop through the array:
- For each element `num` in `arr`:
- If `num % 2 == 0`, increment `even_count`.
- Otherwise, increment `odd_count`.
**Step 4:** Display the counts.
**Final Step:** End the algorithm.
Here are the algorithms for **Tasks 21 to 49** divided into sections for readability:
## **Functions: Tasks 21–25**
### **Task 21: Simple Calculator Using Functions**
**Algorithm to perform basic arithmetic using functions.**
**Step 1:** Define four functions:
- `add(a, b)` → return `a + b`.
- `subtract(a, b)` → return `a – b`.
- `multiply(a, b)` → return `a * b`.
- `divide(a, b)` → return `a / b` (check if `b != 0`).
**Step 2:** Input two numbers, `num1` and `num2`.
**Step 3:** Input the operation type: `add`, `subtract`, `multiply`, or `divide`.
**Step 4:** Call the respective function and display the result.
**Final Step:** End the algorithm.
### **Task 22: Find the GCD**
**Algorithm to find the greatest common divisor (GCD) using the Euclidean method.**
**Step 1:** Define a function `gcd(a, b)`.
**Step 2:** In the function:
- While `b != 0`:
- Set `temp = b`.
- Update `b = a % b`.
- Update `a = temp`.
**Step 3:** Return `a` as the GCD.
**Final Step:** End the algorithm.
### **Task 23: Power of a Number**
**Algorithm to calculate the power of a number using a loop.**
**Step 1:** Define a function `power(base, exponent)`.
**Step 2:** Initialize `result = 1`.
**Step 3:** Loop `exponent` times:
- Multiply `result` by `base`.
**Step 4:** Return `result`.
**Final Step:** End the algorithm.
### **Task 24: Sum of Digits**
**Algorithm to calculate the sum of digits of a number.**
**Step 1:** Define a function `sum_of_digits(n)`.
**Step 2:** Initialize `sum = 0`.
**Step 3:** While `n > 0`:
- Add `n % 10` to `sum`.
- Update `n = n // 10`.
**Step 4:** Return `sum`.
**Final Step:** End the algorithm.
### **Task 25: Check Palindrome (String)**
**Algorithm to check if a string is a palindrome.**
**Step 1:** Define a function `is_palindrome(str)`.
**Step 2:** Compare the string with its reverse:
- If `str == str[::-1]`, return `True`.
- Otherwise, return `False`.
**Step 3:** Display the result.
**Final Step:** End the algorithm.
## **Strings: Tasks 26–30**
### **Task 26: Reverse a String**
**Algorithm to reverse a string.**
**Step 1:** Input a string, `str`.
**Step 2:** Reverse the string:
- Use slicing: `reversed_str = str[::-1]`.
**Step 3:** Display the reversed string.
**Final Step:** End the algorithm.
### **Task 27: Count Vowels in a String**
**Algorithm to count vowels in a string.**
**Step 1:** Input a string, `str`.
**Step 2:** Initialize `vowel_count = 0`.
**Step 3:** For each character in `str`:
- If the character is in `{‘a’, ‘e’, ‘I’, ‘o’, ‘u’}` (case insensitive), increment `vowel_count`.
**Step 4:** Display `vowel_count`.
**Final Step:** End the algorithm.
### **Task 28: String Palindrome**
(Same as Task 25.)
### **Task 29: Check Anagram**
**Algorithm to check if two strings are anagrams.**
**Step 1:** Input two strings, `str1` and `str2`.
**Step 2:** Sort both strings.
**Step 3:** Compare the sorted strings:
- If equal, they are anagrams.
**Step 4:** Display the result.
**Final Step:** End the algorithm.
### **Task 30: Convert Uppercase to Lowercase**
**Algorithm to convert uppercase letters in a string to lowercase.**
**Step 1:** Input a string, `str`.
**Step 2:** Convert to lowercase:
- Use `lowercase_str = str.lower()`.
**Step 3:** Display `lowercase_str`.
**Final Step:** End the algorithm.
## **File Handling: Tasks 31–35**
### **Task 31: Read a File**
**Algorithm to read the contents of a text file.**
**Step 1:** Input the file name, `file_name`.
**Step 2:** Open the file in read mode.
**Step 3:** Read and display its content.
**Final Step:** Close the file and end the algorithm.
### **Task 32: Write to a File**
**Algorithm to write content into a text file.**
**Step 1:** Input the file name, `file_name`.
**Step 2:** Input the content to write.
**Step 3:** Open the file in write mode and write the content.
**Final Step:** Close the file and end the algorithm.
### **Task 33: Word Count in a File**
**Algorithm to count the number of words in a text file.**
**Step 1:** Open the file in read mode.
**Step 2:** Read the content and split it into words.
**Step 3:** Count the words and display the result.
**Final Step:** End the algorithm.
### **Task 34: Copy Content from One File to Another**
**Algorithm to copy the content of one file into another.**
**Step 1:** Open the source file in read mode.
**Step 2:** Open the destination file in write mode.
**Step 3:** Copy content and save it to the destination file.
**Final Step:** End the algorithm.
### **Task 35: Find Longest Word in a File**
**Algorithm to find the longest word in a file.**
**Step 1:** Open the file and read its content.
**Step 2:** Split the content into words.
**Step 3:** Loop through the words and find the longest.
**Final Step:** End the algorithm.
Here are the algorithms for **Tasks 36 to 40**, focusing on recursion-based problems:
### **Task 36: Recursive Factorial**
**Algorithm to calculate the factorial of a number using recursion.**
**Step 1:** Define a function `factorial(n)`.
**Step 2:** Base Case:
- If `n == 0` or `n == 1`, return `1`.
**Step 3:** Recursive Case:
- Return `n * factorial(n-1)`.
**Step 4:** Input a non-negative integer, `n`.
**Step 5:** Call the function `factorial(n)` and display the result.
**Final Step:** End the algorithm.
### **Task 37: Recursive Fibonacci**
**Algorithm to calculate the nth Fibonacci number using recursion.**
**Step 1:** Define a function `fibonacci(n)`.
**Step 2:** Base Case:
- If `n == 1`, return `0`.
- If `n == 2`, return `1`.
**Step 3:** Recursive Case:
- Return `fibonacci(n-1) + fibonacci(n-2)`.
**Step 4:** Input the term number, `n`.
**Step 5:** Call the function `fibonacci(n)` and display the result.
**Final Step:** End the algorithm.
### **Task 38: Recursive Sum of Digits**
**Algorithm to calculate the sum of digits of a number using recursion.**
**Step 1:** Define a function `sum_of_digits(n)`.
**Step 2:** Base Case:
- If `n == 0`, return `0`.
**Step 3:** Recursive Case:
- Return `(n % 10) + sum_of_digits(n // 10)`.
**Step 4:** Input a non-negative integer, `n`.
**Step 5:** Call the function `sum_of_digits(n)` and display the result.
**Final Step:** End the algorithm.
### **Task 39: Recursive GCD**
**Algorithm to calculate the greatest common divisor (GCD) using recursion.**
**Step 1:** Define a function `gcd(a, b)`.
**Step 2:** Base Case:
- If `b == 0`, return `a`.
**Step 3:** Recursive Case:
- Return `gcd(b, a % b)`.
**Step 4:** Input two positive integers, `a` and `b`.
**Step 5:** Call the function `gcd(a, b)` and display the result.
**Final Step:** End the algorithm.
### **Task 40: Recursive Power**
**Algorithm to calculate the power of a number using recursion.**
**Step 1:** Define a function `power(base, exp)`.
**Step 2:** Base Case:
- If `exp == 0`, return `1`.
**Step 3:** Recursive Case:
- Return `base * power(base, exp – 1)`.
**Step 4:** Input the `base` and `exp` (exponent).
**Step 5:** Call the function `power(base, exp)` and display the result.
**Final Step:** End the algorithm.
Here are the algorithms for **Tasks 41 to 49**:
## **Miscellaneous: Tasks 41 to 45**
### **Task 41: Armstrong Number Checker**
**Algorithm to check if a number is an Armstrong number.**
**Step 1:** Define the input:
- Input a number, `num`.
**Step 2:** Initialize variables:
- Set `sum = 0`.
- Set `temp = num`.
**Step 3:** Extract digits and calculate the sum of their cubes:
- While `temp > 0`:
- Extract the last digit: `digit = temp % 10`.
- Add `digit^3` to `sum`.
- Remove the last digit: `temp = temp // 10`.
**Step 4:** Check if `sum == num`:
- If true, display “Armstrong Number”.
- Otherwise, display “Not an Armstrong Number”.
**Final Step:** End the algorithm.
### **Task 42: Palindrome Number**
**Algorithm to check if a number is a palindrome.**
**Step 1:** Define the input:
- Input a number, `num`.
**Step 2:** Initialize variables:
- Set `reversed_num = 0`.
- Set `temp = num`.
**Step 3:** Reverse the number:
- While `temp > 0`:
- Extract the last digit: `digit = temp % 10`.
- Update `reversed_num = reversed_num * 10 + digit`.
- Remove the last digit: `temp = temp // 10`.
**Step 4:** Check if `reversed_num == num`:
- If true, display “Palindrome Number”.
- Otherwise, display “Not a Palindrome Number”.
**Final Step:** End the algorithm.
### **Task 43: Count Prime Numbers**
**Algorithm to count all prime numbers between two given numbers.**
**Step 1:** Define the inputs:
- Input two numbers, `low` and `high`.
**Step 2:** Initialize `prime_count = 0`.
**Step 3:** Loop through the range:
- For each number `num` from `low` to `high`:
- Check if `num` is prime (use the prime-checking logic from Task 14).
- If `num` is prime, increment `prime_count`.
**Step 4:** Display `prime_count`.
**Final Step:** End the algorithm.
### **Task 44: Factorial Using Loop**
**Algorithm to calculate the factorial of a number using a loop.**
**Step 1:** Define the input:
- Input a number, `n`.
**Step 2:** Initialize `factorial = 1`.
**Step 3:** Loop through numbers:
- For `I = 1` to `n`:
- Multiply `factorial = factorial * i`.
**Step 4:** Display `factorial`.
**Final Step:** End the algorithm.
### **Task 45: Generate Prime Numbers**
**Algorithm to generate prime numbers up to a given limit.**
**Step 1:** Define the input:
- Input a number, `limit`.
**Step 2:** Loop through numbers:
- For each number `num` from `2` to `limit`:
- Check if `num` is prime (use the prime-checking logic from Task 14).
- If `num` is prime, display it.
**Final Step:** End the algorithm.
## **Advanced Loops & Patterns: Tasks 46 to 49**
### **Task 46: Print Star Pyramid**
**Algorithm to print a star pyramid pattern.**
**Step 1:** Define the input:
- Input the number of rows, `n`.
**Step 2:** Loop through rows:
- For each row `i` from `1` to `n`:
- Print `n-i` spaces.
- Print `2*i-1` stars.
**Final Step:** End the algorithm.
### **Task 47: Pascal’s Triangle**
**Algorithm to print Pascal’s triangle up to `n` rows.**
**Step 1:** Define the input:
- Input the number of rows, `n`.
**Step 2:** Loop through rows:
- For each row `i` from `0` to `n-1`:
- Initialize `value = 1`.
- Loop through columns `j` from `0` to `i`:
- Print `value`.
- Update `value = value * (I – j) / (j + 1)`.
**Step 3:** Print a newline after each row.
**Final Step:** End the algorithm.
### **Task 48: Diamond Pattern**
**Algorithm to print a diamond-shaped star pattern.**
**Step 1:** Define the input:
- Input the number of rows, `n`.
**Step 2:** Print the upper pyramid:
- For each row `i` from `1` to `n`:
- Print `n-i` spaces.
- Print `2*i-1` stars.
**Step 3:** Print the lower inverted pyramid:
- For each row `i` from `n-1` to `1`:
- Print `n-i` spaces.
- Print `2*i-1` stars.
**Final Step:** End the algorithm.
### **Task 49: Number Pattern**
**Algorithm to print a number pattern (e.g., triangle of numbers).**
**Step 1:** Define the input:
- Input the number of rows, `n`.
**Step 2:** Loop through rows:
- For each row `i` from `1` to `n`:
- Loop through columns `j` from `1` to `i`:
- Print `j`.
**Step 3:** Print a newline after each row.
**Final Step:** End the algorithm.
