(i) 2
(ii) 2
(iii) 0
(iv) 5
(v) 2
(vi) 1

(i) python
(ii) false
(iii) false
(iv) PYTHON

(i) 0
(ii) 3
(iii) -1
(iv) 3

Syntax:
("String to be display with %vall and %vaI2" %(val1, vaI2))
Example:
name = "Rajarajan''
mark = 98
print ("Name: %s and Marks: %d" %(name,mark) )
Output:
Name: Rajarajan and Marks: 98

The positive subscript 0 is assigned to the first character and n-1 to the last character, where n is the number of charaters in the string. The negative index assigned from the last character to the first character in reverse order begins with -1.
Example:

1. - y
2. - sample 0
3. - s.x
4. - s. y
5. - s. x + s. y

class Sample:
def _init_(self, n1, n2):
self.n1=n1
self._n2=n2
def display(self):
print("Class variable 1 = ", self.n1)
print("Class variable 2 = ", self._n2)
S=Sample(12,14)
S.display()
print("Value 1 = ", S.n1)
print("Value 2 = ". S._n2)
Reason: The print statements defined within class will successfully display the values of n1 and n2, even though the class variable n2 is private because, in this case, n2 is called by a method defined inside the class. But, when we try to access the value of n2 from outside the class Python throws an error because, private variable cannot be accessed from outside the class.

pass statement is generally used as a placeholder. When we have a loop or function that is to be implemented in the future and not now, we cannot develop such functions or loops with empty body segment because the interpreter would raise an error. So, to avoid this we can use pass statement to construct a body that does nothing.

(i) While creating a tuple with a single element, add a comma at the end of the element.
(ii) In the absence of a comma, Python will consider the element as an ordinary data type; not a tuple. Creating a Tuple with one element is called "Singleton" tuple.
(iii) Example:
Example:
> > > MyTup4 = (10)
> > > type(MyTup4)
< class 'int' >
> > > MyTup5 = (10,)
>>> type(MyTup5)
< class 'tuple' >

country=["India", "Russia", "Srilanka", "China", "Brazil"]
is_member = input("Enter the name of the country: ")
if is_member in country:
print(is_member, " is the member of BRICS")
else:
print(is_member, " is not a member of BRICS")
Output:
Enter the name of the country: India
India is the member of BRICS
Output:
Enter the name of the country: Japan
Japan is not a member of BRICS

In Python, the lists are mutable, which means they can be changed. A list element or range of elements can be changed or altered by using simple assignment operator (=).
Example:
MyList = [1,3,5,7,9]
print ("List Odd numbers ... ")
for x in MyList:
print (x)
MyList[0:5] = 2, 4, 6, 8, 10
print ("List Even numbers ... ")
for y in MyList:
print (y)

(i) The len( ) function in Python is used to find the length of a list. (i.e., the number of elements in a list).
(ii) Usually, the len( ) function is used to set the upper limit in a loop to read all the elements of a list.
(iii) If a list contains another list as an element, len( ) returns that inner list as a single element.
(iv) Example: Accessing single element
> > > MySubject = ['Tamil', 'English', 'Comp', 'Science', 'Maths']
> > > len(MySubject)
4

Step 1 - If it is the first element, it is already sorted.
Step 2 - Pick next element
Step 3 - Compare with all elements in the sorted sub-list
Step 4 - Shift all the elements in the sorted sub-list that is greater than the value to be sorted
Step 5 - Insert the value
Step 6 - Repeat until list is sorted

The space required by an algorithm is equal to the sum of the following two components: 
(i) A fixed part is defined as the total space required to store certain data and variables for an algorithm. For example, simple variables and constants used in an algorithm.
(ii) A variable part is defined as the total space required by variables, which sizes depends on the problem and its iteration. For example: recursion used to calculate factorial of a given value n.

The algorithm can be written as:
Step 1: start the process
Step 2: get the input x
Step 3: calculate the square by multiplying the input value ie., square \(\leftarrow \)x* x
Step 4: display the result square
Step 5: stop

(i) 100
(ii) 100.0
(iii) 100
(iv) 3

x = int(input ("Enter Number 1")
y = int(input("Enter Number 2")
print ("The sum of", x, " and ", y, "is", x+y)

(i) In Python, programs can be written in two ways namely Interactive mode and Script mode.
(ii) The Interactive mode allows us to write codes in Python command prompt >>> whereas in script mode programs can be written and stored as separate file with the extension.
(iii) py and executed. Script mode is used to create and edit python source file.

Public members (generally methods declared in a class) are accessible from outside the class. The object of the same class is required to invoke a public method. This arrangement of private instance variables and public methods ensures the principle of data encapsulation.

(i) Built-in scope is the widest scope. The built -in scope has all the names that are pre-loaded into the program scope when we start the compiler or interpreter.
(ii) Any variable or module which is defined in the library functions of a programming language has Built-in or module scope. They are loaded as soon as the library files are imported to the program.

(iii) Normally only Functions or modules come along with the software, as packages, therefore they will come under Built in scope.

An ADT for rational numbers:
- - constructor
- - constructs a rational number with numerator n, denominator d
rational(n, d)
- - selector
number(x) \(\rightarrow \) returns the numerator of rational number x
denom(y) \(\rightarrow \) returns the denominator of rational number y