FAZAIA INTER COLLEGE KALLAR KAHAR

Unit #2 Solved Exercise

Give short answer of the following Short Response Questions (SRQs).

1. Differentiate between
a. Clarity vs Efficiency
Clarity and efficiency in code are crucial but often opposing qualities. Clarity refers to how
understandable and readable code is, making it easier to debug, maintain, and modify, with well-
organized structure, descriptive names, and meaningful comments. Efficiency, on the other hand,
focuses on optimal resource usage, such as time and memory, requiring optimized algorithms and
data structures. Balancing the two involves trade-offs: clearer code can be less efficient, while highly
efficient code can be harder to understand. The ideal approach depends on the project's
requirements, prioritizing clarity in small projects and efficiency in performance-critical applications.
b. Abstraction vs Pattern Recognition
Abstraction and pattern recognition are key in computational thinking. Abstraction simplifies complex
systems by focusing on essential details and ignoring irrelevant ones, enabling easier management and
problem-solving. Pattern recognition identifies similarities, trends, and regularities in data, aiding in
predicting outcomes and optimizing solutions. Together, they streamline problem-solving by
simplifying tasks and highlighting essential features.
c. Pseudocode vs flowcharts
Pseudocode and flowcharts are tools for planning and visualizing algorithms. Pseudocode uses plain
language to describe the steps of an algorithm, making it easy to write and understand without strict
syntax rules. Flowcharts, on the other hand, use symbols and arrows to represent the flow of a process
visually, providing a clear picture of the algorithm's structure. Both help in designing and
communicating solutions, with pseudocode focusing on detailed step-by-step instructions and
flowcharts emphasizing the overall process flow.
d. Data structures and control structures
Data structures and control structures are fundamental concepts in programming. Data structures
organize and store data efficiently, such as arrays, linked lists, and trees, enabling effective data
manipulation and retrieval. Control structures, like loops, conditionals, and branches, determine the
flow of execution in a program, dictating how and when certain operations are performed. While data
structures manage and hold data, control structures guide the sequence of actions and decisions based
on that data.
e. Algorithm vs Pseudocode
An algorithm is a step-by-step procedure or set of rules designed to perform a specific task or solve a
problem, often described in precise, formal terms. Pseudocode, on the other hand, is a high-level,
informal way of representing an algorithm using plain language and simple notation, making it easier
to understand and communicate the logic without adhering to strict programming syntax. While an
algorithm outlines the overall process, pseudocode provides a readable, intermediary representation
of that process, bridging the gap between conceptual design and actual code implementation.
2. Write note on working of Bubble Sort?
Ans: Bubble sort is a straightforward sorting algorithm that repeatedly steps through the list to be
sorted, compares adjacent elements, and swaps them if they are in the wrong order. The process
continues until the entire list is sorted. Here’s a brief overview of how it works:

1. Initial Pass: Starting from the beginning of the list, compare the first two elements. If the first
element is greater than the second, swap them.
2. Subsequent Passes: Move to the next pair of adjacent elements and repeat the comparison and
swapping process. Continue this process for each pair until the end of the list is reached.
3. End of Pass: After completing a pass through the list, the largest element will be in its correct
position at the end.
4. Repeating: Repeat the process for the remaining unsorted portion of the list (excluding the last
sorted elements). Each subsequent pass will place the next largest element in its correct position.
5. Termination: The algorithm terminates when no more swaps are needed, indicating that the list is
fully sorted.

3. Write names of commonly used computational artifacts made during computational thinking.

1. Algorithms: Step-by-step procedures or formulas for solving problems.

2. Pseudocode: High-level, informal descriptions of algorithms using plain language and simple
notation.
3. Flowcharts: Diagrams that visually represent the flow of a process or algorithm using symbols and
arrows.
4. Data Structures: Methods for organizing and storing data, such as arrays, linked lists, and trees.
5. Control Structures: Constructs that dictate the flow of execution in a program, including loops,
conditionals, and branches.
6. Debugging Statements: Tools and techniques for identifying and fixing errors in code.
7. Models: Abstract representations of systems or processes to analyze and solve problems, such as
mathematical or computational models.

4. Where we prefer to use binary search algorithm rather than linear search algorithm.
We prefer to use the binary search algorithm over the linear search algorithm in scenarios where:
1. The Data is Sorted: Binary search requires that the data be sorted, as it works by repeatedly dividing
the search interval in half. Linear search doesn't have this requirement but is less efficient in such
cases.
2. Large Data Sets: For large datasets, binary search is significantly faster than linear search. Binary
search has

5. What are advantages of using flowcharts?

1. Visual Representation: They provide a clear, visual way to understand and communicate the logic
of a process or algorithm.
2. Easy to Follow: Flowcharts use standardized symbols and arrows, making them easy to follow and
understand.
3. Simplifies Complex Processes: They help break down complex processes into simpler,
manageable steps.
4. Effective for Debugging: Flowcharts can help identify issues and inefficiencies in a process by
visualizing each step.
5. Improves Communication: They facilitate better communication and collaboration by providing a
common, easy-to-understand reference.
 Give long answer of the following Extended Response Questions (ERQs).

1. Determine the properties involved in computational thinking.

Here are the main properties involved IN Computational thinking:
1) Decomposition: Breaking down a complex problem into smaller, more manageable parts. This
makes it easier to understand and solve the problem step by step.
2) Pattern Recognition: Identifying similarities or patterns within problems. Recognizing patterns
can help in predicting future behavior and making solving problems more efficient.
3) Abstraction: Focusing on the important information only, and ignoring irrelevant details. This
helps in simplifying the problem and developing a general solution that can be applied to various
situations.
4) Algorithm Design: Developing a step-by-step procedure or set of rules to solve a problem. This
includes creating algorithms that are clear, efficient, and effective.
5) Evaluation: Assessing the effectiveness and efficiency of the solution. This involves testing and
refining algorithms to ensure they work correctly and optimize performance.
6) Generalization: Extending a solution to solve similar problems. This involves applying the same
solution principles to different but related problems.

2. Sketch an algorithm that inputs length in inches and prints it in centimeter.

1. Start
2. Input the length in inches (let's call it lenInInch)
3. Calculate the length in centimeters using the formula: lenInCen=lenInInch × 2.54
4. Output the length in centimeters (lenInCe)
5. End

3. Implement an algorithm to print multiplication table of a number in reverse order

1. Start
2. Input the number for which the multiplication table is to be printed (let's call it number)
3. Set the variable i to 10 (assuming we want to print the table from 10 to 1)
4. While i is greater than or equal to 1:
o Calculate the product: product = number * i
o Print the result in the format: number * i = product
o Decrement i by 1
5. End

4. A newly developed algorithm needs to be tested. Argue about reasons.

Ans: Testing a newly developed algorithm is crucial for several reasons:
Correctness:
To ensure the algorithm produces accurate and expected results for all given inputs.
Efficiency:
To assess the algorithm’s performance in terms of time and space complexity, ensuring it operates
within acceptable limits.
Clarity:
To verify that the algorithm's logic is clear and understandable, making it easier to maintain and
debug.
Reliability:
To ensure the algorithm consistently performs well under various conditions and can handle
unexpected inputs or edge cases without failing.