Samacheer Kalvi Class 12 Computer Science Solutions Chapter 2 Data Abstraction

I. Choose The Best Answer (1 Marks)

 

Question 1. Which of the following functions build the abstract data type?
(a) Constructors
(b) Destructors
(c) recursive
(d) Nested
Answer: (a) Constructors
In simple words: Constructor functions are special tools used to create new objects and set up their initial state in a program. They help put together the basic structure of a data type.

🎯 Exam Tip: Remember that constructors are always about creating or building, which helps distinguish them from functions that retrieve or modify data.

 

Question 2. Which of the following functions retrieve information from the data type?
(a) Constructors
(b) Selectors
(c) recursive
(d) Nested
Answer: (b) Selectors
In simple words: Selector functions are used to get specific pieces of data or information out of an existing object. Think of them as tools to look inside and pick out what you need.

🎯 Exam Tip: Selectors are key for accessing internal data without needing to know exactly how it's stored, which is a core idea of data abstraction.

 

Question 3. The data structure which is a mutable ordered sequence of elements is called
(a) Built-in
(b) List
(c) Tuple
(d) Derived data
Answer: (b) List
In simple words: A list is a type of data storage that can hold many items in a specific order, and you can change or rearrange these items after creating the list. Lists are very flexible for storing collections of data.

🎯 Exam Tip: The key characteristic of a list is its mutability, meaning elements can be added, removed, or changed after the list is created.

 

Question 4. A sequence of immutable objects is called
(a) Built-in
(b) List
(c) Tuple
(d) Derived data
Answer: (c) Tuple
In simple words: A tuple is like a list, but once you create it, you cannot change its contents. It's a fixed collection of items that stays the same.

🎯 Exam Tip: The main difference between a tuple and a list is that tuples are immutable (cannot be changed), while lists are mutable (can be changed).

 

Question 5. The data type whose representation is known is called
(a) Built-in data type
(b) Derived data type
(c) Concrete data type
(d) Abstract data type
Answer: (c) Concrete data type
In simple words: A concrete data type is one where you know exactly how the data is stored and organized inside the computer. This means its internal structure is fully visible.

🎯 Exam Tip: Concrete data types show all the details of their implementation, which is different from abstract data types that hide these details.

 

Question 6. The data type whose representation is unknown are called
(a) Built-in data type
(b) Derived data type
(c) Concrete data type
(d) Abstract data type
Answer: (d) Abstract data type
In simple words: An abstract data type (ADT) is a data type where you only know what it does, but not how it does it. The way the data is stored and the operations work is hidden from you.

🎯 Exam Tip: Abstract data types (ADTs) focus on the 'what' (behavior) rather than the 'how' (implementation), promoting data hiding and modularity.

 

Question 7. Which of the following is a compound structure?
(a) Pair
(b) Triplet
(c) single
(d) quadrat
Answer: (a) Pair
In simple words: A pair is a simple compound structure because it bundles two different values together into one single unit. This allows related data to be treated as a whole.

🎯 Exam Tip: Compound structures combine multiple individual data items into a single, more complex item, like combining two values to form a pair.

 

Question 8. Bundling two values together into one can be considered as
(a) Pair
(b) Triplet
(c) single
(d) quadrat
Answer: (a) Pair
In simple words: When you combine two items into a single unit, you are essentially creating a pair. This is a basic way to group related data.

🎯 Exam Tip: The term "pair" directly implies a collection of two items, making it the most accurate choice for bundling two values.

 

Question 9. Which of the following allows to name the various parts of a multi-item object?
(a) Tuples
(b) Lists
(c) Classes
(d) quadrats
Answer: (c) Classes
In simple words: Classes are like blueprints that let you create objects and give names to their different parts or characteristics. This helps organize complex information by giving meaningful labels to each piece of data.

🎯 Exam Tip: Classes are fundamental in object-oriented programming for defining custom data types with named attributes and methods.

 

Question 10. Which of the following is constructed by placing expressions within square brackets?
(a) Tuples
(b) Lists
(c) Classes
(d) quadrats
Answer: (b) Lists
In simple words: In many programming languages, lists are created by putting items inside square brackets, like `[item1, item2, item3]`. This is a common way to make an ordered collection of data.

🎯 Exam Tip: Always associate square brackets `[]` with lists and parentheses `()` with tuples when defining data structures in programming.

 

II. Answer The Following Questions (2 Marks)

 

Question 1. What is abstract data type?
Answer: An Abstract Data Type (ADT) is like a blueprint for objects. It defines what actions (operations) can be performed on the data and what values the data can hold. Importantly, an ADT only describes *what* the operations do, not *how* they are actually carried out or implemented. This hides the complex details from the user. It helps in managing complex systems by presenting a simpler view to the user.
In simple words: An ADT tells you what you can do with data, but not how it works inside. It focuses on the outer behavior rather than the inner details.

🎯 Exam Tip: The core concept of an ADT is data abstraction: separating the interface (what it does) from the implementation (how it does it).

 

Question 2. Differentiate constructors and selectors.
Answer:

Constructors create new instances of a data type, setting up its initial state. Selectors, on the other hand, allow you to access and view the individual pieces of data stored within an existing instance. Both are essential for working with abstract data types.
In simple words: Constructors create new data objects, while selectors get specific information out of those objects. One builds, the other reads.

🎯 Exam Tip: To score full marks, clearly state that constructors create and initialize data, while selectors extract and provide access to data.

 

Question 3. What is a Pair? Give an example.
Answer: A pair is a compound structure, often seen as a list or tuple with exactly two elements. It allows you to bundle two related values together into a single unit. This helps to group information that naturally belongs together. For example, if you have `Pr = [10, 20]`, then `a, b := Pr` would assign the value `10` to `a` and `20` to `b`.
In simple words: A pair is just two things bundled into one unit. For example, `[10, 20]` is a pair, where 10 is the first item and 20 is the second.

🎯 Exam Tip: When defining a pair, always provide an example that clearly shows two distinct values being grouped, such as coordinates or related properties.

 

Question 4. What is a List? Give an example.
Answer: A list is a data structure created by putting different expressions or values inside square brackets `[]`, separated by commas. Lists are ordered sequences of elements and are mutable, meaning their contents can be changed after creation. This flexibility makes them very useful for dynamic collections of data. For example, `[10, 20]` is a list containing two integer values.
In simple words: A list is an ordered collection of items, written inside square brackets `[]`. You can change the items in a list whenever you want.

🎯 Exam Tip: Remember to mention both square brackets and mutability when describing lists, as these are their defining features.

 

Question 5. What is a Tuple? Give an example.
Answer: A tuple is a data structure that represents an ordered sequence of values, typically surrounded by parentheses `()`. Unlike lists, tuples are immutable, which means once they are created, their elements cannot be changed, added, or removed. This makes them suitable for storing fixed collections of data. For example, `('red', 'blue', 'green')` is a tuple representing a sequence of colors.
In simple words: A tuple is an ordered collection of items, written inside round brackets `()`. Once created, you cannot change the items in a tuple.

🎯 Exam Tip: Emphasize the immutability of tuples and the use of parentheses as their key characteristics compared to lists.

 

III. Answer The Following Questions (3 Marks)

 

Question 1. Differentiate Concrete Data Type and Abstract Data Type
Answer:

Concrete data types show all the details of how data is stored and managed. On the other hand, Abstract Data Types hide these internal details, only exposing the operations that can be performed on the data. This hiding of details is known as abstraction, which helps manage complexity.
In simple words: Concrete data types show you all their inner workings, while abstract data types only show you what they can do, keeping the internal structure a secret.

🎯 Exam Tip: The core distinction lies in whether the implementation details are visible (concrete) or hidden (abstract). Mentioning "representation known" vs. "representation unknown" is crucial.

 

Question 2. Which strategy is used for program designing? Define that Strategy.
Answer: The strategy used for program designing is 'Wishful Thinking'. Wishful Thinking is a design approach where you imagine that certain functions or components already exist and work perfectly, even if they haven't been created yet. You pretend they are already there, helping you to make decisions and build your program's structure based on what would be ideal, rather than being limited by current realities. This approach helps in focusing on the overall design before getting bogged down in implementation details.
In simple words: We use 'Wishful Thinking' to design programs. This means we pretend that all the parts we need already work, which helps us plan the program without worrying about how to build each piece right away.

🎯 Exam Tip: Clearly define Wishful Thinking as designing based on an ideal scenario, temporarily ignoring implementation constraints to focus on overall structure.

 

Question 3. Identify Which of the following are constructors and selectors?
(a) N1=number()
(b) accetnum(n1)
(c) displaynum(n1)
(d) eval(a/b)
(e) x,y= makeslope (m), makeslope(n)
(f) display()
Answer:

Functions that create or initialize new data (like `number()` or `makeslope()`) are constructors. Functions that access, display, or calculate information from existing data (like `accetnum()`, `displaynum()`, `eval()`, `display()`) are selectors. Understanding this difference helps manage data correctly in programs.
In simple words: Constructors build or make new data, while selectors retrieve or show existing data.

🎯 Exam Tip: When identifying constructors and selectors, look for functions that typically create new objects (constructors) versus those that access or operate on existing objects (selectors).

 

Question 4. What are the different ways to access the elements of a list. Give example
Answer: List elements can be accessed in two main ways: 1. **Multiple Assignments (Unpacking):** This method involves assigning the elements of a list directly to individual variable names. The list is 'unpacked', and each element is bound to a separate variable. This works well for lists with a known, small number of elements. Example: `first_list = [10, 20]` `x, y = first_list` In this example, `x` will get the value `10`, and `y` will get `20`. 2. **Element Selection Operator (Square Brackets):** This method uses square brackets `[]` with an index number to pick a specific element from the list. The index indicates the position of the element, starting from 0 for the first element. Example: `first_list = [10, 20]` `print(first_list[0])`
This will output `10`. `print(first_list[1])`
This will output `20`. Both methods allow programmers to retrieve and use specific values stored within a list, providing flexibility depending on the programming task.
In simple words: You can get items from a list in two ways: either by giving each item its own name when you unpack the list, or by asking for an item using its position number with square brackets.

🎯 Exam Tip: Illustrate both methods with clear, simple examples to show a complete understanding of list element access.

 

Question 5. Identify Which of the following are List, Tuple and class ?
(a) arr [1, 2, 34]
(b) arr (1, 2, 34)
(c) student [rno, name, mark]
(d) day= ('sun', 'mon', 'tue', 'wed')
(e) x= [2, 5, 6.5, [5, 6], 8.2]
(f) employee [eno, ename, esal, eaddress]
Answer:

Lists are identified by square brackets `[]` and tuples by parentheses `()`. Classes are defined by naming attributes (like `rno`, `name`, `mark`) for a concept like `student` or `employee`. Correctly identifying these structures is key to working with different data types in programming.
In simple words: Square brackets `[]` mean it's a list. Round brackets `()` mean it's a tuple. When you see names for different parts inside brackets, it's usually defining a class structure.

🎯 Exam Tip: Pay close attention to the type of brackets used (`[]` for lists, `()` for tuples) and the context (defining named attributes for a blueprint usually indicates a class). If a collection uses named fields, it is a class.

 

IV. Answer The Following Questions (5 Marks)

 

Question 1. How will you facilitate data abstraction? Explain it with a suitable example.
Answer: Data abstraction can be facilitated by creating two primary types of functions: Constructors and Selectors. 1. **Constructors:** These are functions used to build or create an abstract data type. They take the raw data and package it into a structured form, initializing the object. 2. **Selectors:** These are functions used to retrieve specific pieces of information from an already created abstract data type. They allow access to the data without exposing its internal storage mechanism. **Example:** Let's consider creating an abstract data type called "City". * We want a `City` object to store its `name`, `latitude`, and `longitude`. * **Constructor:** We can define a constructor function `makecity(name, lat, lon)`. When we call `city = makecity("New York", 40.71, -74.00)`, it creates a new `City` object and sets its internal values. This function hides how "New York", 40.71, and -74.00 are actually stored inside the `city` object. * **Selectors:** To get information from the `city` object, we would use selector functions: * `getname(city)` would return "New York". * `getlat(city)` would return 40.71. * `getlon(city)` would return -74.00. These selector functions extract the desired information without requiring us to know the internal structure of the `city` object. This separation of "what" (the city data) from "how" (its internal storage and retrieval) is the essence of data abstraction.
In simple words: To make data abstraction work, we use two kinds of functions: 'constructors' to build a data item, and 'selectors' to get information out of it. For example, `makecity` builds a city object, and `getname` gets the city's name.

🎯 Exam Tip: Use a clear, real-world example like 'City' with distinct constructor and selector functions to demonstrate how abstraction hides implementation details.

 

Question 2. What is a List? Why List can be called as Pairs. Explain with suitable example
Answer: A List is a fundamental compound structure in programming, particularly in languages like Python. It is an ordered collection of elements enclosed in square brackets `[]` and separated by commas. Lists are mutable, meaning their elements can be changed, added, or removed after the list is created. Some languages provide a compound structure called 'Pair' which is often implemented using lists or tuples. **Why a List can be called as Pairs:** The first way to implement pairs is by using the List construct because a list can easily hold two values. * The list is constructed by placing expressions within square brackets, separated by commas. * Such an expression is called a list literal. * Each value in a list can be of any type and can even be another list. The elements of a list can be accessed in two primary ways: 1. **Multiple Assignments (Unpacking):** If a list contains exactly two elements, you can assign them to two variables directly. Example: `my_pair = [10, 20]`
`x, y = my_pair` Here, `x` becomes 10 and `y` becomes 20. This essentially treats the list `my_pair` as a pair of values. 2. **Element Selection Operator:** You can also access elements using square brackets with their index. Example: `my_pair[0]` would give `10`, and `my_pair[1]` would give `20`. Because a list can hold two values and those values can be easily accessed or unpacked, a list can effectively function as a "Pair" when it specifically contains two elements. This approach simplifies handling related data that often comes in pairs, like coordinates `[x, y]` or a key-value pair `[key, value]`.
In simple words: A list is a collection of items in square brackets that can be changed. If a list only has two items, it acts like a "pair" because you can easily get both items out, making it good for grouping two related pieces of information.

🎯 Exam Tip: Clearly define a list, then explain how its ability to store and unpack two values allows it to serve the purpose of a "pair," using examples like `[x, y]` to illustrate.

 

Question 3. How will you access the multi-item? Explain with example.
Answer: To access a multi-item object (an object with multiple parts), we typically use a "structure construct," which is called a "class construct" in Object-Oriented Programming (OOP) languages. This allows us to represent objects where each part has a specific name. Let's consider an example using pseudo-code for a `Person` class: `class Person:` `creation()` `firstName := ""` `lastName := ""` `id := ""` `email := ""` This `Person` class is a blueprint that defines how a person's data is structured, with named fields like `firstName`, `lastName`, `id`, and `email`. **Pictorial Representation:**

**Accessing Multi-Items (Fields/Attributes):** Once an object is created from a class, its individual parts (attributes or fields) can be accessed using the dot (`.`) operator, followed by the field's name. Example: If we create an instance of the `Person` class: `p1 := Person()`
\( \implies \) This statement creates a new object named `p1` of type `Person`. Now, we can set and access its fields: * `p1.firstName := "Padmashri"`
\( \implies \) This sets the `firstName` field of `p1` to "Padmashri". * `p1.lastName := "Basker"`
\( \implies \) This sets the `lastName` field of `p1` to "Basker". * `p1.id := "994-222-1234"`
\( \implies \) This sets the `id` field of `p1` to "994-222-1234". * `p1.email := "compsci@gmail.com"`
\( \implies \) This sets the `email` field of `p1` to "compsci@gmail.com". To access the `firstName`, you would simply use `p1.firstName`, which would output "Padmashri". This method allows for organized and named access to individual components of a complex object.
In simple words: To get parts of a multi-item object, we use a 'class' like a recipe. Once we make an object from this recipe, we can reach its parts (like a `person`'s `name` or `email`) using a dot. For example, `p1.firstName` would give us the first name of person `p1`.

🎯 Exam Tip: Focus on explaining classes as blueprints for multi-item objects and demonstrate access using the dot operator (`object.field_name`) with a clear example.

 

12th Computer Science Guide Data Abstraction Additional Questions And Answers

 

I. Choose The Best Answer (1 Mark)

 

Question 1. How many types of functions are needed to facilitate abstraction?
(a) 1
(b) 2
(c) 3
(d) 4
Answer: (b) 2
In simple words: You need two main types of functions to help with abstraction: one to build the data and another to get information from it.

🎯 Exam Tip: The two types of functions essential for abstraction are constructors (to create) and selectors (to retrieve).

 

Question 2. Expansion of CDT is ..........
(a) Collective Data Type
(b) Class Data Type
(c) Concrete Data Type
(d) Central Data Type
Answer: (c) Concrete Data Type
In simple words: CDT stands for Concrete Data Type, which is a data type where all its details are fully visible.

🎯 Exam Tip: Knowing common acronyms like CDT (Concrete Data Type) and ADT (Abstract Data Type) is important for computer science terminology.

 

Question 3. To facilitate data abstraction we need to create types of functions
(a) 2
(b) 3
(c) 4
(d) 5
Answer: (a) 2
In simple words: You need two kinds of functions to make data abstraction work: one to make the data (constructors) and one to read information from it (selectors).

🎯 Exam Tip: Remember that constructors build the data type, and selectors retrieve information from it. Both are crucial for abstraction.

 

Question 4. ................................... is the representation for ADT.
(a) List
(b) Classes
(c) Int
(d) Float
Answer: (b) Classes
In simple words: Classes show how an Abstract Data Type (ADT) is set up.

🎯 Exam Tip: Understand that a class is a blueprint for creating objects, which are instances of an ADT, defining its structure and behavior.

 

Question 5. Which of the following is contracted by placing expressions within square brackets separated by commas?
(a) Tuple
(b) List
(c) Set
(d) Dictionary
Answer: (b) List
In simple words: We make a list by writing things inside square brackets `[ ]` and putting commas between them.

🎯 Exam Tip: Note the specific syntax for lists (square brackets) versus tuples (parentheses) or sets (curly braces) for easy identification.

 

Question 6. The list is constructed by using .................... and ....................
(a) ();
(b) [ ],
(c) < >.;
(d) []
Answer: (b) [ ],
In simple words: You make a list by putting things inside square brackets `[ ]`.

🎯 Exam Tip: Pay attention to the correct syntax for creating data structures in programming languages; square brackets indicate a list.

 

Question 7. Identify the constructor from the following
(a) City = makecity(name, lat, lon)
(b) getname(city)
(c) getlat(city)
(d) getlon(city)
Answer: (a) City = makecity(name, lat, lon)
In simple words: `makecity` is the constructor because it builds a new 'city' object using the given information.

🎯 Exam Tip: Constructors are functions that create new instances of a data type, usually indicated by a function name that suggests creation, like "make" or "create".

 

Question 8. Which of the following extract the information of the object?
(a) Constructors
(b) Selectors
(c) Functions
(d) Destructors
Answer: (b) Selectors
In simple words: Selectors are functions that help you get details out of an object.

🎯 Exam Tip: Remember that selectors are for retrieving data, while constructors are for creating data. Don't confuse their roles.

 

Question 9. Which of the following is used to build the abstract data type?
(a) Destructors
(b) Constructors
(c) Selectors
(d) All of these
Answer: (b) Constructors
In simple words: Constructors are what you use to create a new abstract data type.

🎯 Exam Tip: Constructors initialize objects and set their initial values, making them essential for creating any abstract data type.

 

Question 10. How many ways of representing pair data types are there?
(a) 1
(b) 2
(c) 3
(d) 4
Answer: (b) 2
In simple words: You can show pair data in two main ways, usually with lists or tuples.

🎯 Exam Tip: The two common ways to represent pairs are using lists (for mutable pairs) or tuples (for immutable pairs).

 

Question 11. The process of providing only the essentials and hiding the details is known as
(a) Functions
(b) Encapsulation
(c) Abstraction
(d) Pairs
Answer: (c) Abstraction
In simple words: Abstraction means showing only what is needed and hiding the complicated stuff.

🎯 Exam Tip: Abstraction is key to managing complexity in programming by focusing on "what" rather than "how".

 

Question 12. A D T expansion is ....................
(a) Abstract Data Type
(b) Absolute Data Type
(c) Abstract Data Template
(d) Application Development Template
Answer: (a) Abstract Data Type
In simple words: ADT means Abstract Data Type, which is a way to describe what data does without showing how it works inside.

🎯 Exam Tip: Always remember that ADT stands for Abstract Data Type, emphasizing the abstract view of data operations.

 

Question 13. How many objects can be created from a class?
(a) 0
(c) 2
(d) many
Answer: (d) many
In simple words: A class is like a mold, and you can make countless items (objects) from that one mold.

🎯 Exam Tip: A single class serves as a blueprint from which an unlimited number of objects (instances) can be created, each with its own state.

 

Question 14. A powerful concept that allows programmers to treat codes as objects?
(a) Encapsulation
(b) Inheritance
(c) Data Abstraction
(d) Polymorphism
Answer: (c) Data Abstraction
In simple words: Data Abstraction is a big idea where coders can treat their code pieces like individual objects, making programs easier to handle.

🎯 Exam Tip: Data abstraction is crucial for object-oriented programming, as it simplifies complex systems by providing a high-level view of data and operations.

 

Question 1. What are the two parts of a program?
Answer: Every program has two main parts. The first part works with abstract data, which is how we think about the data and its actions. The second part defines the concrete representation, which is how the data is actually stored and managed inside the computer. Understanding these two parts helps in creating well-structured programs.
In simple words: A program has two parts: one that deals with general ideas of data, and another that shows how that data is actually built.

🎯 Exam Tip: When describing program parts, always mention both the abstract (what it does) and concrete (how it works) aspects to show a complete understanding.

 

Question 1. Explain the representation of Abstract data type using rational numbers.
Answer: Abstract Data Types (ADTs) can be represented by separating how data is used from how it is stored. For rational numbers, which are ratios of two integers (like 8/3), we use this idea.
A rational number needs both a numerator (top number) and a denominator (bottom number) to be exactly defined. If we simply divide them, we get a decimal that might lose precision.
Instead, we can create an ADT that keeps the numerator and denominator separate.
This ADT uses two types of functions:
1. Constructor: A function like `rational(n, d)` that builds a rational number by taking a numerator `n` and a denominator `d`.
2. Selectors: Functions like `numer(x)` to get the numerator from a rational number `x`, and `denom(y)` to get the denominator from a rational number `y`.
These functions allow us to work with rational numbers without directly dealing with how they are stored (e.g., as a pair of integers). For instance, to represent a rational number like `8/3`, we can create it using `rational(8, 3)`. Then, to use its parts, we can call `numer(rational(8,3))` to get `8` and `denom(rational(8,3))` to get `3`. This helps maintain the exact value and avoid rounding errors.
For example, if we set `x, y := 8, 3`, and then call `rational(n,d)`, followed by `numer(x)/numer(y)`, this structure would effectively represent the division, yielding an output like `2.6666666666666665`.
In simple words: We can represent rational numbers (like fractions) as an Abstract Data Type. This means we use special functions to build the number (constructor) and to get its top and bottom parts (selectors), without directly seeing how it's stored. This keeps the number exact, like `8/3`, instead of changing it to a decimal.

🎯 Exam Tip: When explaining ADTs, always provide clear examples of constructors and selectors and highlight how they manage data without exposing its internal representation.