The 1D array EmployeeID[] contains the identification numbers of employees in a
company. The 2D array EmployeeSalary[] contains the salary for each employee
in different departments, for each employee. The position of each employee's
data in the two arrays is the same, for example, the employee in position 6 in
EmployeeID[] and EmployeeSalary[] is the same.
The variable EmployeeNo contains the number of employees in the company. The
variable DepartmentNo contains the number of departments in the company. All
employees work in the same number of departments.
The arrays and variables have already been set up and the data stored.
Employees are awarded a bonus based on their average salary.
Average salary Bonus awarded greater than or equal to $75,000 $1,000 greater
than or equal to $50,000 and less than $75,000 $500 less than $50,000 no bonus
Write a program that meets the following requirements:
● calculates the total salary for each employee in all their
departments
● calculates the average salary for each employee in all their
departments, rounded to the nearest whole number
● outputs for each employee:
● identification number
● total salary
● average salary
● bonus awarded
● calculates, stores and outputs the total bonus awarded to all
employees in the company.
You must use pseudocode or program code and add comments to explain how
your code works. You do not need to initialize the data in the array.
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE TotalSalary : ARRAY[1:50] OF INTEGER
DECLARE AverageSalary : ARRAY[1:50] OF INTEGER
DECLARE Bonus : ARRAY[1:50] OF INTEGER
DECLARE DepartmentCounter : INTEGER
DECLARE EmployeeCounter : INTEGER
DECLARE TotalBonus : INTEGER
CONSTANT Bonus1000 = 1000
CONSTANT Bonus500 = 500
CONSTANT Salary75000 = 75000
CONSTANT Salary50000 = 50000
// initialisation processes for this scenario, initialising the running totals used for
// bonuses and combined salaries
TotalBonus ← 0
FOR EmployeeCounter ← 1 to EmployeeNo
TotalSalary[EmployeeCounter] ← 0
FOR DepartmentCounter ← 1 to DepartmentNo
TotalSalary[EmployeeCounter] = TotalSalary[EmployeeCounter] +
EmployeeSalary[EmployeeCounter, DepartmentCounter]
NEXT DepartmentCounter
AverageSalary[EmployeeCounter] =
ROUND(TotalSalary[EmployeeCounter]/DepartmentNo)
// calculate and output employee's information
OUTPUT "Employee ID: " + EmployeeID[EmployeeCounter]
OUTPUT "Total salary: $" + TotalSalary[EmployeeCounter]
OUTPUT "Average salary: $" + AverageSalary[EmployeeCounter]
IF AverageSalary[EmployeeCounter] >= Salary75000
Bonus[EmployeeCounter] = Bonus1000
OUTPUT "Bonus awarded: $" + Bonus[EmployeeCounter]
TotalBonus = TotalBonus + Bonus[EmployeeCounter]
ELSE IF AverageSalary[EmployeeCounter] >= Salary50000
Bonus[EmployeeCounter] = Bonus500
OUTPUT "Bonus awarded: $" + Bonus[EmployeeCounter]
TotalBonus = TotalBonus + Bonus[EmployeeCounter]
ELSE
OUTPUT "No bonus awarded"
END IF
NEXT EmployeeCounter
// output the total bonus awarded to all employees
OUTPUT "Total bonus awarded: $" + TotalBonus
The 1D array ProductID[] contains the identification numbers of products in a store.
The 2D array ProductPrice[] contains the price for each product in different colors, for
each product. The position of each product's data in the two arrays is the same, for
example, the product in position 3 in ProductID[] and ProductPrice[] is the same.
The variable ProductNo contains the number of products in the store. The variable
ColorNo contains the number of colors available for each product. All products have
the same number of colors available.
The arrays and variables have already been set up and the data stored.
A discount is applied to the products based on their average price.
Average price Discount applied greater than or equal to 50 10% greater than or
equal to 30 and less than 50 5% less than 30 no discount
Write a program that meets the following requirements:
● calculates the combined total price for each product in all its colors
● calculates the average price for each product in all its colors, rounded
to the nearest whole number
● outputs for each product:
● identification number
● combined total price
● average price
● discount applied
● calculates, stores and outputs the total discount applied to all products
in the store.
You must use pseudocode or program code and add comments to explain how your
code works. You do not need to initialize the data in the array
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE TotalPrice : ARRAY[1:50] OF INTEGER
DECLARE AveragePrice : ARRAY[1:50] OF INTEGER
DECLARE ColorCounter : INTEGER
DECLARE ProductCounter : INTEGER
DECLARE TotalDiscount : INTEGER
CONSTANT Discount10 = 10
CONSTANT Discount5 = 5
// initialisation processes for this scenario, initialising the running totals used for
// discount and combined totals
TotalDiscount ← 0
FOR ProductCounter ← 1 to ProductNo
TotalPrice[ProductCounter] ← 0
FOR ColorCounter ← 1 to ColorNo
TotalPrice[ProductCounter] = TotalPrice[ProductCounter] + ProductPrice[ProductCounter,
ColorCounter]
NEXT ColorCounter
AveragePrice[ProductCounter] = ROUND(TotalPrice[ProductCounter]/ColorNo)
// calculate and output product's information
OUTPUT "Product ID: " + ProductID[ProductCounter]
OUTPUT "Combined total price: " + TotalPrice[ProductCounter]
OUTPUT "Average price: " + AveragePrice[ProductCounter]
// calculate and output product's discount
IF AveragePrice[ProductCounter] >= 50
OUTPUT "Discount applied: 10%"
TotalDiscount = TotalDiscount + TotalPrice[ProductCounter] * Discount10 / 100
ELSE IF AveragePrice[ProductCounter] >= 30 AND AveragePrice[ProductCounter] < 50
OUTPUT "Discount applied: 5%"
TotalDiscount = TotalDiscount + TotalPrice[ProductCounter] * Discount5 / 100
ELSE
OUTPUT "No discount applied"
END IF
NEXT ProductCounter
// output the total discount applied to all products in the store
OUTPUT "Total discount applied: " + TotalDiscount
The 1D array CustomerID[] contains the identification numbers of customers in a
store. The 2D array CustomerPurchase[] contains the amount of money spent by
each customer on each purchase, for each customer. The position of each
customer's data in the two arrays is the same, for example, the customer in position
2 in CustomerID[] and CustomerPurchase[] is the same.
The variable CustomerNo contains the number of customers in the store. The
variable PurchaseNo contains the number of purchases made by each customer. All
customers make the same number of purchases.
The arrays and variables have already been set up and the data stored.
Customers are awarded a discount on their next purchase based on the total amount
of money they spent.
Total spent Discount applied greater than or equal to 100 10% greater than or equal
to 50 and less than 100 5% less than 50 no discount
Write a program that meets the following requirements:
● calculates the total amount of money spent by each customer on all
their purchases
● outputs for each customer:
● identification number
● total amount spent
● discount applied on the next purchase
● calculates, stores and outputs the total discount applied to all
customers in the store.
You must use pseudocode or program code and add comments to explain how your
code works. You do not need to initialize the data in the array.
Solution
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE TotalSpent : ARRAY[1:50] OF INTEGER
DECLARE Discount : ARRAY[1:50] OF INTEGER
DECLARE PurchaseCounter : INTEGER
DECLARE CustomerCounter : INTEGER
DECLARE TotalDiscount : INTEGER
CONSTANT Discount10 = 10
CONSTANT Discount5 = 5
// initialisation processes for this scenario, initialising the running totals used for
// discount and combined totals
TotalDiscount ← 0
FOR CustomerCounter ← 1 to CustomerNo
TotalSpent[CustomerCounter] ← 0
FOR PurchaseCounter ← 1 to PurchaseNo
TotalSpent[CustomerCounter] = TotalSpent[CustomerCounter] +
CustomerPurchase[CustomerCounter, PurchaseCounter]
NEXT PurchaseCounter
// calculate and output customer's information
OUTPUT "Customer ID: " + CustomerID[CustomerCounter]
OUTPUT "Total amount spent: " + TotalSpent[CustomerCounter]
// calculate and output customer's discount
IF TotalSpent[CustomerCounter] >= 100
OUTPUT "Discount applied on next purchase: 10%"
Discount[CustomerCounter] = Discount10
TotalDiscount = TotalDiscount + TotalSpent[CustomerCounter] * Discount10 / 100
ELSE IF TotalSpent[CustomerCounter] >= 50 AND TotalSpent[CustomerCounter] < 100
OUTPUT "Discount applied on next purchase: 5%"
Discount[CustomerCounter] = Discount5
TotalDiscount = TotalDiscount + TotalSpent[CustomerCounter] * Discount5 / 100
ELSE
OUTPUT "No discount applied on next purchase"
Discount[CustomerCounter] = 0
END IF
NEXT CustomerCounter
//
The 1D array StudentID[] contains the identification numbers of students in a class.
The 2D array StudentAssignment[] contains the score for each assignment, for each
student. The position of each student's data in the two arrays is the same, for
example, the student in position 4 in StudentID[] and StudentAssignment[] is the
same.
The variable StudentNo contains the number of students in the class. The variable
AssignmentNo contains the number of assignments given to each student. All
students receive the same number of assignments.
The arrays and variables have already been set up and the data stored.
Students are awarded a bonus mark based on their average score.
Average score Bonus mark awarded greater than or equal to 80 2 greater than or
equal to 60 and less than 80 1 less than 60 0
Write a program that meets the following requirements:
● calculates the total score for each student on all their assignments
● calculates the average score for each student on all their assignments,
rounded to the nearest whole number
● outputs for each student:
● identification number
● total score
● average score
● bonus mark awarded
● calculates, stores and outputs the total bonus marks awarded to all
students in the class.
You must use pseudocode or program code and add comments to explain how your
code works. You do not need to initialize the data in the array.
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE TotalScore : ARRAY[1:50] OF INTEGER
DECLARE AverageScore : ARRAY[1:50] OF INTEGER
DECLARE BonusMark : ARRAY[1:50] OF INTEGER
DECLARE AssignmentCounter : INTEGER
DECLARE StudentCounter : INTEGER
DECLARE TotalBonusMark : INTEGER
The 1D array DriverID[] contains the identification numbers of drivers in a city. The
2D array DriverSpeed[] contains the speed of each driver on each road, for each
driver. The position of each driver's data in the two arrays is the same, for example,
the driver in position 3 in DriverID[] and DriverSpeed[] is the same.
The variable DriverNo contains the number of drivers in the city. The variable RoadNo
contains the number of roads on which each driver was monitored. All drivers were
monitored on the same number of roads.
The arrays and variables have already been set up and the data stored.
Drivers are fined based on their maximum speed on any road.
Maximum speed Fine applied greater than or equal to 120 100 greater than or equal
to 100 and less than 120 50 less than 100 no fine
Write a program that meets the following requirements:
● calculates the maximum speed of each driver on all roads
● outputs for each driver:
● identification number
● maximum speed
● fine applied
● calculates, stores and outputs the total fines applied to all drivers in the
city.
You must use pseudocode or program code and add comments to explain how your
code works. You do not need to initialize the data in the array
Question 3
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE Speed : ARRAY[1:50] OF INTEGER
DECLARE Fine : ARRAY[1:50] OF INTEGER
DECLARE VehicleCounter : INTEGER
DECLARE TotalFine : INTEGER
CONSTANT Fine10 = 10
CONSTANT Fine5 = 5
// initialisation processes for this scenario, initialising the running totals used for
// fines
TotalFine ← 0
FOR VehicleCounter ← 1 to VehicleNo
// calculate and output vehicle's speed and fine
OUTPUT "Vehicle " + VehicleCounter + " speed: " + Speed[VehicleCounter] + " mph"
IF Speed[VehicleCounter] > SpeedLimit
Fine[VehicleCounter] = IF Speed[VehicleCounter] > SpeedLimit + 10 THEN Fine10 ELSE
Fine5
OUTPUT "Fine applied: $" + Fine[VehicleCounter]
TotalFine = TotalFine + Fine[VehicleCounter]
ELSE
OUTPUT "No fine applied"
END IF
NEXT VehicleCounter
// output the total fine applied to all vehicles
OUTPUT "Total fine applied: $" + TotalFine
The 1D array CustomerID[] contains the identification numbers of customers in a
store. The 2D array CustomerOrder[] contains the number of items ordered for each
customer in different categories, for each customer. The position of each customer's
data in the two arrays is the same, for example, the customer in position 7 in
CustomerID[] and CustomerOrder[] is the same.
The variable CustomerNo contains the number of customers in the store. The variable
CategoryNo contains the number of categories of items in the store. All customers
order items from the same number of categories.
The arrays and variables have already been set up and the data stored.
Customers are awarded a discount based on the total number of items they ordered.
Total number of items ordered Discount applied
greater than or equal to 50 10%
greater than or equal to 30 and less than 50 5%
less than 30 no discount
Write a program that meets the following requirements:
● calculates the total number of items ordered for each customer in all
categories
● outputs for each customer:
○ identification number
○ total number of items ordered
○ discount applied
● calculates, stores and outputs the total discount applied to all customers in
the store.
You must use pseudocode or program code and add comments to explain how your
code works.
You do not need to initialize the data in the array
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE TotalItems : ARRAY[1:50] OF INTEGER
DECLARE Discount : ARRAY[1:50] OF INTEGER
DECLARE CategoryCounter : INTEGER
DECLARE CustomerCounter : INTEGER
DECLARE TotalDiscount : INTEGER
CONSTANT Discount10 = 10
CONSTANT Discount5 = 5
// initialisation processes for this scenario, initialising the running totals used for
// discounts
TotalDiscount ← 0
FOR CustomerCounter ← 1 to CustomerNo
TotalItems[CustomerCounter] ← 0
FOR CategoryCounter ← 1 to CategoryNo
TotalItems[CustomerCounter] = TotalItems[CustomerCounter] +
CustomerOrder[CustomerCounter, CategoryCounter]
NEXT CategoryCounter
// calculate and output customer's information
OUTPUT "Customer ID: " + CustomerID[CustomerCounter]
OUTPUT "Total items ordered: " + TotalItems[CustomerCounter]
IF TotalItems[CustomerCounter] >= 50
Discount[CustomerCounter] = Discount10
OUTPUT "Discount applied: " + Discount[CustomerCounter] + "%"
Question 7
The 1D array CountryID[] contains the identification numbers of countries in the world.
The 2D array CountryPopulation[] contains the population for each country in different
age groups, for each country. The position of each country's data in the two arrays is
the same, for example, the country in position 9 in CountryID[] and CountryPopulation[] is
the same.
The variable CountryNo contains the number of countries in the world. The variable
AgeGroupNo contains the number of age groups in each country. All countries have
the same number of age groups.
The arrays and variables have already been set up and the data stored.
Countries are ranked based on the total population in each age group.
Write a program that meets the following requirements:
● calculates the total population for each country in all age groups
● outputs for each country:
○ identification number
○ total population
○ rank
● calculates, stores and outputs the average rank of all countries in the world.
You must use pseudocode or program code and add comments to explain how your
code works.
You do not need to initialize the data in the array.
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE TotalPopulation : ARRAY[1:50] OF INTEGER
DECLARE Rank : ARRAY[1:50] OF INTEGER
DECLARE AgeGroupCounter : INTEGER
DECLARE CountryCounter : INTEGER
DECLARE TotalRank : INTEGER
// initialisation processes for this scenario, initialising the running totals used for
// ranking
TotalRank ← 0
FOR CountryCounter ← 1 to CountryNo
TotalPopulation[CountryCounter] ← 0
FOR AgeGroupCounter ← 1 to AgeGroupNo
TotalPopulation[CountryCounter] = TotalPopulation[CountryCounter] +
CountryPopulation[CountryCounter, AgeGroupCounter]
NEXT AgeGroupCounter
// calculate and output country's information
OUTPUT "Country ID: " + CountryID[CountryCounter]
OUTPUT "Total population: " + TotalPopulation[CountryCounter]
Rank[CountryCounter] = RANK(TotalPopulation[CountryCounter])
OUTPUT "Rank: " + Rank[CountryCounter]
TotalRank = TotalRank + Rank[CountryCounter]
NEXT CountryCounter
Question 8
The 1D array AnimalID[] contains the identification numbers of animals in a zoo. The
2D array AnimalWeight[] contains the weight for each animal in different months, for
each animal. The position of each animal's data in the two arrays is the same, for
example, the animal in position 11 in AnimalID[] and AnimalWeight[] is the same.
The variable AnimalNo contains the number of animals in the zoo. The variable
MonthNo contains the number of months in a year. All animals have their weight
measured in the same number of months.
The arrays and variables have already been set up and the data stored.
Animals are monitored for their weight changes over the year. A warning is issued if
an animal's weight changes by more than 10% in any month.
Write a program that meets the following requirements:
● calculates the average weight for each animal in all months
● outputs for each animal:
○ identification number
○ average weight
○ warning issued (yes/no)
● calculates, stores and outputs the total number of warnings issued for all
animals in the zoo.
You must use pseudocode or program code and add comments to explain how your
code works.
You do not need to initialize the data in the array
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE AverageWeight : ARRAY[1:50] OF INTEGER
DECLARE Warning : ARRAY[1:50] OF STRING
DECLARE MonthCounter : INTEGER
DECLARE AnimalCounter : INTEGER
DECLARE TotalWarnings : INTEGER
CONSTANT WarningThreshold = 10
// initialisation processes for this scenario, initialising the running totals used for
// warnings
TotalWarnings ← 0
FOR AnimalCounter ← 1 to AnimalNo
AverageWeight[AnimalCounter] ← 0
FOR MonthCounter ← 1 to MonthNo
AverageWeight[AnimalCounter] = AverageWeight[AnimalCounter] +
AnimalWeight[AnimalCounter, MonthCounter]
NEXT MonthCounter
AverageWeight[AnimalCounter] = ROUND(AverageWeight[AnimalCounter]/MonthNo)
// calculate and output animal's information
OUTPUT "Animal ID: " + AnimalID[AnimalCounter]
OUTPUT "Average weight: " + AverageWeight[AnimalCounter]
Warning[AnimalCounter] = "no"
FOR MonthCounter ← 1 to MonthNo
IF ABS(AnimalWeight[AnimalCounter, MonthCounter] -
AverageWeight[AnimalCounter])/AverageWeight[AnimalCounter] > WarningThreshold/100
Warning[AnimalCounter] = "yes"
NEXT MonthCounter
OUTPUT "Warning issued: " + Warning[AnimalCounter]
TotalWarnings = TotalWarnings + Warning[AnimalCounter]
NEXT AnimalCounter
// output the total number of warnings issued for all animals
OUTPUT "Total warnings issued: " + TotalWarnings
Question 9
The 1D array PlayerID[] contains the identification numbers of players in a sports
team. The 2D array PlayerScore[] contains the score for each player in different games,
for each player. The position of each player's data in the two arrays is the same, for
example, the player in position 13 in PlayerID[] and PlayerScore[] is the same.
The variable PlayerNo contains the number of players in the sports team. The variable
GameNo contains the number of games played in a season. All players have their
score recorded in the same number of games.
The arrays and variables have already been set up and the data stored.
Players are awarded points based on their average score in each game.
Average score Points awarded
greater than or equal to 10 3
greater than or equal to 7 and less than 10 2
less than 7 1
Write a program that meets the following requirements:
● calculates the average score for each player in all games
● outputs for each player:
○ identification number
○ average score
○ points awarded
● calculates, stores and outputs the total points awarded to all players in the
sports team.
You must use pseudocode or program code and add comments to explain how your
code works.
You do not need to initialize the data in the arra
// meaningful identifier names and appropriate data structures (variables, constants and the
// given arrays) to store all the data required
DECLARE AverageScore : ARRAY[1:50] OF INTEGER
DECLARE Points : ARRAY[1:50] OF INTEGER
DECLARE GameCounter : INTEGER
DECLARE PlayerCounter : INTEGER
DECLARE TotalPoints : INTEGER
CONSTANT Points3 = 3
CONSTANT Points2 = 2
CONSTANT Points1 = 1
// initialisation processes for this scenario, initialising the running totals used for
// points
TotalPoints ← 0
FOR PlayerCounter ← 1 to PlayerNo
AverageScore[PlayerCounter] ← 0
FOR GameCounter ← 1 to GameNo
AverageScore[PlayerCounter] = AverageScore[PlayerCounter] +
PlayerScore[PlayerCounter, GameCounter]
NEXT GameCounter
AverageScore[PlayerCounter] = ROUND(AverageScore[PlayerCounter]/GameNo)
// calculate and output player's information
OUTPUT "Player ID: " + PlayerID[PlayerCounter]
OUTPUT "Average score: " + AverageScore[PlayerCounter]
IF AverageScore[PlayerCounter] >= 10
Points[PlayerCounter] = Points3
ELSE IF AverageScore[PlayerCounter] >= 7
Points[PlayerCounter] = Points2
ELSE
Points[PlayerCounter] = Points1
OUTPUT "Points awarded: " + Points[PlayerCounter]
TotalPoints = TotalPoints + Points[PlayerCounter]
NEXT PlayerCounter
// output the total points awarded to all players
OUTPUT "Total points awarded: " + TotalPoints
