NCERT Solutions Class 11 Computer Science Chapter 8 2026-27

Strategic angle. Split the problem into three checks: slice limits, slice step and method meaning. This avoids guessing outputs.

1. First mark the positions in Computer Science. The blank space is also a character, so it is counted during indexing.
2. A full slice from 0 to len(mySubject) returns every character from C to the final e.
3. The slice [-7:-1] means positions -7, -6, -5, -4, -3, -2. These characters form Scienc.
4. The step slice [::2] selects positions 0, 2, 4, 6, 8, 10, 12, 14. These give Cmue cec.
5. The reverse step [::-2] selects positions 15, 13, 11, 9, 7, 5, 3, 1. These give eniSrtpo.
6. The expression mySubject[:3] + mySubject[3:] divides the string at index 3, then joins both parts back.
7. The method swapcase() flips letter case only. The space remains a space.
8. The method startswith() checks the first few characters. The method isalpha() checks whether all characters are alphabetic, and the space makes it false.

When output tracing feels long, write the index row once. Then every slice becomes direct reading.

The ten outputs are Computer Science, Scienc, Cmue cec, e, Computer ScienceComputer Science, eniSrtpo, Computer Science, cOMPUTER sCIENCE, True, and False.

Quick reading. This question tests how methods treat separators and missing substrings. The address has two commas, three spaces and two occurrences of New.

1. Case methods do not change digits, hyphens, commas or spaces. Only letters change in lower() and upper().
2. Counting New gives 2 because it appears before Ganga and before Delhi.
3. The first occurrence starts after WZ-1,. That puts it at index 5.
4. The second occurrence starts after WZ-1,New Ganga Nagar,. That puts it at index 21.
5. The comma split creates three address parts. The space split creates four parts because it cuts only where blank spaces appear.
6. replace() returns a new string with both New occurrences changed to Old.
7. partition(',') always returns three pieces: before separator, separator itself and after separator.
8. index('Agra') cannot find the substring. Unlike find(), it does not return -1; it raises ValueError.

For method-output questions, count separators before writing the list. That prevents most split and partition errors.

find('New') gives 5, rfind('New') gives 21, and index('Agra') raises ValueError: substring not found.

Structural observation. This program has two separate jobs. First collect text. Then classify the collected text.

• The input loop should stop only when the user gives a blank line.
• The counting loop should not ask for input again.
• The word count should be calculated after the full text is ready.

1. A blank input line is a clear stopping signal. The loop therefore checks if line == "".
2. The list lines stores each non-blank line. The expression " ".join(lines) combines them with one blank between adjacent lines.
3. len(text) counts every character, including letters, digits, punctuation and spaces.
4. For classification, ch.isalpha() catches letters and ch.isdigit() catches digits.
5. A character that is neither a letter nor a digit nor a space is counted as a special symbol.
6. The word count uses text.strip().split(" "). The strip() call removes leading and trailing spaces before splitting.

The counters are independent, so changing one counter never changes another. That makes the program easy to test with short input such as A1 @. In that test, total characters are 4, alphabets are 1, digits are 1, special symbols are 1, and words are 2.

The important design point is that the space character is handled twice in different ways. It contributes to len(text), but it is not counted as an alphabet, digit or special symbol.

A correct solution uses a loop for input, len() for total characters, isalpha() and isdigit() for classification, and split(" ") for word count.

Quick reading. The function must not only print the changed string. Since the question asks for a user-defined function, returning the changed string is better.

• Splitting gives separate words.
• Indexing changes the first character of each word.
• Joining rebuilds the final sentence.

1. The statement words = sentence.split(" ") gives a list of words.
2. Each non-empty word is handled separately. The first character is word[0].
3. word[0].upper() capitalises the first letter.
4. word[1:].lower() keeps the remaining part in lowercase.
5. These two parts are joined and stored in newWords.
6. Finally, " ".join(newWords) rebuilds the sentence.

This solution also handles extra spaces safely because empty words are added back unchanged. If the input is "python string methods", the function builds "Python String Methods". If a word is already capitalised, converting the rest of the word with lower() keeps the output neat and consistent.

toTitleCase() returns the given multi-word string with the first letter of each word capitalised.

Strategic angle. Think of the function as a filter. Keep every character that passes the condition c != ch.

• The original text is the source.
• The character parameter is the value to reject.
• The result string stores only accepted characters.

1. The original string remains unchanged because Python strings cannot be edited in place.
2. The variable result starts as an empty string.
3. During traversal, each character is tested.
4. If the character matches the unwanted character, the loop simply skips it.
5. If it does not match, the character is attached to result.
6. After all characters are checked, result contains only the allowed characters.

For example, deleteChar("banana", "a") returns bnn. The loop reads b and keeps it, reads a and skips it, reads n and keeps it, then repeats the same check until the string ends.

This method also removes consecutive copies. If the input is "book" and the character is "o", both o characters are skipped, so the returned string is bk.

The function returns a new string with all copies of the selected character removed.

Structural observation. The key is to add numeric values, not character codes. That is why int(ch) is required.

1. The loop checks one character at a time.
2. If ch.isdigit() is false, the character is ignored.
3. If ch.isdigit() is true, int(ch) converts values such as "4" into the number 4.
4. The value is added to total.
5. After the loop, total stores the required digit sum.

If the string has no digits, the loop never adds anything. The function correctly returns 0.

sumDigits() returns the sum of all digits found in the input string.

Quick reading. The required change is global because every blank must be replaced, not only the first blank.

• The blank space is the old substring.
• The hyphen is the new substring.
• The returned value is a fresh string.

1. The parameter sentence stores the original sentence.
2. The method replace(" ", "-") scans the whole string.
3. Every blank space is replaced by the hyphen character.
4. The original string is not edited. The method returns a new string.
5. The function sends this new string back to the caller.

For example, "Computer Science Class" becomes "Computer-Science-Class". The same rule works for longer sentences because replace() checks the complete string, not just the first word gap.

If built-in methods are not allowed, the same logic can be written with traversal. Add "-" whenever the character is a blank space; otherwise add the original character.

blankToHyphen() returns sentence.replace(" ", "-").