Higher Nationals - Summative Assignment Feedback

Form
Student Name/ID Patkunam Sheshanthan
Unit Title Unit 01 – Programming
Assignment 1 Assessor
Number
Date
Submission Date Received
1st
submission
Date Received
Re-submission 2nd submission
Date

Assessor Feedback:

Grade: Assessor Signature: Date:

Resubmission Feedback:

Grade: Assessor Signature: Date:

Internal Verifier’s Comments:

Signature & Date:

 Please note that grade decisions are provisional. They are only confirmed once
internal and external moderation has taken place and grades decisions have
been agreed at the assessment board.

BTEC HN Summative Assignment Feedback Form

Issue Date: June 2021 Owner: HN QD
DCL1 Public (Unclassified) Version 1.0 Page |i
Important Points:

1. It is strictly prohibited to use textboxes to add texts in the assignments,

except for the compulsory information. eg: Figures, tables of comparison
etc. Adding text boxes in the body except for the before mentioned
compulsory information will result in rejection of your work.
2. Avoid using page borders in your assignment body.
3. Carefully check the hand in date and the instructions given in the
assignment. Late submissions will not be accepted.
4. Ensure that you give yourself enough time to complete the assignment by
the due date.
5. Excuses of any nature will not be accepted for failure to hand in the work
on time.
6. You must take responsibility for managing your own time effectively.
7. If you are unable to hand in your assignment on time and have valid
reasons such as illness, you may apply (in writing) for an extension.
8. Failure to achieve at least PASS criteria will result in a REFERRAL grade.
9. Non-submission of work without valid reasons will lead to an automatic RE
FERRAL. You will then be asked to complete an alternative assignment.
[Link] you use other people’s work or ideas in your assignment, reference
them properly using HARVARD referencing system to avoid plagiarism.
You have to provide both in-text citation and a reference list.
11. If you are proven to be guilty of plagiarism or any academic misconduct,
your grade could be reduced to A REFERRAL or at worst you could be
expelled from the course
[Link] word processing application spell check and grammar check function
to help editing your assignment.
[Link] footer function in the word processor to insert Your Name,
Subject, Assignment No, and Page Number on each page. This is
useful if individual sheets become detached for any reason.

P a g e | ii
 STUDENT ASSESSMENT SUBMISSION AND DECLARATION
When submitting evidence for assessment, each student must sign a declaration
confirming that the work is their own.
Student name: Assessor name:

Issue date: Submission date: Submitted on:

Programme: Pearson BTEC HND in Computing

Unit: Unit 01 – Programming

Assignment number and title:
1- Training Fee Calculation System for KickBlast Judo.
Plagiarism

Plagiarism is a particular form of cheating. Plagiarism must be avoided at all costs and
students who break the rules, however innocently, may be penalised. It is your
responsibility to ensure that you understand correct referencing practices. As a
university level student, you are expected to use appropriate references throughout and
keep carefully detailed notes of all your sources of materials for material you have used
in your work, including any material downloaded from the Internet. Please consult the
relevant unit lecturer or your course tutor if you need any further advice.

Guidelines for incorporating AI-generated content into assignments:

The use of AI-generated tools to enhance intellectual development is permitted;
nevertheless, submitted work must be original. It is not acceptable to pass off AI-generated
work as your own.
Student Declaration
Student declaration
I certify that the assignment submission is entirely my own work and I fully understand
the consequences of plagiarism. I understand that making a false declaration is a form of
malpractice.

Student signature: Date:

P a g e | iii
Unit 01: Programming
Assignment Brief

Student Name/ID
Number

Unit Number and Unit 01 – Programming

Title

Academic Year 2024/2025

Unit Tutor

Assignment Title Training Fee Calculation System for KickBlast Judo.

Issue Date

Submission Date

Submission Format
The assignment submission is in the form of the following.
 An individual written report written in a concise, formal technical style
using single spacing and font size 12. Include all necessary screenshots
of your coding and screenshots of the developed application as
evidence. Referencing should be done using the Harvard Referencing
system.
 All the source code files, Complete GUI System with the database.

Submit all above in a one single .zip file to the submission portal.

Unit Learning Outcomes

LO1. Define basic algorithms to carry out an operation and outline the process of
programming an application.

LO2. Explain the characteristics of procedural, object-orientated and event-driven

programming.

LO3. Implement basic algorithms in code using an IDE.

LO4. Determine the debugging process and explain the importance of a coding standard

P a g e | iv
Computing-related cognitive skills :
 Demonstrate knowledge and understanding of essential facts,
concepts, principles and
theories relating to computing and computer applications
 Use such knowledge and understanding in the modelling and
design of computer-based
systems for the purposes of comprehension, communication,
prediction and the
understanding of trade-offs
 Recognise and analyse criteria and specifications appropriate to
specific problems, and
plan strategies for their solutions
 Critical evaluation and testing: analyse the extent to which a
computer-based system
meets the criteria defined for its current use and future
development
 Methods and tools: deploy appropriate theory, practices and tools
for the design,
implementation and evaluation of computer-based systems.

Computing-related practical skills :

 The ability to specify, design and construct reliable, secure and
usable computer-based
systems
 The ability to evaluate systems in terms of quality attributes and
possible trade-offs
presented within the given problem
 The ability to deploy effectively the tools used for the construction
and documentation
of computer applications, with particular emphasis on
understanding the whole process
involved in the effective deployment of computers to solve
practical problems
 The ability to critically evaluate and analyse complex problems,
including those with
incomplete information, and devise appropriate solutions, within
the constraints of a
budget.

Generic skills for employability:

 Intellectual skills: critical thinking; making a case; numeracy and
literacy
 Self-management: self-awareness and reflection; goal setting and
action planning
 Independence and adaptability; acting on initiative; innovation and
creativity
 Contextual awareness, e.g. the ability to understand and meet the
needs of individuals,

Page |v
 business and the community, and to understand how workplaces
and organisations are
governed.

Assignment Brief and Guidance:

Activity 1

A. The Fibonacci numbers are the numbers in the following integer sequence.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ……..

In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the recurrence

relation.

Fn = F n-1 + F n-2

B. Factorial of a non-negative integer, is multiplication of all integers smaller than or equal

to n. For example, factorial of 6 is 6*5*4*3*2*1 which is 720.

n! = n * (n - 1) * …….. 1

Define what an algorithm is and outline the characteristics of a good algorithm. Write the
algorithms to display the Fibonacci series and the factorial value for a given number using

P a g e | vi
 Pseudo code. Determine the steps involved in the process of writing and executing a
program and carry out an analysis of writing the code phase by discussing the potential
challenges faced.
Take a sample number and dry run the above two algorithms. Show the outputs at the end
of each iteration and the final output. Examine what Big-O notation is and explain its role in
evaluating efficiencies of algorithms. Write the Python program code for the above two
algorithms and critically evaluate their efficiencies using Big-O notation.

Activity 2

Compare and discuss what is meant by a Programming Paradigm and the main
characteristics of Procedural, Object oriented and Event-driven paradigms and the
relationships among them. Write small snippets of code as example for the above three
programming paradigms using a suitable programming language(s) and critically
evaluate the code samples that you have given above in relation to their structure and
the unique characteristics.

Activity 3 and Activity 4 are based on the following Scenario.

You have just started a new role as a Junior Software Developer at CUBE-GEN Software
Solutions an independent software development company that designs and builds bespoke
software solutions for various companies of different sizes that cover a range of different
industries. The software that they design uses a wide range of technologies, from simple stand-
alone programs to large web-based applications.
CUBE-GEN Software Solutions has been approached by a small, local company – KickBlast
Judo – that specialises in providing judo training sessions to people from the local community.
KickBlast Judo caters to people of all ages and experience, from expert to beginner.
KickBlast Judo has requested a simple program that will calculate the cost of training fees for
their athletes each month.
The Chief Executive Officer (CEO) of the company has reviewed the client requirements and
has determined that this is a suitable project for you to take on. The company wants to see how
you use and apply the CUBE-GEN Software development environments and code standards.
The requirements are that KickBlast Judo wants a program that will allow a user to enter the

P a g e | vii
following information:
● athlete name
● training plan
● current weight in kilograms (kg)
● competition weight category
● number of competitions entered this month
● option to add the number of hours private coaching.
For each athlete, the program should then output the following information:
● the athlete’s name
● an itemised list of all costs for the month
● the total cost of training and competitions for the month
● how their current weight compares to their competition weight category.
KickBlast Judo currently have six athletes enrolled on their training program, but they would
like the ability to register more.
You should use the additional information on the next page to help you when developing your
program.
The CEO has instructed you to develop a GUI application for the KickBlast Judo.
Once the program has been built, the CEO has asked you to report back to them on how you
designed and developed the algorithms required, as well as how you converted these algorithms
into a final program and to show any issues you encountered.

P a g e | viii
Additional information

● Athletes can receive a maximum of five hours’ private coaching a week

● Only Intermediate and Elite athletes can enter competitions
● Competitions are held on the second Saturday of each month
● All prices and costs should be displayed as currency to two decimal places
● The program deals with user error by displaying suitable messages to the user and then
prompting them for another go
● KickBlast Judo assumes that a month consists of four weeks.

Activity 3

Write the complete pseudocode to calculate the cost of training fees for KickBlast
athletes for each month. Use the visual studio IDE (using C#.net) to implement the above

P a g e | ix
 algorithms. The developer can decide the methods which need to be included when
developing the classes. Design the suitable database structure for keeping the data of the
above system.
Analyze the features of an Integrated Development Environment (IDE) and explain how
those features help in application development. Evaluate the use of the Visual StudioIDE
for your application development contrasted with not using an IDE.
Activity 4
2.1 Design and build a small GUI system for the above scenario and the application should be a
complete functional system with all the functions which has described in the above scenario
with the database structure which has designed in activity 3.
2.2 Examine debugging process and the features available in Visual studio IDE for debugging
your code more easily. Evaluate how you used the debugging process to develop more
secure, robust application with examples.
2.3 Explain and outline the coding standards you have used in your application development.
Critically evaluate why a coding standard is necessary for the team as well as for the
individual.

Reading:
Aho, A. V. et al. (1987) Data Structures and Algorithms. 1st Ed. Addison-Wesley. Hunt,
A. et al. (2000) The Pragmatic Programmer: From Journeyman to Master. 1st Ed.

Addison-Wesley. McConnell, S. (2004) Code Complete: A Practical Handbook of

Software Construction. 2nd Ed. Microsoft Press.

HN Global:
HN Global HN Global (2021) Reading Lists. Available at:
[Link]

HN Global (2021) Student Resource Library. Available at:

[Link]

Page |x
 HN Global (2021) Textbooks. Available at:
[Link]

P a g e | xi
P a g e | xii
 Unit 1:
Programming

[Link]
E281445
SE/26 & NE/27
ESOFT Metro Campus – Batticaloa
Acknowledgment

I would like to express my sincere gratitude to all those who supported me to complete
this Programming assignment successfully.

I am especially thankful to my lecturer [Link] Rikaz sir for their valuable

guidance, support, and encouragement throughout this work. Their expertise in
programming concepts has been great help in understanding and completing this
assignment. I am also thankful to my classmates and friends for their helpful insights and
cooperation.

Finally, I extend my heartfelt appreciation to my family for their constant support and
motivation.

Regards,

[Link]

Page | ii
[Link] PRO
Table of Contents
Assessor Feedback:...................................................................................................i
 Please note resubmission feedback is focussed only on the resubmitted work................i
Unit Number and Title........................................................................................iv
Unit 01 – Programming......................................................................................iv
Assignment Title..................................................................................................iv
Training Fee Calculation System for KickBlast Judo...................................................iv
Issue Date.............................................................................................................. iv
Submission Format.............................................................................................iv
Unit Learning Outcomes...................................................................................iv
Acknowledgment................................................................................................................ii
List of Table........................................................................................................................iv
List of Figure....................................................................................................................... v
Activity -1............................................................................................................................1
1.1. Introduction..................................................................................................... 1
1.1. Algorithm.............................................................................................................3
1.2. Characteristics of a good algorithm.....................................................................4
1.2.1. Well-defined Inputs..........................................................................................4
1.2.2. Well-defined Outputs.......................................................................................4
1.2.3. Unambiguity..................................................................................................... 4
1.2.4. Finiteness..........................................................................................................4
1.2.5. Language Independent.....................................................................................5
1.2.6. Effectiveness and Feasibility.............................................................................5
1.3. Pseudo code........................................................................................................ 6
1.3.1. Pseudo Code for Fibonacci Series.....................................................................7
1.3.2. Pseudo code for factorial series......................................................................10
1.4. Steps Involved in Writing and Executing a Program..........................................13
1.4.1. Problem Analysis.............................................................................................13
1.4.2. Program Design...............................................................................................13
1.4.3. Coding.............................................................................................................13
1.4.4. Testing and debugging....................................................................................14
1.4.5. Compilation and Execution.............................................................................14
1.4.6. Maintenance...................................................................................................14
1.5. The potential challenges faced..........................................................................15
1.6. Flow Chart..........................................................................................................16

Page | iii
[Link] PRO
 1.7. Dry run Table..................................................................................................... 17
1.7.1. Dry Run Table for Fibonacci Series..................................................................18
References................................................................................................................32

Page | iv
[Link] PRO
List of Table
Table 1: Dry Run Table for Fibonacci 21

Page | v
[Link] PRO
List of Figure
Figure 1: Algorithm 2
Figure 2: Characteristics of a good algorithm 4
Figure 3: Pseudo Code Image 5
Figure 4: Pseudo code for Fibonacci 6
Figure 5: Pseudo code for factorial series 9
Figure 6: Flow Chart Image 15
Figure 7: Flow chart for Fibonacci 16
Figure 8: Flow chart for factorial series 18
Figure 9 : Dry Run Table 20
Figure 10: Big O notation image 28

Page | vi
[Link] PRO
Introduction
This assignment focuses on developing a strong understanding of fundamental
programming concepts, algorithm design, and software development practices using both
console-based and graphical user interface GUI programming. It aims to demonstrate how
theoretical knowledge of algorithms, programming paradigms, and software development
life cycle phases can be effectively applied to practical problem-solving and real-world
application design.

The focus is on understanding and implementing algorithms for basic computational

problems such as generating the Fibonacci series and calculating factorial values. This
section explores the process of algorithm design using pseudo code, dry-run analysis,
program implementation in Python, and the evaluation of algorithm efficiency using Big-
O notation. The activity also discusses the key phases in writing and executing a program,
along with the challenges encountered during the coding phase.

Explores the concept of programming paradigms, including procedural, object-oriented,

and event-driven programming. It compares their characteristics, code structures, and
unique features through example code snippets, providing a critical evaluation of how
each paradigm supports different software development approaches.

The assignment focuses on applying these principles in a practical context through the
Kick Blast Judo scenario. As a junior software developer at cube Gen Software Solutions,
the task is to design and develop a GUI-based application that calculates monthly training
fees for athletes based on their selected plans, competition entries, and private coaching
hours. The activities include designing pseudo code algorithms, implementing them using
Visual Studio IDE with C#, and developing a suitable database structure to manage
athlete data effectively.

Additionally, the later sections examine the features of an Integrated Development

Environment IDE, specifically Visual Studio, and explain how tools such as debugging,
auto-completion, and project management enhance productivity and code quality. The
assignment concludes by evaluating coding standards, discussing their importance in
ensuring maintainable, secure, and team-consistent software development.

Page | 1
[Link] PRO
Activity 1
1.1. Algorithm
An algorithm is a process for carrying out a calculation or resolving an issue. In
hardware- or software-based routines, algorithms function as a precise set of instructions
that carry out predetermined operations systematically.

Algorithms are widely employed in all IT domains. In computer science, computer

programming, and mathematics, an algorithm is typically a brief process that resolves a
persistent issue. Algorithms are crucial to automated systems and are often used as
standards for data processing (Gillis, 2024).

Figure 1: Algorithm

Page | 2
[Link] PRO
 Page | 3
[Link] PRO
 1.2. Characteristics of a good algorithm
According to Singh(2024), mention below Characteristics of a good algorithm

1.2.1. Well defined input

For an algorithm to be accurate, predictable, and repeatable, its expected inputs need to be
well specified. The behavior of the algorithm is deterministic, meaning that the same
input will always result in the same output, thanks to well-defined inputs. Clear inputs aid
in avoiding improper implementations and misinterpretations of the algorithm's
specifications.

1.2.2. Well-defined Outputs

To guarantee that an algorithm generates the precise and desired result for a given set of
inputs, its outputs should be well stated. It eliminates uncertainty and ensures that the
algorithm resolves the issue accurately. Additionally, it is simple to confirm that the
algorithm is implemented correctly. With clearly specified outputs, you may further
optimize the algorithm to get better results more quickly.

1.2.3. Unambiguity

Inaccurate implementations and unreliable outcomes may stem from vague algorithm
descriptions. For this reason, it is critical that an algorithm be clear. It makes the
algorithm predictable, meaning that the same input yields the same result, which
facilitates implementation debugging. Additionally, it is simpler to standardize and utilize
unambiguous for a variety of purposes. You can concentrate more on optimizations while
implementing clear algorithms rather than managing unforeseen faults and edge
circumstances.

1.2.4. Finiteness

The algorithm should have a limited number of instructions and terminate after a
predetermined period. An algorithm with a finite number of steps will eventually finish
running and yield a result. In real-world situations where computing cannot be done
indefinitely, an infinite algorithm would never come to a finish .In the case of a finite
algorithm, the time and space complexity can be examined, which is crucial for carrying
out additional optimizations (Singh, 2024).

Page | 4
[Link] PRO
 1.2.5. Language Independent

An algorithm that is language-independent can be readily translated to other platforms

and computer languages, increasing its adaptability and use in a variety of settings. An
algorithm that is language-independent is also future-proof, meaning that it can be readily
implemented with more recent programming languages. Language independence is
crucial for algorithms in classrooms where students are exposed to a variety of
programming languages. Additionally, it facilitates the comparison of the algorithm's
performance across other programming languages.

1.2.6. Effectiveness and Feasibility

Because feasibility shows that an algorithm is workable and can be implemented with
realistic resources and constraints, it should be viable. Additionally, it avoids lengthy
execution periods, which might render an algorithm useless in practical situations.
Without the need for specialized resources, feasible algorithms can be readily
implemented using the hardware infrastructure already in place. Because of their realistic
hardware requirements, they are readily adopted for use in a variety of applications.

Figure 2: Characteristics of a good algorithm

Page | 5
[Link] PRO
 1.3. Pseudo code
Pseudo code is a thorough yet understandable explanation of what an algorithm or
computer program should accomplish. Programmers and other development process
participants can easily understand it because it is written in a formal yet readable style
with natural grammar and structure. Pseudo code cannot be turned into an executable
program because it is not a programming language. Rather, it acts as a guide for
converting the logic of the code into a real programming language (Sheldon, 2023).

Figure 3: Pseudo Code Image

Page | 6
[Link] PRO
 Figure 4: Pseudo code for Fibonacci

1.3.1. Pseudo Code for Fibonacci Series

Page | 7
[Link] PRO
 [Link]. Explanation for Fibonacci Series Pseudo code

2. Start – This marks the beginning of the program. It shows where the execution
starts.

3. Repeat – The program enters a loop that will keep asking the user for input until a
valid number is entered.

4. Display “Enter the Number” – This line shows a message on the screen asking the
user to type a number.

5. Read User_Input – The program reads the user’s input and stores it temporarily in
variable called User_Input.

6. IF user_Input is not a Number then – This check whether the user typed a valid
number. If the user entered letters or symbols instead of a number, the condition
becomes true.

7. Display “Enter Number Only” – If the user typed something invalid, this message
is displayed to remind them to type only numbers.

8. Go back and ask again – The program returns to the beginning of the input step to
ask for the number again.

9. END IF – This marks the end of the “if “condition that checks for invalid input.

10. Convert the user_Input into an integer type and store it as num1- The user’s input
is converted to an integer so that the program can perform calculations with it.

11. IF num1 is less than or equal to zero then – This checks if the number entered is 0
or a negative number.

12. Display " Please Enter a Suitable Number Greater Than 0 " – If the number is 0 or
less, the program tell the user to enter a suitable number.

13. Else – If the number is greater than zero, the program moves on to the next part.

14. Exit the Loop – Since a suitable number has been entered, the input loop ends
here.

Page | 8
[Link] PRO
 15. END IF – This closes the second “if” condition that checks whether the number is
valid.

16. Until num1 is a Suitable Number – The line defines the end condition of the
repeat loop. The loop will continue until the user provides a valid number.

17. Initialize A = 0 – The first Fibonacci number is stored in variable A, Which starts
at 0.

18. Initialize B = 1- The second Fibonacci number is stored in variable B, which starts
at 1.

19. Display "Fibonacci Series" – These shows a heading on the screen before printing
the sequence.

20. FOR i From 1 to num1 do – This line starts a loop that will run as many times as
the number entered by the user.

21. Print the value of A – Each time through the loop, the program prints the current
Fibonacci number, which is stored in A.

22. Calculate next_Num = A + B – The next Fibonacci number is found by adding the
two previous number.

23. Update A = B – The variable A is now update to hold the previous value of B. its
moves one step forward in the sequence.

24. Update B = next_num – The variable B is updated to the newly calculated

Fibonacci number.

25. END FOR – This marks the end of loop, and the program goes back to step 19
until all numbers are printed.

26. END - This indicates the end of the program.

Page | 9
[Link] PRO
1.3.2. Pseudo code for factorial series

Figure 5: Pseudo code for factorial series

Page | 10
[Link] PRO
[Link]. Explanation for Fibonacci Series Pseudo code

1. Start – This marks the beginning of the program. Every pseudo code usually starts with
this keyword.

2. Repeat – This means the next steps will keep repeating until the user enters a correct
number.

3. Display "Enter the Number:" – The program shows a message on the screen asking
the user to enter a number.

4. Read User_Input - The program reads the user’s input and stores it temporarily in
variable called User_Input.

5. IF User_Input is not a Number then - This check whether the user typed a valid
number. If the user entered letters or symbols instead of a number, the condition becomes
true.

6. Display "Enter Number Only...!" – If the input is not a number, the program tells the
user to entered numbers only.

7. Go back and ask again – The program goes back to the input step and asks the user to
enter the number again.

8. END IF – This marks the end of the condition that checks whether the input is a
number.

9. Convert the user_Input into an integer type and store it as num1 – Once a valid
number is entered, the program converts the user’s input into an integer and saves it as
num1.

10. IF num1 is less than or equal to 0 then – The program now checks if the number is 0
or a negative number.

11. Display "Factorial does not exist for negative numbers." – IF the entered number is
zero or less, this message is shown because factorials are only defined for positive
number.

12. Go back and ask again – If the number is invalid , the program repeats and ask the
user to enter a valid suitable number.

Page | 11
[Link] PRO
13. Else – If the number is positive, the program continues with the next steps.

14. Exit the Loop – The loop stops when a valid positive number is enters.

15. END IF – Marks the end of the condition that checks if the number is suitable.

16. Until num1 is a Suitable Number – The program will keep looping until the user gives
a suitable number.

17. Initialize Factorial = 1 – Before starting the calculation, the program sets the variable
Factorial to 1.

18. FOR i from 1 to num1 do – This line starts a loop that runs from 1 up to the entered
number. The loop will continue running until I becomes equal to num1.

19. Factorial = Factorial * i – Each time the loop runs, the current value of Factorial is
multiplied by i.

20. END FOR – Marks the end of loop that calculates the factorial.

21. Display "The Factorial of ", num1, "is", Factorial – Finally the program shows the
result, the Factorial of the number entered by the user.

22. Stop – This marks the end of the program execution.

Page | 12
[Link] PRO
 1.4. Steps Involved in Writing and Executing a Program
According to Thapa (2023), mention below Steps involved in writing and executing a
program.

1.4.1. Problem Analysis

Examining the program specifications, which outline the functions of the new system, is
the first step in the process. In order to completely grasp what the software should
perform, the systems analyst and programmer go over the specifications and may even
speak with users at this phase. A system analyst is responsible for this. System users are
consulted in order to determine the program's services, limitations, and goals. includes
the following duties, Describe the program's goals, Describe the program's goals,
identified the necessary inputs, Identify the processing needs, Assess the program's
viability, Record the analysis.

1.4.2. Program Design

The specifications, which typically take the form of a variety of program design tools, are
used to represent the algorithm required to solve the problem during program design.

A finite collection of instructions that take a set of values as input and create output as the
result of the calculation in a finite number of steps is called an algorithm.

A flowchart is a visual depiction of an algorithm that uses special-purpose symbols joined

by arrows to show the order of actions to be carried out. It is a crucial tool in
programming and one of the earliest methods for representing an algorithm.

1.4.3. Coding

Coding is the process of changing processes in each flowchart box according to the
programming language declaration. A programming language like C is use for coding.
Another name for the code created with a computer language is source code. Coding must
eliminate all syntax and logical errors.

Page | 13
[Link] PRO
1.4.4. Testing and debugging

Examining and verifying that a product satisfies the necessary quality standards is known
as testing. It verifies whether the software product meets all functional, performance, and
usability requirements in the context of software testing.

The process of identifying, evaluating, and fixing software issues is known as debugging.
This happens after the testing stage to make sure the program is operating properly before
to launch (Punnam, 2025).

1.4.5. Compilation and Execution

Source code is program code written in a high-level language that the computer cannot
directly understand. Therefore, it is necessary to translate the source code into machine-
level language, which is comprehensible to computers. Compilation is the translation
process, which is carried out by specialized software known as a compiler (Thapa, 2023).

1.4.6. Maintenance

The practice of upgrading or enhancing a program after it has been made available to the
user is known as program maintenance.

Programs don't wear out like physical equipment does, but they could need to be modified
because of mistakes, shifting needs, or new technology (Hampton, 2025).

Page | 14
[Link] PRO
1.5. The potential challenges faced
During the process of developing the algorithm, several challenges were encountered that
affected both understanding and implementation.

The first challenge was understanding the exact requirements of the problem.
Misinterpreting the problem statement often led to writing unnecessary or incorrect steps
so a clear understanding was achieved by carefully reading the question, identifying the
input and output, and outlining the purpose of each step before writing the algorithm.

The Second challenge involved arranging the steps in a correct and logical sequence. At
times, certain actions were placed before essential inputs or conditions, causing confusion
in program flow. The solution, each step was reordered according to the correct process,
starting from input, followed by processing, and ending with output.

Choosing the right loop or decision-making structure was another difficulty. Incorrect use
of loops caused infinite repetition or skipped steps. The solution, different loop types and
conditions were tested to determine which structure best matched the problem’s logic and
requirements.

After completing the algorithm, converting it into actual program code became another
challenge, Small logical errors in the algorithm created multiple coding mistakes. The
solution, each step of the algorithm was double-checked before coding. Simple examples
were used to confirm that the algorithm worked correctly before implementation.

Finding mistakes within the algorithm was time-consuming. Errors were sometimes
hidden due to unclear logic or missing steps so debugging was simplified by tracing each
step manually and comparing expected outputs with actual ones.

At first, the algorithm contained unnecessary steps that made it long and inefficient so
unneeded steps were removed, and repetitive tasks were replaced with loops or functions
to improve performance.

Writing a proper algorithm took longer than expected because of frequent corrections and
testing. The solution is a structured plan was followed, starting from problem analysis to
final testing, which saved time and improved accuracy.

Page | 15
[Link] PRO
1.6. Flowchart
One kind of diagram that depicts an algorithm, workflow, or procedure is a flowchart.
Different types of boxes in the flowchart represent the steps, and arrows are used to
connect the boxes to demonstrate their order. This diagrammatic depiction shows a model
of a problem's solution. In many different industries, flowcharts are used for process or
program analysis, design, documentation, and management (Busbee, 2018).

Figure 6: Flow Chart Image

Page | 16
[Link] PRO
1.6.1. Flowchart for Fibonacci Series

Figure 7: Flow chart for Fibonacci

Page | 17
[Link] PRO
[Link]. Explanation for Fibonacci flow chart

The flowchart shows the process of generating the Fibonacci series.

Page | 18
[Link] PRO
1.6.2. Flow chart for Factorial Series

Figure 8: Flow chart for factorial series

Page | 19
[Link] PRO
[Link]. Explanation for Factorial flow chart

Page | 20
[Link] PRO
1.7. Dry run Table
A key method in software testing is dry run testing, which enables testers to mimic
software execution without actually running the code. This procedure is essential for
spotting logical mistakes and confirming algorithms at an early stage of development.
Knowing the importance of dry run testing can help you enhance the quality and
dependability of your software, regardless of your level of experience as a tester. We will
go into the definition of dry run testing, its significance, and how to use it successfully in
your projects in this post (Ahire, 2025).

Figure 9 : Dry Run Table

Page | 21
[Link] PRO
 1.7.1. Dry Run Table for Fibonacci Series

Table 1: Dry Run Table for Fibonacci

step FB1 While User_ If not User_ If A B For i in i next_ Output
Input User_ Input User_ range () num
FB1
Input
Input is
<= 0
digit

Initial TRUE TRUE 10 False 10 False 0 1 TRUE 0 1 Fibonacci series

Step- 1 - - - - - - 1 1 TRUE 1 2 0

Step- 2 - - - - - - 1 2 TRUE 2 3 01

Step- 3 - - - - - - 2 3 TRUE 3 5 011

Step- 4 - - - - - - 3 8 TRUE 4 8 0112

Step- 5 - - - - - - 8 13 TRUE 5 13 01123

Step- 6 - - - - - - 13 21 TRUE 6 21 011238

Step- 7 - - - - - - 21 34 TRUE 7 34 0 1 1 2 3 8 13

Step- 8 - - - - - - 34 55 TRUE 8 55 0 1 1 2 3 8 13 21

Step- 9 - - - - - - 55 89 TRUE 9 89 0 1 1 2 3 8 13 21 34

Step- 10 - - - - - - - - False 10 - -

Page | 22
[Link] PRO
[Link]. Explanation for Fibonacci Series Dry run Table

Step 2 shows the first two seed values are entered into the output in this stage. The guard
check and user input remain unchanged in the table; Num1 stays at 11, allowing the loop
to proceed. The Next_Num column displays 1 (A + B = 0 + 1), whereas A = 0 and B = 1
are displayed. Now that the series has begun by listing the first two Fibonacci terms
(some implementations explicitly print the seeds first), the Output column displays 0 1.
To put it briefly, the first two terms are ready, and the next number to calculate is 1.

Step 3 the Next_Num = A + B = 0 + 1 = 1 is calculated using the algorithm. In order to

proceed, the pair is shifted so that Next_Num becomes the new B and the old B becomes
the new A. Thus, A and B both become 1. The output becomes 0 1 1 after appending that
new B (the recently calculated value). The loop will continue since it still detects that
Num1 = 11 and Num1 <= 0 are untrue.

Step 4 shows the Next_Num is now equal to A + B = 1 + 1 = 2. We have A = 1, B = 2

after updating the pair (A ÷ old B = 1, B ≠ Next_Num = 2). The new value is added to the
output, resulting in Output = 0 1 1 2. The Fibonacci term 2 was the result of this phase.

Step 5 shows the compute Next Num = A + B = 1 + 2 = 3. Move the pair so that A = 2 and
B = 3. The output goes up to 0 1 1 2 3. The procedure is repeated in each step: add, shift,
then sum the last two integers.

Step 6 shows the compute Next Num = 2 + 3 = 5. Update B = 5, A = 3. The result is 0 1 1

2 3 5. There are currently five in the succession.

Step7 shows the compute Next Num = 3 + 5 = 8. Update B = 8, A = 5. The result is 0 1 1

2 3 5 8. The table continues constructing the output string while displaying the
subsequent Fibonacci number (8).

Step 8 shows the compute Next Num = 5 + 8 = 13. A = 8 and B = 13 after the transfer.
The result is 0 1 1 2 3 5 8 13. Each new item is the total of the preceding two, so the
series is growing correctly.

Step 9 shows the compute Next Num = 8 + 13 = 21. Update B = 21, A = 13. The result is
0 1 1 2 3 5 8 13 21. 21 is the ninth Fibonacci term, or ninth added term if counting from
0.

Page | 23
[Link] PRO
Step10 shows the compute Next Num = 13 + 21 = 34. Change to A = 21 and B = 34. The
result is 0 1 1 2 3 5 8 13 21 34. The next figures are being produced steadily.

Page | 24
[Link] PRO
Step 11 shows the Next_Num = 21 + 34 = 55. Update B = 55, A = 34. 0 1 1 2 3 5 8 13 21
34 55 is the output. Eleven numbers, including the initial 0 and 1, have now been listed,
matching the user's Num1 = 11.

Step 12 shows the compute Next Num = 34 + 55 = 89. A = 55 and B = 89 after the move.
The table's output column displays 0 1 1 2 3 5 8 13 21 34 55 89 (or, depending on how
the implementation counts, the table shows up to 55 then 89 in the following line). This
stage illustrates the ongoing evolution; if the algorithm was instructed to generate 11
terms, it might halt at this point, because the desired count has been attained.

Page | 25
[Link] PRO
 1.7.2. Dry Run Table for Factorial Series

step FA1 While User_ If not User_ If Factorial For i i fact Output

FA1 User_ User_ in orial

Input Input
Input range *= i
Input
<= 0 ()
is digit

Initial - - - - -

Step- 1 8 False - - -

Step- 2 - 8 - 1 1 -

Step- 3 - 8 - 2 2 -

Step- 4 - 8 - 3 6 -

Step- 5 - 8 - 4 24 -

Step- 6 - 8 - 5 120 -

Step- 7 - 8 - 6 720 -

Step- 8 - 8 - 7 5040 -

Step- 9 - 8 - 8 40320

Page | 26
[Link] PRO
[Link]. Explanation for Factorial Series

The various variables and conditions used in the factorial program are represented by the
vertical columns in the table, and each column shows how the values change at each stage
of the program's execution. The User_Input column holds the value that the user entered,
while the Step column displays the execution sequence from beginning to end. The Num1
column stores the user input's integer form following validation, while the Not user_input
is Digit column verifies whether or not the input is a number. The Num1 ≤ 0 column
determines if the value is less than or equal to zero. The Factorial column shows the
intermediate and final factorial values as they are calculated, while the i column shows
the current iteration number in the loop that computes the factorial. Lastly, the program's
final printed result is displayed in the Output column. Each row corresponds to a different
stage of the program's execution, and the horizontal rows illustrate how variables change
and what conditions are checked at each level.

Initial:

At the beginning of the program, no number is entered yet. All the variables are empty,
and the factorial value is set to 1 to start with. The program is ready to take the user’s
input.

Step 1:

The user enters the number 8. The program checks if the entered value is a valid number.
Since 8 is a digit, the program accepts it. It then converts the input into an integer and
stores it in Num1. The program also checks whether the number is less than or equal to
zero, but since 8 is a positive number, it continues. The factorial value still remains 1
because the calculation hasn’t started yet.

Step 2:

Now, the program starts calculating the factorial using a loop. In the first round of the
loop, the value of i is 1, and the program multiplies the factorial by 1. So, the factorial
remains 1 × 1 = 1.

Page | 27
[Link] PRO
Step 3:

In the second round, i becomes 2, and the factorial value is updated as 1 × 2 = 2. The
program continues to the next round because the loop will run until i reaches 8.

Step 4:

For the next step, i is 3. The program multiplies the current factorial (which is 2) by 3,
giving 2 × 3 = 6. The factorial is slowly increasing with every step.

Step 5:

In this round, i becomes 4, and the factorial value is calculated as 6 × 4 = 24. The
program keeps looping and updating the factorial.

Step 6:

Now i is 5. The program multiplies 24 × 5 = 120. The factorial value keeps growing as
more numbers are multiplied.

Step 7:

When i becomes 6, the program calculates 120 × 6 = 720. The factorial result is getting
larger with each loop.

Step 8:

Here, i is 7, and the program multiplies 720 × 7 = 5040. The loop is still not finished
because it needs to go up to 8.

Step 9:

Finally, i is 8, and the program multiplies 5040 × 8 = 40320. This is the final factorial
value. The loop ends here because all the numbers from 1 to 8 have been multiplied. The
program then prints the final output: “The factorial of 8 is 40320.”

Page | 28
[Link] PRO
1.8. Big o Notation
Big O notation can be used to express how an algorithm's time or space requirements rise
with the size of the input. When a function f(n) is O(g(n)), it indicates that, provided the
input size is sufficiently large, f(n) will not increase more quickly than a specific multiple
of another function g(n). Put differently, for big inputs, f(n) is bounded by g(n) scaled up
by a constant number. To put it simply, f(n) acts more predictably than g(n) as the input
size increases if a constant and a beginning point where this relationship holds can be
established. This aids in comprehending and contrasting the effectiveness of various
algorithms, guaranteeing that they operate within reasonable bounds for substantial
volumes of data (Kumar, 2025).

Figure 10: Big O notation image

Page | 29
[Link] PRO
 1.8.1. Complexity Comparison between Typical Big O

According to Singh (Kumar, 2025), mention below Complexity Comparison between

Typical Big O

[Link]. O (1) - Constant Time Complexity

Regardless of the size of the input, algorithms with constant time complexity run in a
constant period. For instance, using an index to access an element in an array.
Comparison for O (1), the time is the same regardless of the size of the input.

[Link]. O (log n) - Logarithmic Time Complexity

The runtime of algorithms with logarithmic time complexity increases logarithmically

with the size of the input. Binary search in a sorted array, for instance. When compared to
linear time complexity, O (log n) is more efficient because the runtime grows slowly as
the input size increases.

[Link]. O (n) - Linear Time Complexity

The runtime of algorithms with linear time complexity increases linearly as the size of the
input increases. Linear search through an unsorted array, for instance. O (n) comparison,
for as the input size increases, so does the runtime.

[Link]. O (n log n) - Linearithmic Time Complexity

The runtime of algorithms with logarithmic time complexity increases according to the
input size multiplied by the input size's logarithm. For instance, heap sort and merging are
examples of effective sorting algorithms. Comparing O (n log n), Less effective than
linear or logarithmic time complexity, but more effective than quadratic ones.

Page | 30
[Link] PRO
[Link]. O (n^2) - Quadratic Time Complexity

The runtime of algorithms with quadratic time complexity increases exponentially with
the size of the input. Nested loops that iterate over the input are one example. Comparing
O (n^2), it becomes less efficient for large inputs as the runtime grows exponentially with
the input size.

[Link]. O (2^n) - Exponential Time Complexity

Page | 31
[Link] PRO
 Page | 32
[Link] PRO
 Page | 33
[Link] PRO
 Page | 34
[Link] PRO
References
Gillis, A. S., 2024. [Online]
Available at: [Link]
[Accessed 13 October 2025].
Singh, J. K., 2024. [Online]
Available at: [Link]
[Accessed 14 October 2025].

Page | 35
[Link] PRO
 Page | 36
[Link] PRO