Computer Science Class 11 Unit 2: Computational Thinking and Algorithm Question Bank

Abstraction means hiding unnecessary features and focusing only on the essential ones that are needed to solve a problem. In simple terms, it reduces the complexity of an algorithm by ignoring what is not important and concentrating on what truly matters. It is used so that the algorithm stays simple, general and reusable for many similar situations.

• It removes noise, so the logic of the solution is easy to see.
• It makes the algorithm work for many cases, not only one.
• It saves time because we do not design useless details.

We ask three questions: What is necessary? What can change based on situation? What can we ignore?

These are the minimum steps required, regardless of the type of tea: boil water, add tea leaves or a tea bag, steep for a few minutes, pour into a cup, and serve. This is the abstracted process and the key logic of "making tea" in all cases.

Details can vary: the ingredients (black tea, green tea, herbal tea, milk tea), the additions (sugar, honey, milk, lemon), the tools (electric kettle, stove, tea pot) and the time (boiling time and steeping time). These are the inputs or parameters of the algorithm.

The brand of the kettle, the colour or design of the cup, where the tea is being made (kitchen or office) and the type of mug (glass or ceramic) are not important for the main logic. These details add noise and are excluded from the abstraction.

In this way abstraction gives one simple algorithm that works for every cup of tea.

Computational thinking is a systematic way of solving problems. Decomposition and pattern recognition are two of its main techniques, along with abstraction and algorithms. Both of them make a problem simpler before the solution is written.

Decomposition is a problem-solving technique in which a complex task or system is broken down into smaller, manageable parts. It is used in computational thinking and software development, and it is equally useful in daily life.

A person does not learn a whole language at once. The task is broken into subtasks: learn vocabulary, understand grammar rules, learn tenses, practise sentence building, listen and imitate native speakers, and get feedback from a teacher.

• It reduces complexity because we focus on one piece at a time.
• It makes learning manageable and easy to practise in steps.
• It helps in debugging because we can find exactly where the mistake is.
• It promotes reusability: once you learn how to form a sentence, you can apply it to new words.

Pattern recognition is the process of identifying regularities, repetitions or rules in data. To find a pattern we observe the input data and ask: what is repeating, what changes in a predictable way, and can I generalize this?

In the triangle of stars (*, , *, **, ***) the first row shows 1 star, the second 2 stars and so on. The pattern is that each row adds one star to the previous row.

• It helps to discover meaningful relationships among elements.
• It reduces the overall complexity of the algorithm.
• It helps to develop generic and reusable solutions, and it forms the foundation of loops, conditions and data structures.

Decomposition makes a big problem small, and pattern recognition finds the repeated rule inside it, so together they help us to write clear and short algorithms.

Bubble Sort is an elementary sorting algorithm used to arrange the elements of a list in ascending or descending order. It works by repeatedly comparing adjacent elements and swapping them if they are in the wrong order. This process is repeated until the whole list is sorted. It is also called Ripple Sort because the largest value moves to the end in every pass.

• Step 1: Start and set the array DATA and N (the number of items).
• Step 2: Repeat for K = 1 to N-1 (this is the outer loop, one pass for each K).
• Step 3: In each pass set the pointer PTR = 1, and while PTR is less than or equal to N-K: if DATA[PTR] is greater than DATA[PTR+1], swap them using a temporary variable, then increase PTR by 1.
• Step 4: End. The list is now sorted.

Sorted list: 1, 3, 4, 8, 9. After every pass the largest remaining value reaches its final place at the right end.

• Advantages: easy to understand and code; needs no extra memory.
• Disadvantages: nested loops make it slow for big lists, and it makes many swaps.

Selection Sort is a simple sorting algorithm that arranges a list by repeatedly selecting the smallest element from the unsorted portion and moving it to its correct position at the front. After every pass the sorted part of the list grows by one element.

• Step 1: Start and set the array DATA and N.
• Step 2: Repeat for K = 1 to N-1: this position K is the place for the next smallest value.
• Step 3: Set PTR = K+1 and compare DATA[K] with every DATA[PTR] up to N. If DATA[K] is greater than DATA[PTR], swap them, so the smallest value comes to position K. Move PTR forward.
• Step 4: End. The list is sorted.

Sorted list: 1, 3, 4, 8, 9.

• It is easy to code, as it is just two loops: one to track the sorted boundary and one to find the minimum value.
• In each pass it makes at most one final placement, so it is good where moving data is expensive.
• It needs no extra memory.

• It must finish every loop even if the list is already sorted, so it takes the same time for any data.
• It becomes very slow for large data, so it is used only for small datasets.
• Equal items may change their relative order.

Linear search, also known as sequential search, is a simple searching algorithm used to find a specific element in a list. It works by examining each element one by one, from the beginning, until the target is found or all the elements have been checked. It works on both sorted and unsorted lists.

• Step 1: Start. Set DATA (the list), N (the number of items) and FindValue (the item to search).
• Step 2: Set ValueFound = 0, where 0 means not found and 1 means found.
• Step 3: Repeat for PTR = 1 to N: if DATA[PTR] is equal to FindValue, set ValueFound = 1 and stop the loop.
• Step 4: If ValueFound = 1 print the data, otherwise print "Data not found". End.

The item is found at the 5th position.

• Advantages: it works on any list (sorted or scrambled), the code is very simple, and it needs no extra space.
• Disadvantages: if the list has 1 million items and the target is at the end, it makes 1 million checks, and its time grows linearly with the list size.

Binary search is a highly efficient searching algorithm that works by repeatedly dividing the search interval in half. It compares the middle element with the target: if they are equal the search is successful, if the target is smaller it continues in the left half, and if it is larger it continues in the right half. The list must be sorted.

• Step 1: Start. Take a sorted array. Set BEG = 1 (beginning) and END = last position (here 8).
• Step 2: Find the middle position: MID = INT((BEG + END) / 2). INT changes a decimal result into an integer.
• Step 3: Repeat while BEG is less than or equal to END and DATA[MID] is not equal to the item: if the item is smaller than DATA[MID] set END = MID - 1, otherwise set BEG = MID + 1. Find a new MID.
• Step 4: If DATA[MID] equals the item, the location is MID. Otherwise the item is not found. End.

It works only on a sorted list. If the data is scrambled, the logic fails.

Binary Search is the best searching algorithm for large datasets, provided that the data is sorted. The answer depends on the speed of the algorithm as the number of items grows.

It cuts the search area in half at every single step. So an item in a list of 1 million elements can be found in about 20 steps, whereas Linear Search may need 1 million checks. Whether the list has 1,000 items or 1 billion items, Binary Search stays very fast.

Linear Search checks the elements one by one, so if the target is at the very end the algorithm has to perform all the checks. If the size of the list is doubled, the search time is also doubled.

The data must already be in order. If the list is not sorted, it must be sorted first, which takes extra time. If we have to search only once in unsorted data, Linear Search may actually be faster. But for a static, sorted list (like a dictionary or a phone book) that is searched thousands of times, sorting once and using Binary Search saves a massive amount of time.

Conclusion: Linear Search is used for unsorted and small datasets. Binary Search is used for sorted and large datasets that need fast searching.

There are many ways to solve a problem, so we need criteria to judge how good an algorithm is. The three most important criteria used to assess the quality of an algorithm are correctness, efficiency and clarity.

An algorithm is correct if its output matches the expected outcome for the given input. We check whether it solves the problem exactly as defined in the requirements, whether it handles typical inputs gracefully (negative numbers, null values, empty strings or maximum-capacity data) and whether it is guaranteed to finish its execution and avoid an infinite loop. Example: the even/odd check (IF number MOD 2 = 0 THEN display Even, ELSE display Odd) is correct because it always decides properly.

Efficiency is measured by the time and the space (memory) that an algorithm uses as the input grows. Time (speed) means how fast it runs and space means how much memory it needs. We ask: does it scale well with larger inputs, is there a way to make it faster or use less memory, and is it optimized for real-world use? Example: Linear Search is less efficient than Binary Search for large sorted data.

An algorithm must be easy to read, easy to understand and easy to modify by other users. For clarity: the steps are clearly written, variable names are meaningful, the logic is shown with indentation and comments, and the flow of control (IF, LOOP and so on) is easy to follow.

A good algorithm should be correct first, then efficient, and it should also be clear so that other people can understand and maintain it.

An even number is exactly divisible by 2 (the remainder is 0), and an odd number leaves a remainder of 1. The MOD operation gives the remainder after division, so we can use it to check a number. For example, 6 MOD 2 = 0 (even) and 7 MOD 2 = 1 (odd).

Step 1 takes the number from the user. Step 2 divides it by 2 and checks whether the remainder is 0. If yes, step 3 displays "Even". Otherwise step 5 displays "Odd". Step 6 closes the decision.

The algorithm is correct because it always determines even or odd properly for every input.

It can be difficult to decide which algorithm is best for a problem. Before deciding, we should think about the problem and the data. Choosing the wrong algorithm can waste a lot of time and memory.

• What is the type of problem (searching, sorting or something else)?
• What is the input size (small or large)?
• Is the data sorted or unsorted?
• Do we need speed and memory efficiency?

Problem: find a number in a sorted list. Is the data sorted? Yes. Is a fast result needed? Yes. So the correct choice is Binary Search.

Sorting and searching are fundamental techniques of computer science and data analysis. Both work on lists of data of the same type, such as a student's name, father's name or age.

Sorting is the process of arranging a collection of items or data in a specific order. It may be ascending (lowest to highest, 0 to 9, a to z, A to Z), descending (highest to lowest) or chronological. It is used to organize data so that it becomes easier to use for searching, retrieval and analysis. Common sorting algorithms are Bubble Sort and Selection Sort.

Searching is the process of locating a specific element within a list of data. Searching algorithms are designed to find the position, the existence or the value of a target element in an efficient and systematic way, for example finding a student's name in the class list. Common searching algorithms are Linear Search and Binary Search.

• Database queries: finding and arranging records.
• Online shopping filters: sorting by price and searching by name.
• Leaderboards: sorting scores in descending order.
• File organization: arranging files by name or date.
• Recommendation systems: searching and ordering suggestions.

Without sorting and searching, working with large amounts of data would be very slow.

An algorithm is a step-by-step logical procedure used to solve a problem. It is conceptual in nature and independent of any programming language. Algorithms are vital because they provide clear and efficient solutions. Without algorithms we would have to reinvent the wheel every time we face a challenge.

• They provide a structured approach to problem-solving, which makes complex tasks easier to understand and execute.
• They help in selecting solutions that save time and memory, which is crucial for large-scale applications.
• Once developed, an algorithm can be reused for similar problems, saving both time and effort.
• They ensure accuracy and consistency, producing correct results and reducing the chance of human error.
• Every computer program is built upon algorithms, and they serve as a blueprint before the actual code is written.

Pseudocode is a human-readable representation of an algorithm using plain English and structured programming keywords (IF, FOR, WHILE). It is not executable code but shows how the algorithm can be implemented in a readable format before actual coding.