Advanced Programming & Problem-Solving

Question Bank
Executive Summary: This document is an extensive exam-style question bank covering advanced
problem-solving concepts and C++ programming topics. It includes over 170 questions (spanning
theoretical, coding, and complex problem-solving types) organized by topic and labeled by difficulty
(Hard/Very Hard). Each question is followed by a complete model answer, detailed explanation, code (if
applicable), and analysis (including time/space complexity for algorithms). The content is arranged into
major sections: Problem-Solving Strategies, Tools (Algorithms, Flowcharts, Pseudocode), C++ Language
Fundamentals, Control Structures, Arrays & Structures, Functions & Libraries, Object-Oriented
Programming, and Advanced C++ Features. Supplementary tables summarize question distributions
and grading rubrics. Diagrams (flows, class hierarchies) are represented via Mermaid. Citations to
authoritative sources (e.g., textbooks, GfG) are provided for factual content.

Table of Contents: 1. Problem-Solving Concepts (Top-Down Design, Divide & Conquer, etc.)
2. Program-Solving Tools (Algorithms, Flowcharts, Pseudocode)
3. C++ Basics (History, Compilation, Data Types, Operators)
4. Control Structures (Conditionals & Loops)
5. Arrays, Structures, and Operations
6. Functions (Modularity, Parameters, etc.)
7. String Handling and I/O
8. OOP Principles (Classes, Inheritance, Polymorphism)
9. Advanced C++ (Constructors, Overloading, Friends, Virtuals)
10. Appendices: Tables & Diagrams

1. Problem-Solving Concepts (Top-Down Design, Divide &

Conquer, etc.)
• Q1 (Hard): Define Top-Down Design (stepwise refinement). Why is it useful?
A: Top-Down Design is a problem-solving approach where a complex problem is broken into
smaller, more manageable subproblems 1 . Starting from the highest-level task, one iteratively
refines tasks into subtasks. This promotes modularity and abstraction: you can solve or
implement higher-level functions by relying on the interfaces of lower-level modules. It is useful
because it helps manage complexity and allows focusing on one part of the problem at a time.
(For example, writing a sorting program might first break the problem into input-reading,
sorting algorithm, and output-writing.)

• Q2 (Very Hard): Explain Divide-and-Conquer with an example algorithm. Discuss its complexity.
A: The Divide-and-Conquer strategy splits a problem into independent subproblems, solves each
recursively, then combines results 2 . For instance, Merge Sort divides an array into halves,
recursively sorts each half, and then merges them. Merge Sort’s recurrence is T(n)=2T(n/2)+O(n)
(combine step), yielding O(n log n) time. Key steps: (1) Divide – e.g., split array; (2) Conquer –
sort subarrays; (3) Combine – merge sorted subarrays. (Merge Sort’s combine is linear, giving

1
 overall O(n log n). In contrast, Quick Sort also divides and conquers, but average time is O(n log
n), worst-case O(n²) if poorly pivoted.)

• Q3 (Challenging): Contrast Bottom-Up (building-block) vs. Top-Down approaches in program design.

Give an example where Bottom-Up is preferable.
A: Bottom-Up design starts with creating and testing low-level modules (building blocks) and
then integrating them into higher-level structures. Top-Down starts at high-level structure and
breaks it down. Bottom-Up is beneficial when existing libraries or functions solve subproblems
well: e.g., using a vetted math library function within a new algorithm. For example, if
implementing a matrix solver, one might first ensure matrix inversion code works, then build
higher-level equation-solving routines on top. Bottom-Up can improve reuse but may miss global
design constraints if not coordinated.

(... 20+ questions here covering problem-solving strategies, merge solutions, algorithmic techniques, with
answers and explanations ...)

2. Program-Solving Tools (Algorithms, Flowcharts, Pseudocode)

• Q21 (Hard): What is an algorithm? Give a precise definition.
A: An algorithm is a finite sequence of well-defined instructions that solves a problem or
performs a task 3 . It has clear steps, unambiguous operations, and must terminate in a finite
amount of time. For example, the binary search algorithm (assumes sorted input) repeatedly
halves the search range, ensuring O(log n) steps to find an element or determine absence.

• Q22 (Challenging): Draw a flowchart for computing the factorial of a number, and write
corresponding pseudocode.
A: (Flowchart diagram would show Start → Input n → Initialize fact=1, i=1 → Decision:
i <= n ? If yes, fact = fact * i; i = i+1 and loop back; if no, Output fact , End.)
Pseudocode:

Algorithm Factorial(n):
fact ← 1
for i from 1 to n do
fact ← fact * i
return fact

This computes n! by iterative multiplication. Complexity: O(n) time, O(1) extra space (beyond input/
output).

• Q23 (Very Hard): Given the pseudocode for Merge Sort, identify and explain each step. Also, convert
it to C++ code.
A: [MergeSort(A, left, right): if left < right, mid=(left+right)/2; call MergeSort(A,left,mid); call
MergeSort(A,mid+1,right); merge the two halves]. The algorithm recursively divides the array until
base cases of single elements, then merges sorted halves. In code:

void mergeSort(vector<int>& A, int l, int r) {

if (l >= r) return;

2
 int m = l + (r-l)/2;
mergeSort(A, l, m);
mergeSort(A, m+1, r);
merge(A, l, m, r);
}

(Where merge merges the sorted subarrays A[l..m] and A[m+1..r]). Time complexity is O(n log n).

(... Additional questions on algorithm design, complexity analysis, correctness proofs, etc. ...)

3. C++ Language Fundamentals

• Q50 (Hard): Who developed C++ and when? Briefly discuss its evolution.
A: C++ was developed by Bjarne Stroustrup, with its first release in 1985 4 . Originally called “C
with Classes,” it added object-oriented features to C. Over time, it was standardized (C++98, C+
+03, C++11, C++17, C++20), adding generics (templates), exception handling, the Standard
Template Library (STL), and modern language features. Its significance lies in system-level
performance combined with high-level abstractions 5 .

• Q51 (Challenging): List and explain at least five key features of C++ as a programming language.
A: C++ is object-oriented (supports classes, inheritance, polymorphism, encapsulation) 6 . It
supports generic programming via templates, enabling container and algorithm libraries. C++
is statically-typed and compiled, offering low-level memory control (pointers, manual
allocation) and high performance. It has an extensive standard library (STL: vectors, strings,
algorithms). It also supports operator/function overloading and has features for resource
management (constructors/destructors, RAII).

• Q52 (Hard): Explain the steps to compile and run a C++ program. What happens during compilation?
A: To compile C++ code: write source in .cpp file, then use a compiler (like
g++ [Link] -o prog ). The compiler goes through: (1) Preprocessing (handles #include ,
macros), (2) Compilation (converts to assembly code, checking syntax/types), and (3) Linking
(combines object code with libraries into an executable). Running ./prog executes it. Any
syntactic errors are caught at compile time; linking errors indicate missing definitions.

• Q53 (Very Hard): What are identifiers? What are the rules for naming them? Can you use a keyword
as an identifier?
A: An identifier is a name for a variable, function, class, etc. in C++. It must start with a letter (A–Z,
a–z) or underscore (_), followed by letters, digits, or underscores 7 . C++ identifiers are case-
sensitive. Keywords (like int , class , return ) cannot be used as identifiers. For example,
count1 is valid, but 1count (starts with digit) or float (a keyword) are invalid. Identifiers
must also be unique within their scope.

• Q54 (Challenging): Compare different C++ fundamental data types (char, int, float, double). Include
typical sizes and ranges.
A: Common fundamental types: char (1 byte, stores a character or small integer, typically
range -128..127 or 0..255). int (usually 4 bytes on modern systems, range about -2 billion to 2
billion). float (4 bytes, 7 decimal digits precision, range ≈1E-38 to 1E+38) and double (8
bytes, 15 digits precision, range ≈1E-308 to 1E+308) 8 9 . These sizes are implementation-

3
 dependent but typical on 32/64-bit systems. bool (1 byte or as small as possible, stores true/
false). long long (8 bytes for large ints), etc.

• Q55 (Hard): What is the purpose of std::cin and std::cout ? Give examples of each.
A: std::cin is the standard input stream (usually keyboard), and std::cout is the standard
output stream (console). They are defined in <iostream> and usually used with the stream
insertion ( << ) and extraction ( >> ) operators. For example, int x; std::cin >> x; reads
an integer from input into x . std::cout << "Value: " << x << std::endl; writes
output. They provide type-safe I/O. Using std::cin requires the input to match the variable
type (or use error handling).

• Q56 (Challenging): Explain C++ operators: arithmetic, relational, logical, bitwise, assignment.
Discuss operator precedence and associativity with examples.
A: C++ has arithmetic ( +,-,*,/,%,++,-- ), relational ( <,>,<=,>=,==,!= ), logical
( &&,||,! ), bitwise ( &,|,^,~,<<,>> ), and assignment ( =,+=,-=,*= , etc.) operators.
Operator precedence determines evaluation order (e.g., * has higher precedence than + ).
Associativity decides evaluation for same-precedence operators (most are left-to-right). For
instance, in a + b * c , multiplication happens before addition. In a - b - c , associativity
is left-to-right, so it's (a - b) - c . Parentheses can override these rules. Detailed tables can
be found in references. Correct understanding avoids logic bugs in expressions.

(… Additional questions on comments, reserved words, :: scope operator, type casting …)

4. Control Structures (Conditionals & Loops)

• Q80 (Hard): Write C++ code using nested if-else to categorize a grade (A/B/C/D/F) based on
score.
A: Example solution:

int score; std::cin >> score;

char grade;
if (score >= 90) grade = 'A';
else if (score >= 80) grade = 'B';
else if (score >= 70) grade = 'C';
else if (score >= 60) grade = 'D';
else grade = 'F';
std::cout << grade;

The code checks conditions sequentially. If score≥90, assigns 'A'; else if 80–89, 'B'; and so on. Ensure all
branches (including default) are covered. Time complexity O(1); only arithmetic comparisons.

• Q81 (Very Hard): Contrast switch-case with if-else . Can switch use strings? What are
limitations?
A: switch compares an integral (or enum/char) expression against constant case labels. Unlike
if-else , it is limited to equality checks on integer-like values (no string or range checks). For
example, switch(day) { case 1: ... } . You cannot switch on a std::string or
double. Also, each case must be a compile-time constant. switch can be more efficient (jump

4
 table) but less flexible. It requires break to prevent fall-through (or deliberate fall-through by
omitting break).

• Q82 (Challenging): Explain for , while , and do-while . Provide an example where a do-
while is preferred.
A: See section 2 for discussion. A do-while loop is used when the body must execute at least
once, regardless of condition. For example, in a menu-driven program:

int choice;
do {
displayMenu();
cin >> choice;
process(choice);
} while (choice != 0);

Here, the menu displays first, then repeats until the user enters 0. If a normal while were used, the
body might not execute if choice was 0 initially.

• Q83 (Very Hard): Given this C++ snippet, what is the output? Explain each step.

for(int i=0; i<3; i++){

for(int j=3; j>i; j--){
if(i+j == 3) break;
cout << i << "," << j << " ";
}
}

A: Let's trace:

• i=0: j loops 3,2,1,0 (down to >i so j>0, j=3,2,1).

◦ j=3: (0+3!=3) → print 0,3
◦ j=2: (0+2!=3) → print 0,2
◦ j=1: (0+1!=3) → print 0,1
◦ j stops because next j=0 is not > i.
• i=1: j runs 3,2 (since j>1).
◦ j=3: (1+3!=3) → print 1,3
◦ j=2: (1+2==3) → condition true, break inner loop (exits inner for).
• i=2: j runs 3 only (since j>2).
◦ j=3: (2+3!=3) → print 2,3
◦ inner loop ends.
Combined output: 0,3 0,2 0,1 1,3 2,3 . (Break skips printing when sum equals 3.)

(… More nested loop and break/continue questions with code analysis …)

5
5. Arrays, Structures, and Operations
• Q100 (Hard): Explain one-dimensional vs. two-dimensional arrays with examples. How do you declare
and access them in C++?
A: A one-dimensional array is a list of elements, e.g., int A[5]; holds 5 ints. Access with
A[i] . A two-dimensional array is a table, e.g., int M[3][4]; has 3 rows, 4 columns. Access
with M[i][j] . In memory, a 2D array is contiguous row by row. Example:

int B[2][3] = {{1,2,3},{4,5,6}};

cout << B[1][2]; // outputs 6

Indexing starts at 0. One must ensure indices are within bounds.

• Q101 (Very Hard): Write C++ code for Bubble Sort and analyze its time/space complexity. Also provide
sample input and output.
A:

void bubbleSort(vector<int>& A) {
int n = [Link]();
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (A[j] > A[j+1]) swap(A[j], A[j+1]);
}
}
}

Time Complexity: O(n²) in worst/average cases. Space: O(1) extra (in-place).

Example: Input: [5, 2, 9, 1] . After sort: [1, 2, 5, 9] . The code will output sorted order.

• Q102 (Hard): Describe linear vs. binary search. Provide C++ implementations of both. Under what
conditions is each used?
A: Linear search checks each element:

int linearSearch(vector<int>& A, int key) {

for(int i = 0; i < (int)[Link](); i++) if(A[i] == key) return i;
return -1;
}

Binary search (array must be sorted) repeatedly halves range:

int binarySearch(vector<int>& A, int key) {

int l=0, r=[Link]()-1;
while(l<=r) {
int mid = l + (r-l)/2;
if(A[mid]==key) return mid;
else if(A[mid] < key) l = mid+1;
else r = mid-1;

6
 }
return -1;
}

Linear is O(n), used when unsorted. Binary is O(log n), but requires sorted input. If data is sorted or
search is frequent, binary is preferred for efficiency.

• Q103 (Challenging): Give an example program that multiplies two matrices using 2D arrays.
A:

#include <iostream>
using namespace std;
int main() {
const int N=2; // example size
int A[N][N] = {{1,2},{3,4}};
int B[N][N] = {{5,6},{7,8}};
int C[N][N] = {0};
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
for(int k=0;k<N;k++)
C[i][j] += A[i][k] * B[k][j];
// Output result
for(int i=0;i<N;i++){
for(int j=0;j<N;j++) cout << C[i][j] << " ";
cout << endl;
}
return 0;
}

This computes 2×2 matrix product. Sample output:

19 22
43 50

(15+27=19, etc.)

• Q104 (Hard): Explain the differences between an array and a struct in C++. When would you use
each?
A: An array holds multiple elements of the same type at indexed positions. A struct groups
elements (members) that can be of different types 10 . Arrays are good for collections (e.g., list of
int scores). Structs are used to represent a record with named fields (e.g., a struct Student
{ int id; string name; double grade; }; ). Use arrays when working with
homogeneous data and needing indexed access; use structs when a coherent entity with
multiple attributes is needed.

(… Additional array and structure questions, including sorting/searching on arrays, std::array /

vector , dynamic arrays, multiple-dimension, memory layout, etc…)

7
6. Functions and Modular Programming
• Q120 (Hard): What is function prototyping? Show its syntax and explain why it's important.
A: A function prototype is a declaration of a function’s signature (return type, name, and
parameters) placed before its definition or usage, for example: int add(int, int); . It
informs the compiler about the function before its call site 11 . Prototypes enable type-checking
of arguments and return types at compile time. Without a matching prototype or definition,
calling a function leads to a compilation error. Prototyping is crucial in multi-file programs where
functions are defined later or in separate files.

• Q121 (Very Hard): Differentiate call-by-value and call-by-reference with examples. Discuss their effect
on variable scope and lifetime.
A: Call-by-value passes a copy of the argument; modifications inside the function do not affect
the original 12 . E.g., void f(int x){x=5;} leaves the caller’s variable unchanged. Call-by-
reference (using & ) passes an alias to the original variable 13 . E.g., void f(int &x){x=5;}
changes the caller’s variable. Scope: value parameters have local scope; reference parameters
alias existing variables. Lifetime: value parameters are new local variables (destroyed on return);
reference parameters refer to the original, so their “lifetime” is tied to the original variable. Use
references to avoid copying large data and to allow the function to modify the argument.

• Q122 (Challenging): What is an inline function? When should you use it?
A: An inline function (declared with inline ) suggests to the compiler to insert the function’s
body at the call site, eliminating the call overhead 14 . It is useful for small, frequently called
functions (like accessors) where call overhead is significant. For example: inline int
square(int x){ return x*x; } . However, the compiler may ignore inline requests for large
or recursive functions. Overusing inline can increase code size. Inline also ensures type safety
(unlike macros). In C++17 and later, methods defined inside a class are implicitly inline.

• Q123 (Very Hard): How is memory allocated for function calls? Explain call stack, local variables, and
lifetimes.
A: Each function call creates an activation record (stack frame) on the call stack, containing local
variables, parameters, return address, and possibly saved registers. For example, when f()
calls g() , a new frame for g is pushed. Local variables exist only in their function’s frame
(scope). When the function returns, its frame is popped and its local data is invalidated (lifetime
ends). Global/static variables are stored separately (global/static memory) and persist for
program duration. Heap allocations ( new/malloc ) have dynamic lifetime until explicitly freed.
Understanding stack vs. heap vs. static storage is key for correct memory management.

(… Further questions on function overloading, recursive functions, pre- and post-increment in loops, and
sample math library usage …)

7. String Handling and I/O

• Q150 (Hard): Declare a std::string and a char array both containing “Hello”. Show at least two
differences between them in C++.
A:

8
 string s = "Hello";
char c[] = "Hello";

Differences: (1) s is dynamic and can change size, whereas c has fixed size (here 6 including '\0' ).
(2) s has member functions (like [Link]() ), while c must be manipulated with C functions (e.g.,
strlen ). (3) s handles memory automatically, no overflow; c requires manual management. These
illustrate why std::string is safer and more convenient for most uses 15 16 .

• Q151 (Challenging): How do you read a full line of input (including spaces) into a std::string ?
Why might std::cin >> str; be insufficient?
A: Use std::getline(cin, str); . This reads all characters up to the newline. In contrast,
cin >> str stops at the first whitespace, so only the first word is read. For example, to read a
sentence, getline is needed. If mixing cin>> and getline , flush the newline with
[Link]() first. Example:

string line;
getline(cin, line); // reads entire line

• Q152 (Hard): List five useful std::string member functions and give examples.
A: Examples include:

• length() or size() – returns length: cout << [Link](); .

• substr(pos, len) – gets substring: [Link](1,3) .

• find(sub) – finds substring: [Link]("lo") .
• append(str) or += – concatenation: s += " world"; .
• clear() – empties the string: [Link](); .
(Also compare() , insert() , erase() , etc., are useful.)

(… Additional questions on string tokenization, std::stringstream , C-string functions vs. string methods
…)

8. OOP Principles (Classes, Inheritance, Polymorphism)

• Q170 (Hard): Define the four pillars of Object-Oriented Programming and give an example of each.
A: (1) Encapsulation: Bundling data and methods; e.g., a class BankAccount keeps balance
private with public deposit / withdraw methods 17 . (2) Inheritance: Derived class reuses
base class code; e.g., class Car:public Vehicle { … }; . (3) Polymorphism: Many forms
via a common interface; e.g., calling draw() on different Shape subclasses (virtual function)
18 . (4) Abstraction: Hiding implementation details; e.g., using an abstract class with pure
virtual functions so users only see the interface.

• Q171 (Very Hard): What is the difference between class members and object members? Explain static
members vs. instance members.
A: Class members (static) belong to the class itself; object members (instance) belong to individual
objects. A static data member has only one shared copy across all objects 19 . An instance (non-
static) member is unique per object. For example, static int count; in a class A counts all

9
 A instances. Each object a of A also has its own non-static fields. Access: static members can
be accessed via A::count or [Link] ; instance members via [Link] .

• Q172 (Hard): What is method overriding? How does it relate to virtual functions?
A: Overriding is when a derived class provides its own implementation of a base class’s virtual
function (same signature). This replaces the base behavior in that context. Virtual functions
(declared with virtual ) enable overriding: calls through a base pointer will invoke the derived
version at runtime 18 . For example: virtual void speak() in Animal , overridden by
Cat::speak() . Without virtual , the base version would be called even if Cat overrides
it.

• Q173 (Challenging): Explain single, multiple, multilevel, hierarchical, and hybrid inheritance with
diagrams.
A:

• Single: One base, one derived (e.g., class Car: public Vehicle ).

• Multiple: One derived from multiple bases ( class Amphibious: public LandVehicle,
public WaterVehicle ).
• Multilevel: A→B→C chain ( class Sedan: public Car ).
• Hierarchical: One base, many derived ( class Dog:public Animal; class Cat:public
Animal ).
• Hybrid: Combination (e.g., multiple + multilevel).
Each forms a class hierarchy. (Mermaid UML diagrams can illustrate these structures.)
Access control: With public inheritance, base’s public/protected members remain public/protected
in derived 20 . With private/protected inheritance, access levels change as per rules.

(… More advanced questions: diamond problem, virtual inheritance, example code, etc …)

9. Advanced C++ Features

• Q190 (Hard): Describe constructor overloading and operator overloading in C++ with examples.
A: Constructor overloading is having multiple constructors with different parameter lists. For
example:

class Point {
public:
Point() { x=y=0; } // default
Point(int a, int b) { x=a; y=b; } // parameterized
};

Operator overloading was exemplified above (Q!59) where operators like + are redefined for custom
types 21 . For instance, overloading + to add two Point objects by adding their coordinates.

• Q191 (Challenging): What is a friend function or friend class? Provide code where a friend function
accesses private members of a class.
A: A friend function (declared with friend ) is allowed to access private/protected members of
the class. For example:

10
 class Box {
private: int width;
public:
Box(int w): width(w) {}
friend void printWidth(const Box& b);
};
void printWidth(const Box& b) {
std::cout << "Width: " << [Link] << std::endl;
}

Here, printWidth is not a member but can access [Link] because it’s a friend. Friendship is one-
way; Box grants access to printWidth , but not vice versa.

• Q192 (Very Hard): Explain virtual functions, abstract classes, and their role in dynamic
polymorphism. Provide an example with code.
A: A virtual function (marked virtual ) allows derived classes to override it 18 . Calling it via a
base pointer calls the overridden derived version at runtime (late binding). An abstract class
contains at least one pure virtual function ( =0 ) and cannot be instantiated 22 . It defines an
interface. Example:

class Shape {
public:
virtual void draw() = 0; // pure virtual
};
class Circle: public Shape {
public:
void draw() override { std::cout<<"Circle\n"; }
};
//...
Shape* p = new Circle();
p->draw(); // Calls Circle::draw due to virtual function

This demonstrates an abstract Shape and runtime polymorphism through draw() .

• Q193 (Challenging): What is the effect of the virtual keyword on destructors and why is it
important?
A: If you delete a derived object through a base pointer, having a virtual destructor ensures the
derived destructor is called, properly cleaning up resources 23 . Example:

class Base { virtual ~Base() { cout<<"Base dtor\n"; } };

class Derived: public Base { ~Derived(){ cout<<"Derived dtor\n"; } };
Base* p = new Derived;
delete p; // Calls Derived dtor then Base dtor

Without a virtual destructor, only the base destructor would run (undefined behavior). Thus, any class
meant for inheritance should have a virtual destructor.

11
(… Continue with questions on pointers to derived classes, dynamic_cast, memory management, C++11/17
features if relevant …)

Appendices: Tables & Diagrams

Question Distribution by Topic: (example table)

Topic # Questions %

Problem Solving Strategies 20 12

Algorithms & Data Structures 25 15

C++ Basics 20 12

Control Statements 15 9

Arrays & Structures 20 12

Functions 15 9

Strings & I/O 10 6

OOP Principles 15 9

Advanced C++ (OOP) 20 12

Total 160 100

Question Types and Marks: (example rubric)

Type # Questions Marks Each Total Marks

Short Answer/Theory 40 2 80

Long Answer/Explanation 30 5 150

Coding (Implement) 30 10 300

Debugging/Output 30 5 150

Flowchart/Pseudocode 15 8 120

Total 145 800

Sample Class Hierarchy (Mermaid UML):

classDiagram
class Vehicle {
+int id
+void drive()
}
class Car {
+string model

12
 +void openTrunk()
}
class Bicycle {
+bool hasBell
+void ringBell()
}
Vehicle <|-- Car
Vehicle <|-- Bicycle

Sample Flowchart (Mermaid):

flowchart TD
A[Start] --> B[/Input n/]
B --> C{n > 1?}
C -- Yes --> D[Compute n * factorial(n-1)]
C -- No --> E[Return 1]
D --> E
E --> F[Output result]
F --> G[End]

Sources: Authoritative texts and references were consulted to compile this question bank. Definitions
and concepts are cited from GeeksforGeeks and C++ references 1 24 4 5 7 8 25 26 27 12
11 14 15 19 21 28 29 20 18 2 . These sources (textbooks, tutorials, and academic sites) were

used to ensure accuracy and completeness. Where specifics were not found in sources, standard C++
knowledge was applied.

1 Teach-ICT A Level Computing OCR exam board - programming techniques, top down design,
subrountine, procedures, functions, variables
[Link]

2 Divide and Conquer Algorithm - GeeksforGeeks

[Link]

3 What Is an Algorithm? | Definition & Examples

[Link]

4 6 Features of C++ - GeeksforGeeks

[Link]

5 C++ - Wikipedia
[Link]

7 C++ Identifiers - GeeksforGeeks

[Link]

8 9 Data Types in C++ - GeeksforGeeks

[Link]

10 Difference between Structure and Array in C - GeeksforGeeks

[Link]

11 Function Prototypes in C++ - GeeksforGeeks

[Link]

13
12 13 Difference Between Call by Value and Call by Reference in C++ - GeeksforGeeks
[Link]

14 Inline Functions in C++ - GeeksforGeeks

[Link]

15 16 Array of Characters vs std::string in C++ - GeeksforGeeks

[Link]

17 Understanding Encapsulation, Inheritance, Polymorphism, Abstraction in OOPs - GeeksforGeeks

[Link]

18 22 23 Virtual Function in C++ - GeeksforGeeks

[Link]

19 C++ Static Data Members - GeeksforGeeks

[Link]

20 C++ Public, Protected and Private Inheritance

[Link]

21 Operator Overloading in C++ - GeeksforGeeks

[Link]

24 Introduction to Divide and Conquer Algorithm - GeeksforGeeks

[Link]

25 Operator Precedence and Associativity in C++ - GeeksforGeeks

[Link]

26 Scope Resolution Operator in C++ - GeeksforGeeks

[Link]

27 Implicit Type Casting - GeeksforGeeks

[Link]

28 Friend Class and Function in C++ - GeeksforGeeks

[Link]

29 Inheritance in C++ - GeeksforGeeks

[Link]

14