Assume an array `arr` holds 5 elements. Write a program that inputs 5 numbers sequentially to populate the array, and then inputs a final target number `T`. The program should output "Found" if `T` exists within the array, and "Not Found" otherwise.

Linear Search

Write a program that takes a person's name as input and outputs a greeting in the exact format "Hello [name]".

Greet the User

Write a program that prompts the user to enter 5 positive numbers one by one. The program should evaluate them sequentially and output the largest number entered.

Find Maximum of 5 Numbers

Write a program that inputs a string and outputs the exact string backwards (in reverse).

Reverse a String

Write a program that takes an integer `N` and outputs the `N`th number in the Fibonacci sequence. Assume the sequence starts with 1, 1, 2, 3, 5... so if N=4, output 3.

Nth Fibonacci Number

Write a program that asks for a lowercase string and outputs the integer number of vowels (a, e, i, o, u) it contains.

Count Vowels

A library charges $0.50 per day for a book that is up to 7 days late, and $1.00 per day for every day after that (e.g. 8 days late = 7 * 0.50 + 1 * 1.00 = 4.50). Write a program that inputs the total number of days late and outputs the total fine.

Library Fine Calculator

Write a program that takes the prices of 3 items in a shopping cart. If the total is greater than 50, apply a 10% discount. Output the final total.

Shopping Cart Total

Write a program that takes a year as input and outputs "Leap" if it is a leap year, and "Not Leap" otherwise. A year is a leap year if it is divisible by 4 but not by 100, unless it is also divisible by 400.

Leap Year Checker

Write a program that inputs 5 integers into an array and outputs their total sum.

Sum of an Array

Write a program that takes a temperature in Celsius as input and outputs the equivalent temperature in Fahrenheit. The formula is F = C * (9/5) + 32.

Temperature Conversion

Write a program that takes a student's mark out of 100 as input. Output "A" for marks 80 and above, "B" for 60 to 79, "C" for 40 to 59, and "Fail" for anything below 40.

Student Grade Calculator

Write a program that takes three numbers as input and outputs the smallest of the three.

Minimum of Three Numbers

Write a program that takes an integer `n` as input and prints its multiplication table from 1 to 5. Each line should just output the result of `n * i`.

Multiplication Table

Write a program that asks the user for an integer and outputs "Even" if the number is divisible by 2, and "Odd" otherwise.

Check Even or Odd

Write a program that takes a positive integer `N` as input and outputs the numbers from 1 to `N`, each on a new line.

Print 1 to N

Write a program that takes a positive integer and outputs the sum of its individual digits. For example, if the input is 123, the output should be 6 (1+2+3).

Sum Digits of a Number

Write a program that calculates the factorial of a given positive integer `N`. Output the final mathematical result.

Calculate Factorial

Write a program that takes 5 integers as input and calculates their average. Output the average as a real number.

Calculate Average

Write a program that takes an integer `N` as input and outputs all even numbers from 2 up to `N` (inclusive), each on a new line.

Print Even Numbers to N

Write a program that takes an integer as input. If the number is greater than 0, output "Positive". If it is less than 0, output "Negative". If it is 0, output "Zero".

Positive, Negative or Zero

Write a program that takes three numbers as input and outputs the largest of the three.

Largest of Three Numbers

Write a program that takes a string as input and checks if it reads the same forwards and backwards. Output "Palindrome" if it does, and "Not Palindrome" if it does not.

Check Palindrome

Write a program that inputs 5 numbers sequentially to populate an array, and then inputs a target number `T`. Output the 1-based position (1 to 5) of the first occurrence of `T`. If it is not found, output -1.

Find Index of Value

Write a program that inputs 5 numbers sequentially. Count how many of those numbers are even and output the final count.

Count Even Numbers

Write a program that inputs 5 integers into an array and sorts them into **ascending** order using a bubble sort. Swap two neighbouring values only when the left one is **strictly greater** than the right one.

Output the 5 sorted values, one per line, followed by a final line showing the total number of swaps made during the sort.

For example, the input 5 1 4 2 8 outputs 1, 2, 4, 5, 8 (one per line) and then 4.

Bubble Sort with Swap Count

Write a program that inputs a sentence and outputs the number of words in it.

You may assume the sentence is not empty, words are separated by exactly one space, and there are no spaces at the start or end of the sentence.

For example, `the quick brown fox` contains 4 words.

Word Counter

The Collatz process starts with a positive integer `n` and repeats the following until `n` becomes 1:

- If `n` is even, replace it with `n` divided by 2.
- If `n` is odd, replace it with `3 * n + 1`.

Write a program that inputs a positive integer and outputs the number of steps needed to reach 1.

For example, 6 -> 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1 takes 8 steps. An input of 1 needs 0 steps.

Collatz Step Counter

A 3 x 3 grid of integers is stored in a 2D array. Write a program that inputs 9 integers **row by row** (the first three inputs fill row 1, the next three fill row 2, and so on).

Output two lines:

1. The sum of the main diagonal (top-left to bottom-right).
2. The sum of the anti-diagonal (top-right to bottom-left).

For example, the grid 1 2 3 / 4 5 6 / 7 8 9 has a main diagonal sum of 15 and an anti-diagonal sum of 15.

Grid Diagonal Sums

A website scores a password against three rules:

1. It has at least 8 characters.
2. It contains at least one digit (0-9).
3. It contains at least one uppercase letter (A-Z).

Write a program that inputs a password and outputs:

- `Strong` if all 3 rules are met
- `Medium` if exactly 2 rules are met
- `Weak` if 0 or 1 rules are met

Hint: digits have ASCII codes 48 to 57 and uppercase letters have codes 65 to 90.

Password Strength Checker

A museum charges different ticket prices depending on a visitor's age.

- Under 5: 0
- 5 to 15 (inclusive): 5
- 16 to 64 (inclusive): 12
- 65 and over: 7

Write a program that inputs the visitor's age as an integer and outputs the ticket price as a whole number.

Ticket Price by Age

Simulate a simple cash machine. The account balance starts at 500 and the correct PIN is 1234.

**Step 1 - PIN entry:** The user has up to 3 attempts. For each wrong PIN, output `Wrong PIN`. A correct PIN moves on to Step 2. If all 3 attempts are wrong, output `Card blocked` and stop (do not input anything else).

**Step 2 - Withdrawals:** Repeatedly input a withdrawal amount (a non-negative integer) until 0 is entered. For each amount:

- If it is greater than the current balance, output `Insufficient funds`.
- Otherwise, if it is not a multiple of 10, output `Invalid amount`.
- Otherwise, subtract it from the balance and output the new balance.

When 0 is entered, output `Goodbye`.

For example, the inputs 1234, 100, 0 produce `400` then `Goodbye` (one per line).

ATM Withdrawal Simulation

Write a program that inputs 5 integers into an array, then outputs the **range** of the data: the largest value minus the smallest value.

For example, the values 4, 9, 2, 7, 5 have a range of 9 - 2 = 7.

Array Range

Write a function `IsPrime(n)` that returns `TRUE` if the integer `n` is a prime number and `FALSE` otherwise. (A prime number is greater than 1 and has no divisors other than 1 and itself.)

Then write a main program that inputs an integer `N`, calls `IsPrime` for every whole number from 2 to `N` inclusive and outputs each prime number on its own line.

If there are no primes in that range, output `None`.

For example, if `N` is 10 the output is 2, 3, 5, 7 (one per line).

Primes Up To N Using a Function

A Caesar cipher replaces each letter with the letter a fixed number of places further along the alphabet, wrapping round from Z back to A.

Write a program that inputs a word made only of **uppercase** letters (A-Z), then inputs a shift value between 0 and 25. Output the encrypted word.

For example, `HELLO` with a shift of 3 becomes `KHOOR`, and `XYZ` with a shift of 3 becomes `ABC`.

Hint: the ASCII code for `A` is 65 and for `Z` is 90.

Caesar Cipher Encryptor

Write a program that inputs a positive integer `n` and outputs the sum of the squares of all whole numbers from 1 to `n` inclusive.

For example, if `n` is 3 the program calculates 1 + 4 + 9 and outputs 14.

Sum of Squares

Write a program that inputs a day, a month and a year (three integers, in that order) and outputs `Valid` if they form a real calendar date, otherwise `Invalid`.

Rules:

- The year must be 1 or greater and the month must be 1 to 12.
- The day must be at least 1 and no more than the number of days in that month.
- April, June, September and November have 30 days; February has 28 days, or 29 in a leap year; all other months have 31 days.
- A year is a leap year if it is divisible by 400, or divisible by 4 but not by 100.

For example, 29 2 2024 is `Valid` but 29 2 1900 is `Invalid`.

Valid Date Checker

Write a program that repeatedly inputs an exam mark until a valid mark is entered. A valid mark is a whole number from 0 to 100 inclusive.

Every time an invalid mark is entered, output `Invalid`. When a valid mark is entered, output `Accepted` and stop.

For example, the inputs 150, -5, 60 produce `Invalid`, `Invalid`, `Accepted` (one per line).

Mark Range Validation

Write a program that inputs 7 integers which are already sorted in ascending order into an array, then inputs a target value.

Use a binary search with `low` as the first index, `high` as the last index and `mid = (low + high) DIV 2`. Count each time the middle item is examined.

- If the target is found, output the number of steps taken to find it.
- If it is not in the array, output `Not Found`.

For example, with the array 2, 5, 8, 12, 16, 23, 38 and a target of 23, the middle items checked are 12 then 23, so the output is 2.

Binary Search Step Counter

Write a program that inputs the lengths of three sides of a shape (positive integers `a`, `b` and `c`, in that order).

Three lengths form a valid triangle only if the sum of any two sides is **greater than** the third side. Output one of:

- `Not a triangle`
- `Equilateral` (all sides equal)
- `Isosceles` (exactly two sides equal)
- `Scalene` (no sides equal)

Triangle Classifier

A **perfect number** is a positive integer that equals the sum of its proper divisors (all the positive divisors that are smaller than the number itself). For example, 6 is perfect because 1 + 2 + 3 = 6.

Write a program that inputs an integer `N` and outputs every perfect number from 2 to `N` inclusive, one per line, in ascending order. If there are none, output `None`.

Perfect Numbers Up To N

Write a program that inputs a positive integer `n` and outputs a right-angled triangle of asterisks (`*`) with `n` rows. Row 1 has one asterisk, row 2 has two, and so on up to row `n`.

For example, if `n` is 3 the output is:

```
*
**
***
```

Triangle of Stars

Write a program that inputs 3 integers into array `a`, then 3 integers into array `b`. Each array is already sorted in ascending order.

Merge them into a single array of 6 values that is also in ascending order, **without sorting the combined array**: repeatedly compare the next unused value of each array and copy the smaller one across. Output the merged array, one value per line.

For example, `a` = 1, 4, 7 and `b` = 2, 3, 9 produce 1, 2, 3, 4, 7, 9.

Merge Two Sorted Arrays

Write a program that judges one round of Rock, Paper, Scissors. Input Player 1's choice, then Player 2's choice. Each choice is a single uppercase letter: `R` (rock), `P` (paper) or `S` (scissors).

Rock beats scissors, scissors beats paper, and paper beats rock. Output one of:

- `Player 1 wins`
- `Player 2 wins`
- `Draw`

Rock Paper Scissors Judge

Two words are **anagrams** if they contain exactly the same letters the same number of times, in any order (for example `listen` and `silent`).

Write a program that inputs two words made only of lowercase letters (a-z), which may be different lengths. Output `Anagram` if they are anagrams of each other, otherwise output `Not anagrams`.

Hint: use an array of 26 counters, one for each letter. The ASCII code for `a` is 97.

Anagram Checker

The **greatest common divisor** (GCD) of two positive integers is the largest integer that divides both exactly.

Write a function `GCD(a, b)` that returns the GCD using Euclid's algorithm: while `b` is not 0, replace `a` with `b` and `b` with the remainder of `a` divided by `b`. When `b` is 0, the answer is `a`.

Then write a main program that inputs two positive integers, calls the function, and outputs the result.

For example, the GCD of 12 and 18 is 6.

GCD Function

A traffic light repeats a 12-second cycle:

- Seconds 0 to 4: `Green`
- Seconds 5 and 6: `Amber`
- Seconds 7 to 11: `Red`

After second 11 the cycle starts again at second 0. Write a program that inputs the number of seconds `t` since the simulation started (a non-negative integer) and outputs the colour of the light at that moment.

For example, at `t` = 30 the light is `Amber`.

Traffic Light Simulation

Simulate a vending machine that sells 3 items: item 1 costs 100, item 2 costs 150 and item 3 costs 200 (in pence).

**Step 1:** Input the item number. If it is not 1, 2 or 3, output `Invalid item` and stop.

**Step 2:** Repeatedly input coins until the total inserted is **at least** the price. Only coins of 10, 20, 50 and 100 are accepted. For any other coin value, output `Invalid coin` and ignore it (it does not count towards the total).

**Step 3:** Once enough money has been inserted, output three lines: `Dispensed`, then the change due (total inserted minus price), then the number of valid coins that were inserted.

For example, the inputs 1, 50, 50 produce `Dispensed`, `0` and `2` (one per line).

Vending Machine Simulation

A website requires usernames to be between 4 and 12 characters long (inclusive).

Write a program that inputs a username and outputs:

- `Too short` if it has fewer than 4 characters
- `Too long` if it has more than 12 characters
- `Valid` otherwise

Username Length Check

Run-length encoding compresses a string by replacing each run of identical consecutive characters with the character and the length of the run.

Write a program that inputs a non-empty string of lowercase letters. For each run, in order, output the character on one line and the run length on the next line.

For example, `aaabbc` has runs of 3 `a`s, 2 `b`s and 1 `c`, so the output is:

```
a
3
b
2
c
1
```

Run-Length Encoding

Write a function `Area(width, height)` that **returns** the area of a rectangle (width multiplied by height).

Then write a main program that inputs a width and a height (both integers), calls your function, and outputs the value it returns.

Rectangle Area Function

Write a program that inputs 5 integers into an array and checks whether they are in **ascending order** (each value is less than or equal to the value after it).

Output `Sorted` if they are in ascending order, otherwise output `Not Sorted`.

Is the Array Sorted?

Write a program that inputs 6 **different** integers into an array and outputs the second largest value.

Do not sort the array: find the answer by keeping track of the largest and second largest values as you traverse it once.

For example, the values 4, 9, 2, 7, 5, 1 have a largest value of 9 and a second largest value of 7.

Second Largest Value

Write a function `IsLeap(year)` that returns `TRUE` if the year is a leap year and `FALSE` otherwise. A year is a leap year if it is divisible by 400, or divisible by 4 but not by 100.

Then write a main program that inputs a start year and an end year (the start year is never later than the end year), uses your function to count how many leap years there are from the start year to the end year **inclusive**, and outputs the count.

For example, between 2000 and 2024 there are 7 leap years.

Count Leap Years

Write a program that inputs 5 integers into an array, then inputs a whole number `k` (0 to 5). Rotate the array to the **right** by `k` positions, so that each value moves `k` places to the right and values that fall off the end wrap round to the start.

Output the rotated array, one value per line.

For example, rotating 1 2 3 4 5 right by 1 gives 5 1 2 3 4.

Practice Questions

All Modules

Linear Search

Greet the User

Find Maximum of 5 Numbers

Reverse a String

Nth Fibonacci Number

Count Vowels

Library Fine Calculator

Shopping Cart Total

Leap Year Checker

.css-1lnp26r{font-family:'Montserrat',sans-serif;position:relative;}Practice .css-1v0lc0l{color:var(--chakra-colors-blue-500);}Questions

All Modules

Linear Search

Greet the User

Find Maximum of 5 Numbers

Reverse a String

Nth Fibonacci Number

Count Vowels

Library Fine Calculator

Shopping Cart Total

Leap Year Checker

Practice Questions