Solutions to the Questions in the Problem Solving Question Bank

2 Marks Questions
1.
Define a computer and list its basic characteristics.

A computer is an electronic device that processes data and performs tasks according to a set of instructions (program). Basic characteristics include
speed, accuracy, storage capability, versatility, and automation.

2.
What are the uses of computers in education?

Computers are used in education for e-learning, research, administrative tasks, virtual classrooms, and interactive simulations.
3.
Name two types of errors encountered during programming.

Syntax errors and runtime errors.

4.
State the difference between hardware and software.

Hardware refers to the physical components of a computer, while software refers to the programs and applications that run on the hardware.

5.
What is debugging in programming?

Debugging is the process of identifying, analyzing, and removing errors from a program.

6.
Define flowcharting and its significance.

Flowcharting is the graphical representation of an algorithm or process using symbols. It helps in visualizing the sequence of steps and identifying
logical errors.

7.
Mention two characteristics of structured programming.

Use of subroutines/functions and a clear, hierarchical structure.

8.
Write the definition of an algorithm with an example.

An algorithm is a step-by-step procedure for solving a problem. Example: Algorithm to find the sum of two numbers.

9.
Differentiate between RAM and ROM.

RAM (Random Access Memory) is volatile memory used for temporary data storage, while ROM (Read-Only Memory) is non-volatile memory used to
store firmware.

10.
What is an array in programming?

An array is a data structure that can store a fixed-size sequential collection of elements of the same type.

11.
Define the term "computer generations."

Computer generations refer to the stages of technological evolution in computer design and functionality, from the first to the fifth generation.

12.
What is program verification?

Program verification is the process of ensuring that a program correctly implements the intended algorithm and meets its specifications.
13.
Name two characteristics of fifth-generation computers.

Use of artificial intelligence and parallel processing.

14.
State the difference between machine language and assembly language.

Machine language is a low-level language consisting of binary code that the computer's CPU can execute directly, while assembly language is a low-
level language that uses mnemonic codes to represent machine language instructions.

15.
What is the role of an interpreter in programming?

An interpreter translates and executes code line-by-line, allowing for immediate error detection and debugging.

16.
Define debugging and list two debugging tools.

Debugging is the process of finding and fixing errors in a program. Two debugging tools are GDB (GNU Debugger) and Visual Studio Debugger.

17.
What is a syntax error? Provide an example.

A syntax error occurs when the code does not follow the programming language's rules. Example: Missing semicolon in C programming.
18.
State the significance of decision tables in program logic design.

Decision tables provide a systematic way of representing complex business rules and conditions to aid in decision-making processes.

19.
Define the term "implementation of algorithms."

Implementation of algorithms refers to the process of converting an algorithm into a programming language to create a functional program.

20.
What are logical operators? Give an example.

Logical operators are used to combine or invert Boolean values. Example: AND (&&), OR (||), NOT (!).

3 Marks Questions
21.
Explain the term "top-down programming."

Top-down programming is a problem-solving approach where the main problem is broken down into smaller, more manageable sub- problems, which
are then solved individually.

22.
 Describe the concept of problem-solving in computer programming.

Problem-solving in programming involves understanding the problem, devising a plan (algorithm), implementing the solution in a programming
language, and testing the solution to ensure it works correctly.

23.
How are generations of computers classified? Briefly explain the first generation.

Generations of computers are classified based on technological advancements. The first generation (1940-1956) used vacuum tubes for circuitry and
magnetic drums for memory, and they were large, expensive, and consumed a lot of power.

24.
Explain structured programming and its advantages.

Structured programming is a programming paradigm that uses a top-down approach and emphasizes breaking down a program into modules or
functions. Advantages include improved readability, easier maintenance, and reduced complexity.

25.
What are the modules of a computer? Describe briefly.

Modules of a computer include the CPU (central processing unit), memory (RAM and ROM), input devices (keyboard, mouse), output devices
(monitor, printer), and storage devices (hard drive, SSD).

26.
Differentiate between high-level and low-level programming languages.

High-level programming languages are closer to human languages and abstract from hardware, making them easier to write and
 understand (e.g., Python, Java). Low-level programming languages are closer to machine language and provide more control over hardware (e.g.,
Assembly).

27.
Write a short note on documentation in programming.

Documentation in programming involves writing descriptions, explanations, and comments within the code and separate documents to help developers
understand and maintain the code.

28.
Explain the significance of debugging in the software development process.

Debugging is crucial as it helps identify and fix errors in the code, ensuring the software runs smoothly and correctly. It improves the reliability and
performance of the software.

29.
What is a decision table? Explain its role in problem-solving.

A decision table is a tabular representation of conditions and actions used to model complex decision logic. It helps in systematically analyzing and
specifying decision rules.

30.
Briefly describe the bottom-up approach in programming.

The bottom-up approach in programming starts with solving the smaller, simpler problems first, which are then integrated to form the complete solution.
It focuses on developing and testing modules or functions independently before combining them.
5 Marks Questions
31.
Explain the basic organization of a computer.

The basic organization of a computer consists of the following components:

Central Processing Unit (CPU): The brain of the computer that performs instructions defined by software.
Memory (RAM and ROM): Stores data and instructions temporarily (RAM) and permanently (ROM).
Input Devices: Allow users to input data into the computer (e.g., keyboard, mouse).
Output Devices: Display or output data from the computer (e.g., monitor, printer).
Storage Devices: Store data permanently (e.g., hard drives, SSDs).
Motherboard: The main circuit board that connects all components and allows communication between them.

32.
Discuss the planning process of a computer program with an example.

The planning process of a computer program involves several steps:

Problem Definition: Understanding the problem and its requirements.
Algorithm Design: Creating a step-by-step solution to the problem.
Coding: Writing the algorithm in a programming language.
Testing: Running the program to check for errors and correctness.
Documentation: Writing explanations and comments for future reference.
Example: Planning a program to calculate the factorial of a number involves defining the problem, designing an algorithm (e.g., using a loop),
coding the algorithm in a language like C, testing with different inputs, and documenting the code.

33.
 Compare and contrast arrays and linked lists in terms of usage and performance.

Arrays:

Fixed size.
Fast access to elements (constant time).
Memory is allocated contiguously.
Insertions and deletions are costly (shifting elements).

Linked Lists:

Dynamic size.
Slower access to elements (linear time).
Memory is allocated non-contiguously (nodes).
Insertions and deletions are efficient (constant time if the position is known).

34.
Explain the characteristics of the fourth generation of computers.

The fourth generation of computers (1971-present) is characterized by: Use

of microprocessors (integrated circuits).
High-speed processing.
Increased memory capacity.
Smaller, more affordable personal computers.
Development of GUIs (Graphical User Interfaces) and high-level programming languages.

35.
 How does an algorithm differ from a flowchart? Provide examples.

Algorithm:

A textual representation of a step-by-step procedure to solve a problem.

Example: Algorithm to find the sum of two numbers.

Flowchart:

A graphical representation of an algorithm using symbols.

Example: Flowchart to find the sum of two numbers.
Differences: Algorithms are text-based and provide detailed steps, while flowcharts are visual and help in understanding the sequence of steps.

36.
Discuss the logical structures in programming and their implementation with examples.

Sequence:
Execution of statements one after the other.
Example: int a = 5; int b = 10; int sum = a + b;

Selection:
Decision-making structures like if-else.
Example: if (a > b) { /* code */ } else { /* code */ }

Iteration:
Looping structures like for, while.
Example: for (int i = 0; i < 10; i++) { /* code */ }
37.
Describe the techniques of problem-solving in programming.

Problem Understanding: Analyzing the problem and its requirements.

Algorithm Design: Creating a logical sequence of steps.
Pseudocode and Flowcharts: Using intermediate representations to plan the solution.
Coding: Writing the solution in a programming language.
Testing and Debugging: Ensuring the program works correctly.
Documentation: Writing clear explanations and comments.

38.
Elaborate on the various types of errors in programming with examples.

Syntax Errors: Mistakes in the code's structure (e.g., missing semicolon).

Runtime Errors: Errors that occur during program execution (e.g., division by zero).
Logical Errors: Incorrect logic that produces wrong results (e.g., incorrect condition in an if statement).

39.
Explain the significance and application of arrays in problem-solving.

Arrays are significant for storing and managing collections of data efficiently. They allow for fast access and manipulation of data.
Applications include sorting algorithms, matrix operations, and storing multiple values in a single variable.

40.
What are programming methodologies? Compare top-down and bottom-up approaches.
 Programming Methodologies: Different approaches to software development (e.g., structured, object-oriented).
Top-Down Approach: Starts with the main problem and breaks it down into smaller parts.
Bottom-Up Approach: Starts with solving smaller problems and integrating them into a larger solution.
Comparison: Top-down focuses on the overall structure first, while bottom-up builds from the details.

12 Marks Questions
41.
Describe the different characteristics of computers and their real-world applications.

Speed: Computers process data quickly, enabling fast computations in scientific research.
Accuracy: High precision in calculations, crucial for applications like medical imaging.
Storage: Large capacity to store data, used in data centers and cloud computing.
Automation: Perform repetitive tasks without human intervention, used in manufacturing.
Versatility: Ability to perform various tasks, from word processing to complex simulations.
Real-World Applications: Banking (transactions), Education (e-learning), Healthcare (diagnostics), Business (data analysis).

42.
Illustrate the process of program verification with an example.

Process:

Specification: Define the requirements and expected behavior.

Implementation: Write the program code.
Verification: Ensure the program meets the specifications.
Example:

Specification: Program to calculate the factorial of a number.

Implementation: Code in C using a loop.
 Verification: Test with known inputs (e.g., factorial of 5 is 120).

43.
Explain in detail the evolution of computers through their five generations.

First Generation (1940-1956): Vacuum tubes, large size, high power consumption.
Second Generation (1956-1963): Transistors, smaller size, more reliable.
Third Generation (1964-1971): Integrated circuits, increased speed, and efficiency.
Fourth Generation (1971-present): Microprocessors, personal computers, GUIs.
Fifth Generation (present and beyond): Artificial intelligence, parallel processing, quantum computing.

44.
Discuss the problem-solving aspects and the top-down approach in program design.

Problem-Solving Aspects:

Understanding the Problem: Analyzing requirements and constraints.

Designing the Algorithm: Creating a logical solution.
Implementing the Solution: Writing code in a programming language.
Testing and Debugging: Ensuring correctness.

Top-Down Approach:

Main Problem Breakdown: Dividing the problem into smaller sub-problems.

Modular Design: Writing and testing individual modules.
Integration: Combining modules to form the complete solution.
Example: Designing a library management system by breaking it into modules like book catalog, user management, and borrowing
 system.

45.
Design a flowchart for calculating the factorial of a number and explain the steps involved.

Flowchart Steps:

1. Start
2. Input number (n)
3. Initialize factorial (fact) to 1
4. Loop from 1 to n
5. Multiply fact by loop variable
6. End loop
7. Output fact
8. End

46.
What is structured programming? Explain its concepts and advantages with an example program.

Structured Programming: A programming paradigm that emphasizes the use of functions and control structures to improve clarity and
maintainability.
Concepts:

Modularity: Breaking the program into smaller, manageable functions.

Control Structures: Using sequences, selections, and iterations.

Advantages:
 Improved Readability: Clear structure and flow.
Easier Maintenance: Simplified debugging and updating.
Reusability: Functions can be reused in different programs.

Example Program: A C program to check if a number is prime using functions and loops.

47.
Explain the basic modules of a computer with a detailed diagram and their interconnectivity.

Basic Modules:

CPU (Central Processing Unit): Executes instructions.

Memory (RAM and ROM): Stores data and instructions.
Input Devices: Allow user input (e.g., keyboard, mouse).
Output Devices: Display output (e.g., monitor, printer).
Storage Devices: Store data (e.g., hard drive, SSD).
Motherboard: Connects all components.

Interconnectivity: The CPU communicates with memory and I/O devices through buses (data, address, control).

48.
Develop an algorithm to find the largest element in an array and write its flowchart.

Algorithm:

1. Start
2. Input the array and its size
3. Initialize the largest element as the first element
4. Loop through the array
5. If the current element is larger, update the largest element
 6. End loop
7. Output the largest element
8. End

Flowchart: (Follow the algorithm steps to create the flowchart symbols)

49.
Write detailed notes on debugging, types of errors, and their resolution techniques.

Debugging: The process of identifying and fixing errors in a program.

Types of Errors:

Syntax Errors: Violations of language rules.

Runtime Errors: Errors that occur during execution.
Logical Errors: Incorrect logic leading to wrong results.

Resolution Techniques:

Syntax Errors: Fix code structure and syntax.

Runtime Errors: Use debugging tools to trace and resolve.
Logical Errors: Review and correct the logic.

50.
Compare and contrast arrays and pointers with real-life applications in programming.

Arrays:

Definition: Collection of elements of the same type.

Usage: Suitable for fixed-size collections.
 Example: Storing student grades.

Pointers:

Definition: Variables that store memory addresses.

Usage: Dynamic memory allocation, linked lists.
Example: Implementing data structures like linked lists.

51.
Create a flowchart for calculating the area of different shapes (circle, rectangle, triangle).

Flowchart Steps:

1. Start
2. Input shape type
3. Based on shape type, input relevant dimensions
4. Calculate area using appropriate formula
5. Output the area
6. End

52.
Discuss the various debugging techniques in software development with examples.

Techniques:

Manual Debugging: Reviewing code and logic.

Print Statements: Inserting print statements to track values.
Debugging Tools: Using tools like GDB, Visual Studio Debugger.
 Example: Using breakpoints and step execution to find errors in a loop.

53.
Compare and contrast arrays and structures with examples in C/C++.

Arrays:

Definition: Collection of elements of the same type.

Example: int arr[5] = {1, 2, 3, 4, 5};

Structures:

Definition: Collection of variables of different types.

Example:

Copy code

struct Student { int id; char name[50]; float marks; };

54.
Explain the concept of program implementation using structured programming methodologies.

Concept: Breaking down a program into smaller, manageable functions or modules.

Implementation Steps:

Design Modules: Identify and design individual modules.

Write Functions: Implement functions for each module.
Test Individually: Test each function separately.
Integrate: Combine functions to form the complete program.

Example: Implementing a library management system by creating modules for book catalog, user management, and borrowing system.

55.
Discuss top-down and bottom-up programming in detail with practical examples.

Top-Down Programming:

Approach: Start with the main problem and break it down into smaller parts.
Example: Designing a payroll system starting with the main module and breaking it into employee management, salary calculation, and report
generation.

Bottom-Up Programming:

Approach: Start with solving smaller problems and integrate them.

Example: Developing utility functions first and then combining them to form a complete program.

56.
 Write a detailed explanation of computer generations, focusing on the fourth and fifth generations.

First Generation (1940-1956): Vacuum tubes, large size, high power consumption.
Second Generation (1956-1963): Transistors, smaller size, more reliable.
Third Generation (1964-1971): Integrated circuits, increased speed and efficiency.
Fourth Generation (1971-present): Microprocessors, personal computers, GUIs, high-level languages, networking.
Fifth Generation (present and beyond): Artificial intelligence, parallel processing, quantum computing, natural language processing.

57.
Write a short note on computer documentation.

Computer documentation involves writing detailed descriptions, explanations, and instructions related to software and hardware. It includes user
manuals, technical specifications, and code comments, aiding in understanding, maintenance, and usage.

58.
Explain the concept of top-down and bottom-up programming with examples.

Top-Down Programming:

Start with the main problem and break it down into smaller parts.
Example: Designing a library management system starting with the main module and breaking it into book catalog, user management, and
borrowing system.

Bottom-Up Programming:

Start with solving smaller problems and integrate them.

Example: Developing utility functions first and then combining them to form a complete program.
59.
Describe the concept of program verification with a real-life analogy.

Program verification ensures that a program correctly implements the intended algorithm and meets its specifications. Analogy:
Verifying a recipe by checking if the final dish matches the expected taste and appearance, ensuring all steps were followed correctly.

60.
Compare the characteristics of the second and fourth generations of computers.

Second Generation:

Technology: Transistors.
Size: Smaller than the first generation.
Speed: Faster than the first generation.
Usage: Business applications, scientific calculations.

Fourth Generation:

Technology: Microprocessors.
Size: Much smaller, personal computers.
Speed: Significantly faster.
Usage: Personal computing, networking, and advanced applications.

61.
Explain the importance of arrays in structured programming.

Arrays provide a way to store multiple elements of the same type in a single variable, allowing for efficient data management and manipulation. They
are essential for implementing various algorithms and data structures, such as sorting and searching.
62.
How can debugging be automated? Discuss tools and techniques.

Debugging can be automated using tools and techniques like:

Static Analysis Tools: Analyze code without executing it (e.g., linting tools).
Automated Testing: Writing test cases to automatically check for errors.
Continuous Integration (CI): Integrating automated testing in the development pipeline.
Tools: GDB, Visual Studio Debugger, Jenkins for CI.

63.
Explain the advantages and disadvantages of decision tables.

Advantages:

Systematic representation of complex decision logic.

Simplifies understanding and communication.
Helps in identifying all possible conditions and actions.

Disadvantages:

Can become large and complex for many conditions.

May be difficult to update and maintain.

64.
Discuss the significance of proper documentation in software development.
 Proper documentation ensures that the software is understandable, maintainable, and usable. It helps developers understand the code, allows for easier
debugging and updates, and provides users with instructions on how to use the software.

65.
What are the key elements of structured programming? Illustrate with an example.

Key Elements:

Modularity: Breaking the program into smaller functions.

Control Structures: Using sequences, selections, and iterations.
Example: A C program that uses functions to perform different tasks, such as input, processing, and output.

66.
Write a flowchart for finding the sum of all elements in an array.

Flowchart Steps:

1. Start
2. Input the array and its size
3. Initialize sum to 0
4. Loop through the array
5. Add each element to sum
6. End loop
7. Output the sum
8. End

67.
 Discuss the various types of errors encountered during the programming phase.

Syntax Errors: Violations of the programming language rules (e.g., missing semicolon).
Runtime Errors: Errors that occur during program execution (e.g., division by zero).
Logical Errors: Incorrect logic that leads to incorrect results (e.g., wrong condition in an if statement).

68.
What are the key differences between problem-solving and implementation phases in program design?

Problem-Solving Phase:

Analyzing the problem.

Designing the algorithm.
Creating flowcharts or pseudocode.

Implementation Phase:

Writing code in a programming language.

Testing the program.
Debugging and refining the code.

69.
Compare the features of fifth-generation computers with earlier generations.

Fifth Generation:

Use of artificial intelligence and parallel processing. Advanced

user interfaces and natural language processing.
 Earlier Generations:
First Generation: Vacuum tubes, large size. Second
Generation: Transistors, smaller size.
Third Generation: Integrated circuits, increased speed. Fourth
Generation: Microprocessors, personal computers.

70.
What are the advantages of using algorithms?

Algorithms provide a clear and structured way to solve problems, ensuring consistency and accuracy. They help in breaking down complex problems
into manageable steps and are essential for efficient program design and implementation.

71.
List two examples of debugging tools.

GDB (GNU Debugger) and Visual Studio Debugger.

72.
What is program design?

Program design is the process of planning and creating the structure and flow of a program, including defining the algorithms, data structures, and
control logic.

73.
Define decision-making structures in programming.
 Decision-making structures are constructs that allow the program to make choices based on conditions (e.g., if-else statements, switch-case).

74.
What are syntax errors in programming?

Syntax errors are mistakes in the code that violate the rules of the programming language, preventing the program from compiling or running correctly.

75.
Briefly define the term "flowchart symbols."

Flowchart symbols are standard shapes used to represent different types of actions or steps in a flowchart, such as process (rectangle), decision
(diamond), and input/output (parallelogram).

76.
Mention two applications of fifth-generation computers.

Artificial intelligence applications (e.g., natural language processing, expert systems) and advanced robotics.

77.
What is the role of algorithms in solving computational problems?

Algorithms provide a step-by-step procedure for solving computational problems, ensuring a systematic approach to achieving the desired outcome
efficiently and correctly.

78.
 Define sequential logic with an example.

Sequential logic is the execution of statements in a specific order, one after the other. Example: Adding two numbers and then printing the result.

79.
What is a subroutine in programming?

A subroutine is a reusable block of code designed to perform a specific task within a program, also known as a function or procedure.

80.
Describe the first-generation computers and their limitations.

First-generation computers used vacuum tubes, were large, expensive, and consumed a lot of power. They were slow, unreliable, and required
specialized maintenance and operation.

81.
Differentiate between system software and application software.

System Software: Manages hardware and provides a platform for running applications (e.g., operating systems, device drivers).
Application Software: Performs specific tasks for users (e.g., word processors, web browsers).

82.
Explain how arrays can be used to store and manipulate data efficiently.

Arrays allow for efficient storage and manipulation of multiple elements of the same type. They provide fast access to elements using indices and are
essential for implementing algorithms like sorting and searching.
83.
What is program verification, and why is it important?

Program verification ensures that a program correctly implements the intended algorithm and meets its specifications. It is important to ensure the
reliability and correctness of the software.

84.
Describe the bottom-up programming methodology with its advantages.

Bottom-up programming starts with developing and testing individual modules or functions, which are then integrated to form the complete program.
Advantages: Easier debugging, better code reuse, and more manageable development process.

85.
Write a short note on pseudocode and its importance.

Pseudocode is an informal, high-level description of an algorithm using plain language and structured notation. It helps in planning and understanding
the logic of a program before actual coding.

86.
Discuss how debugging improves the efficiency of a program.

Debugging identifies and fixes errors, ensuring the program runs correctly and efficiently. It helps in optimizing code, improving performance, and
preventing crashes or unexpected behavior.

87.
Explain how a flowchart simplifies program logic understanding.
 A flowchart provides a visual representation of the program's logic, making it easier to understand the sequence of steps, identify errors, and
communicate the design to others.

88.
Discuss the role of structured programming in modern software development.

Structured programming improves code readability, maintainability, and reliability by using clear control structures and modular design.
It helps in managing complexity and enhances collaboration among developers.

89.
What are the benefits of using modular programming?

Modular programming allows for dividing a program into smaller, manageable parts (modules or functions), improving code organization,
readability, reusability, and ease of maintenance.

90.
Explain in detail the evolution of programming methodologies from procedural to object-oriented approaches.

Procedural Programming: Focuses on functions and procedures to perform tasks. Example: C.

Structured Programming: Enhances procedural programming with control structures and modular design.
Object-Oriented Programming: Organizes code into objects that encapsulate data and behavior. Example: C++, Java. It supports concepts like
inheritance, polymorphism, and encapsulation, improving code reusability and maintainability.

91.
Create an algorithm and flowchart to determine whether a given number is prime or not.

Algorithm:
 1. Start
2. Input the number (n)
3. If n <= 1, print "Not Prime" and end
4. For i from 2 to sqrt(n)
5. If n is divisible by i, print "Not Prime" and end
6. Print "Prime"
7. End

Flowchart: (Follow the algorithm steps to create the flowchart symbols)

92.
Discuss the techniques of problem-solving in programming with examples of algorithms and flowcharts.

Techniques include understanding the problem, designing algorithms, using pseudocode and flowcharts, implementing the solution in code, and
testing/debugging. Example: Algorithm and flowchart for sorting an array using bubble sort.

93.
Compare and contrast decision tables, flowcharts, and pseudocode as tools for program design.

Decision Tables: Tabular representation of conditions and actions. Useful for complex decision logic.
Flowcharts: Visual representation of the sequence of steps. Useful for understanding and communication.
Pseudocode: High-level description of the algorithm. Useful for planning and transitioning to actual code.

94.
Write a detailed explanation of logical structures (sequence, selection, and iteration) in programming, with examples.

Sequence: Executing statements one after the other. Example: a = b + c; d = a * 2;

Selection: Decision-making structures. Example: if (a > b) { /* code */ } else { /* code */ }
 Iteration: Looping structures. Example: for (int i = 0; i < 10; i++) { /* code */ }

95.
Explain how arrays are used in programming for storing, retrieving, and processing data. Include examples in a language of your choice.

Arrays store multiple elements of the same type, providing fast access and manipulation.
Example in C:

Copy code

int arr[5] = {1, 2, 3, 4, 5}; for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); }

96.
Discuss in detail the role of debugging in software development and the tools and methods used for debugging.

Debugging ensures software correctness and reliability by identifying and fixing errors. Tools include GDB, Visual Studio Debugger, and methods like
breakpoints, step execution, and print statements.

97.
Illustrate and explain the structure and organization of a computer with a labeled diagram and examples of each module.
 Structure and Organization:

CPU: Executes instructions. Example: Intel Core i7.

Memory (RAM and ROM): Stores data and instructions. Example: 16GB DDR4 RAM, 256GB SSD.
Input Devices: Allow user input. Example: Keyboard, Mouse.
Output Devices: Display output. Example: Monitor, Printer.
Storage Devices: Store data. Example: Hard Drive, SSD.
Motherboard: Connects all components.

Diagram: (Include a labeled diagram showing the interconnection of these components)

98.
Design a complete flowchart for a banking system application that includes account creation, deposits, withdrawals, and balance checks.

Flowchart Steps:

1. Start
2. Input operation type (create account, deposit, withdraw, check balance)
3. Based on operation type, perform relevant actions
4. Update account information
5. Output confirmation or balance
6. End

99.
Explain the role of structured programming in software design and development, providing examples and advantages.

Role: Structured programming improves code clarity, maintainability, and reliability by using functions and control structures.
Examples: Using functions in C to perform tasks like input, processing, and output.
 Advantages: Easier debugging, code reuse, better organization.

100.
Design and explain a student management system algorithm that includes adding, deleting, and searching student records. - Algorithm:

1. Start
2. Input operation type (add, delete, search)
3. Based on operation type, perform relevant actions:
Add: Input student details and store in a list
Delete: Input student ID and remove from the list
Search: Input student ID and retrieve details

4. Output confirmation or student details

5. End