Q: C#.NET string interning and object references: consider the code String s1, s2; s1 = 'Hi'; s2 = 'Hi'; Which statements about object creation and references are true?

Introduction / Context: This item tests understanding of string interning and reference behavior in C#.NET. String literals are interned, which can cause multiple variables initialized with the same literal to point to the same object instance. Given Data / Assumptions: Two string variables s1 and s2. Both assigned the same literal 'Hi'. Statements to evaluate include whether objects are created with or without new, and whether references point to the same instance. Concept / Approach: In .NET, string literals are interned. Assigning the same literal to two variables does not create two different heap objects; both references point to the interned single instance. Creating strings without new is perfectly legal through literals. Step-by-Step Solution: 1) 'String objects cannot be created without using new.' → False: literals create interned strings.2) 'Only one object will get created.' → True due to interning.3) 's1 and s2 both will refer to the same object.' → True: both refer to interned 'Hi'.4) 'Two objects will get created…' → False.5) 's1 and s2 are references to the same object.' → True (same as 3). Verification / Alternative check: Use Object.ReferenceEquals(s1, s2) → returns true. Using new string('H',1) etc. would bypass interning unless explicitly interned. Why Other Options Are Wrong: Any option including 1 or 4 is incorrect because they contradict interning and literal semantics. Common Pitfalls: Confusing content equality with reference equality; assuming every assignment creates a new object on the heap. Final Answer: 2, 3, 5

Q: C#.NET String.Insert: determine the output of String s1 = 'Nagpur'; String s2; s2 = s1.Insert(6, 'Mumbai'); Console.WriteLine(s2); What is printed?

Introduction / Context: This checks understanding of the String.Insert method, which returns a new string by inserting a specified substring at a given index (0-based). Given Data / Assumptions: s1 = 'Nagpur' (length 6). We call s1.Insert(6, 'Mumbai'). Index 6 equals the length of s1, so insertion occurs at the end. Concept / Approach: The Insert method does not mutate s1 (strings are immutable); it produces a new string with the substring inserted at the specified index: prefix up to index + inserted text + remainder. If the index is equal to the original length, it appends. Step-by-Step Solution: Compute length: 'Nagpur' → 6.Insert at index 6 (after the last character).Result: 'Nagpur' + 'Mumbai' → 'NagpurMumbai'. Verification / Alternative check: Replace the index with 0 to see a different effect ('MumbaiNagpur'). Attempting an index > length would throw an ArgumentOutOfRangeException. Why Other Options Are Wrong: 'NagpuMumbair' misplaces letters. 'Nagpur Mumbai' implies insertion of a space not present in the call. 'Mumbai' or 'Nagpur' would imply ignoring one of the strings; that is not the behavior of Insert. Common Pitfalls: Confusing Insert with Concat and off-by-one errors with indexes. Final Answer: NagpurMumbai

Question 1

In the C standard library, which function finds the first occurrence of a given substring within another string (i.e., searches for one string inside a larger string)?

Accepted Answer

Introduction / Context: String searching is a common task. The C library offers functions for locating characters and substrings. Choosing the correct function saves time and avoids writing error-prone custom loops for pattern search. Given Data / Assumptions: The goal is to find a substring (needle) inside another string (haystack). Null-terminated strings (char*) are used. We want the first occurrence. Concept / Approach: strstr(haystack, needle) returns a pointer to the first occurrence of needle in haystack, or NULL if not found. For single-character searches, use strchr; for the last occurrence of a character, use strrchr; strnset is a non-standard function for filling portions of a string, not searching. Step-by-Step Solution: Call strstr(h, n) where h is the larger string, n is the substring.Check the return value: non-NULL indicates success and points at the match.If you need the index, subtract h from the returned pointer.Handle NULL safely to avoid dereferencing invalid pointers. Verification / Alternative check: Test with strstr("embedded systems", "bed") which returns a pointer to the substring starting at index 2. Why Other Options Are Wrong: strchr: finds a character, not a substring. strrchr: finds the last occurrence of a character. strnset: sets characters; not a search function. Common Pitfalls: Confusing character search with substring search. Also, ensure needle is not an empty string, which per the standard makes strstr return haystack. Final Answer: strstr().

Question 2

In C, how would you print the two literal characters backslash and n (i.e., the text ' ') on the screen using printf?

Accepted Answer

Introduction / Context: Escape sequences in C string literals can be confusing. The backslash introduces special sequences like (newline). To print a backslash character itself, you must escape it as \ in the source to produce a single backslash at runtime. This question asks for the exact printf form to display the text literally, not to create a newline. Given Data / Assumptions: You want the output characters backslash followed by the letter n. Using the standard C library function printf. No extra whitespace or newlines are required. Concept / Approach: In C string literals, "" represents a single backslash character. Therefore, "" in a literal results in two output characters: backslash and n. Passing that literal to printf prints exactly as text. Using '' (single quotes) forms a character literal representing newline, not the two-character sequence. Step-by-Step Solution: Write a string literal that encodes backslash: "".Append the character n to form "".Call printf(""); to print those two characters.Do not use character literals or unescaped backslashes. Verification / Alternative check: Running printf(""); produces backslash-n on the console. Running printf(""); would print two backslashes followed by n (i.e., \). Why Other Options Are Wrong: printf(""); prints \ (two backslashes), not . printf(''); uses a character literal for newline, not the two characters. The combined comment form is unnecessary and potentially misleading. puts(""); also prints but appends a newline automatically; the question asks specifically for printf and minimal form. Common Pitfalls: Forgetting that backslash must be escaped in string literals. Confusing character and string literals leads to different behavior. Final Answer: printf("");.

Question 3

Which C library function returns a pointer to the last occurrence of a specified character within a null-terminated string?

Accepted Answer

Introduction / Context: Working with strings often requires locating characters from either end. The C library provides separate functions for the first and last occurrences. Picking the right one avoids manual reverse scans and reduces bugs. Given Data / Assumptions: Strings are null-terminated char arrays. You want the last position of a character. Standard C library is available. Concept / Approach: strrchr(s, c) scans the string s and returns a pointer to the last occurrence of character c, or NULL if c does not appear. For first occurrence, use strchr; for substring search, use strstr. Non-standard names like strnstr may exist on some platforms but find substrings, not necessarily last characters, and are not in the C standard. Step-by-Step Solution: Call strrchr with the target string and character.Check for NULL to handle not-found cases safely.If non-NULL, compute index by pointer subtraction if needed.Use the returned pointer for further processing (e.g., splitting). Verification / Alternative check: Example: strrchr("banana", 'a') returns a pointer to the final 'a' (index 5). Why Other Options Are Wrong: strnstr: Non-standard and substring-oriented, not last-character search. laststr: Not a standard function. strstr: Finds substrings, not single characters. Common Pitfalls: Forgetting that the null terminator '\0' can also be searched; strrchr(s, '\0') returns a pointer to the terminator at the end of s. Final Answer: strrchr().

Question 4

Which function sets the first n characters of a C string to a specified character (use the best match among the listed options)?

Accepted Answer

Introduction / Context: Sometimes you need to initialize or overwrite a prefix of a string with a repeated character, such as filling with '' for masking. While the standard C function memset sets raw bytes, some environments provide string-oriented helpers. This question targets the function name commonly used for this task in certain libraries. Given Data / Assumptions: Null-terminated strings are used. You want to modify only the first n characters. We select from the given names. Concept / Approach: strnset(s, ch, n) (non-standard, e.g., MSVC) sets the first n characters of s to ch and returns s. strset sets all characters, not just the first n. Functions like strinit and strcset are not standard. If strict portability is required, prefer memset(s, ch, n) while ensuring you do not overwrite the null terminator unintentionally. Step-by-Step Solution: Call strnset(s, ch, n) to set a prefix of the string.Ensure n does not exceed the string length prior to '\0' to preserve termination.Alternatively, use memset(s, ch, n) for portable code.Re-terminate if necessary to maintain a valid C string. Verification / Alternative check: After calling strnset(s, '', 3) on "hello", s becomes "***lo". Why Other Options Are Wrong: strset modifies all characters; not limited to n. strinit and strcset are not standard or commonly available. Common Pitfalls: Accidentally overwriting the null terminator or using these non-standard functions in portable code. Prefer memset for cross-platform projects. Final Answer: strnset().

Question 5

For two strings s1 and s2 in C, what does strcmp(s1, s2) return if the strings are identical in content and length?

Accepted Answer

Introduction / Context: strcmp is the canonical C function for lexicographic comparison of two null-terminated strings. Interpreting its return value correctly is crucial for sorting, searching, and equality checks. Given Data / Assumptions: s1 and s2 are valid null-terminated strings. We use the standard strcmp contract. No locale-specific collation overrides are considered. Concept / Approach: strcmp returns an integer less than 0 if s1 < s2, greater than 0 if s1 > s2, and exactly 0 if s1 and s2 are equal (same characters in the same order with the same length). Therefore, equality corresponds to a return value of 0, not a Boolean value like 'Yes'. Step-by-Step Solution: Call strcmp(s1, s2).If return == 0, the strings are identical.If return < 0, s1 precedes s2; if > 0, s1 follows s2.Use equality to branch or to confirm matches before further processing. Verification / Alternative check: strcmp("cat","cat") returns 0; strcmp("ant","bee") < 0; strcmp("dog","cat") > 0. Why Other Options Are Wrong: -1 or 1 are specific negative/positive values; the standard only promises <0 or >0, not exact -1/1. Yes is not a valid return type for strcmp. Common Pitfalls: Testing for return == 1 or == -1 specifically; instead, test < 0, == 0, or > 0. Final Answer: 0.

Question 6

Which of the following function is correct that finds the length of a string?

Accepted Answer

Option A is the correct function to find the length of given string. Example: #include<stdio.h>

int xstrlen(char *s)
{
    int length=0;
    while(*s!='\0')
    { length++; s++; }
    return (length);
}

int main()
{
    char d[] = "CuriousTab";
    printf("Length = %d", xstrlen(d));
    return 0;
}
 Output: Length = 8

Question 7

In C input/output programming, which standard library function is most appropriate for reading a multi-word string that includes spaces from standard input?

Accepted Answer

Introduction / Context: Reading text that contains spaces (for example, full names or sentences) requires care in C. Basic token-oriented input like scanf with the %s specifier stops at whitespace, which truncates multi-word input. Older C textbooks often used gets to read an entire line including spaces. Although gets is now removed from the C standard due to safety issues, understanding why it was historically chosen explains the intended behavior of multi-word input questions and highlights safer modern alternatives. Given Data / Assumptions: The task is to read a string that can include spaces (multi-word). We are comparing classic C standard I/O functions. We focus on functional suitability for capturing spaces, not security best practices. Concept / Approach: scanf with %s reads until the first whitespace, so it fails for multi-word input. gets historically read an entire line up to the newline, thus capturing spaces. printf and puts are output functions and cannot read input at all. Step-by-Step Solution: Identify requirement: accept spaces → single-token readers like scanf("%s") are unsuitable.Eliminate output-only functions (printf, puts) because they do not read input.Select the remaining function that reads a whole line including spaces → gets (historically). Verification / Alternative check: Practical test: entering 'I am here' → scanf("%s") captures 'I' only; gets would have captured the full line. Why Other Options Are Wrong: printf(): Output only; cannot read. scanf(): With %s, it stops at whitespace; does not capture multi-word strings without complex formats. puts(): Output only; prints a string with a newline. Common Pitfalls: Using gets in real code is unsafe because it cannot prevent buffer overflows. Prefer fgets(buffer, size, stdin) in modern C. Assuming scanf("%[^]") is trivial; while it can read lines, it requires careful width limits to avoid overflow. Final Answer: gets()

Question 8

C#.NET strings: What will be printed by the following code when comparing two differently cased strings?  String s1 = 'Five Star'; String s2 = 'FIVE STAR'; int c; c = s1.CompareTo(s2); Console.WriteLine(c);  Choose the correct result of the call to …

Accepted Answer

Introduction / Context: This question examines how String.CompareTo behaves in C#.NET. The method performs a case-sensitive, culture-aware comparison and returns an integer: less than 0 if the instance precedes the argument, 0 if equal, and greater than 0 if it follows. Given Data / Assumptions: s1 = 'Five Star' s2 = 'FIVE STAR' c = s1.CompareTo(s2) and then Console.WriteLine(c) CompareTo returns a signed int, not necessarily only -1, 0, or 1, but commonly those values. Concept / Approach: Comparison is lexicographic and case-sensitive in the current culture. The first differing character controls the result. Uppercase and lowercase letters have different sort values; typically lowercase letters follow uppercase in case-sensitive comparisons. Step-by-Step Solution: Compare character by character: 'F' vs 'F' → equal.Next: 'i' (105) vs 'I' (73) → since 105 > 73, s1 is greater than s2.Therefore, CompareTo returns a positive integer. In typical outputs this prints 1. Verification / Alternative check: Calling String.Compare(s1, s2) with default overloads also yields a positive value. Using StringComparer.OrdinalIgnoreCase (not used here) would yield equality (0), highlighting the effect of case sensitivity. Why Other Options Are Wrong: 0 implies equality (not true due to case). -1 or -2 indicate s1 < s2, which contradicts the character comparison. 2 is not the typical printed value; while any positive value technically indicates 'greater than', standard examples show 1. Common Pitfalls: Assuming comparisons are case-insensitive by default or that the numeric values correspond to character code differences directly; CompareTo abstracts that away and only guarantees sign. Final Answer: 1

Question 9

C#.NET string interning and object references: consider the code  String s1, s2; s1 = 'Hi'; s2 = 'Hi';  Which statements about object creation and references are true?

Accepted Answer

Introduction / Context: This item tests understanding of string interning and reference behavior in C#.NET. String literals are interned, which can cause multiple variables initialized with the same literal to point to the same object instance. Given Data / Assumptions: Two string variables s1 and s2. Both assigned the same literal 'Hi'. Statements to evaluate include whether objects are created with or without new, and whether references point to the same instance. Concept / Approach: In .NET, string literals are interned. Assigning the same literal to two variables does not create two different heap objects; both references point to the interned single instance. Creating strings without new is perfectly legal through literals. Step-by-Step Solution: 1) 'String objects cannot be created without using new.' → False: literals create interned strings.2) 'Only one object will get created.' → True due to interning.3) 's1 and s2 both will refer to the same object.' → True: both refer to interned 'Hi'.4) 'Two objects will get created…' → False.5) 's1 and s2 are references to the same object.' → True (same as 3). Verification / Alternative check: Use Object.ReferenceEquals(s1, s2) → returns true. Using new string('H',1) etc. would bypass interning unless explicitly interned. Why Other Options Are Wrong: Any option including 1 or 4 is incorrect because they contradict interning and literal semantics. Common Pitfalls: Confusing content equality with reference equality; assuming every assignment creates a new object on the heap. Final Answer: 2, 3, 5

Question 10

C#.NET String.Insert: determine the output of  String s1 = 'Nagpur'; String s2; s2 = s1.Insert(6, 'Mumbai'); Console.WriteLine(s2);  What is printed?

Accepted Answer

Introduction / Context: This checks understanding of the String.Insert method, which returns a new string by inserting a specified substring at a given index (0-based). Given Data / Assumptions: s1 = 'Nagpur' (length 6). We call s1.Insert(6, 'Mumbai'). Index 6 equals the length of s1, so insertion occurs at the end. Concept / Approach: The Insert method does not mutate s1 (strings are immutable); it produces a new string with the substring inserted at the specified index: prefix up to index + inserted text + remainder. If the index is equal to the original length, it appends. Step-by-Step Solution: Compute length: 'Nagpur' → 6.Insert at index 6 (after the last character).Result: 'Nagpur' + 'Mumbai' → 'NagpurMumbai'. Verification / Alternative check: Replace the index with 0 to see a different effect ('MumbaiNagpur'). Attempting an index > length would throw an ArgumentOutOfRangeException. Why Other Options Are Wrong: 'NagpuMumbair' misplaces letters. 'Nagpur Mumbai' implies insertion of a space not present in the call. 'Mumbai' or 'Nagpur' would imply ignoring one of the strings; that is not the behavior of Insert. Common Pitfalls: Confusing Insert with Concat and off-by-one errors with indexes. Final Answer: NagpurMumbai

Question 11

C#.NET: Correct ways to convert a String to an int (assume s = '123'). Select all valid C# approaches.

Accepted Answer

Introduction / Context: Converting text to numeric types is routine. In C#, several standard methods exist to convert a numeric string to an int, each with different behavior for invalid input. Given Data / Assumptions: String s = '123'; and int i; Evaluate: casting, int.Parse, Int32.Parse, Convert.ToInt32, CInt. Concept / Approach: int.Parse and Int32.Parse are equivalent and parse a string containing digits into an integer (throwing on invalid format). Convert.ToInt32 also parses strings and handles null differently (returns 0 for null). Direct casting from string to int is not allowed. CInt is a VB keyword, not valid C# syntax. Step-by-Step Solution: Attempt i = (int)s; → invalid in C#.Use i = int.Parse(s); → valid.Use i = Int32.Parse(s); → valid.Use i = Convert.ToInt32(s); → valid.Use i = CInt(s); → invalid in C#. Verification / Alternative check: For safe parsing, int.TryParse(s, out i) avoids exceptions on bad input and returns a boolean. Why Other Options Are Wrong: Any combination including 1 or 5 is incorrect because casting a string to int is illegal and CInt is not a C# construct. Common Pitfalls: Confusing C# with VB syntax; forgetting to handle invalid inputs and culture-specific formats. Final Answer: 2, 3, 4

Question 12

C#.NET strings: What is the correct way to compare two string variables s1 and s2 for equality of contents (not assignment)?

Accepted Answer

Introduction / Context: Comparing strings in C#.NET can be done via operators or methods. Understanding which operator compares contents versus references is vital to avoid subtle bugs. Given Data / Assumptions: s1 and s2 are variables of type string. We want to test if their contents are equal. Concept / Approach: In C#, the == operator is overloaded for string to perform value (content) equality. Likewise, string.Equals compares contents (with overloads for comparison options). Assignment (=) does not compare; it overwrites references. The is operator tests type, not equality. C-style strcmp is not part of C#. Step-by-Step Solution: s1 == s2 → compares contents and returns a boolean.s1.Equals(s2) → also compares contents and returns a boolean (valid alternative).s1 = s2 → assignment, not comparison; wrong.s1 is s2 → type test, not equality; wrong.strcmp → not available in C#; wrong. Verification / Alternative check: To compare references (object identity), use Object.ReferenceEquals(s1, s2). That is different from content equality. Why Other Options Are Wrong: They either change the variable (=), test type (is), or use non-C# functions. Common Pitfalls: Mixing up content equality with reference equality; assuming == compares references for strings (in C#, it does content comparison). Final Answer: s1 == s2

Question 13

C#.NET strings vs. StringBuilder: choose the correct statement about mutability and immutability.

Accepted Answer

Introduction / Context: This tests whether you know that string in C# is immutable, whereas StringBuilder provides a mutable buffer for efficient in-place-like modifications. Given Data / Assumptions: Statement: Strings built using String are immutable; StringBuilder instances are mutable. Concept / Approach: Immutability means any apparent modification of a string produces a new instance, leaving the original unchanged. StringBuilder maintains an internal resizable buffer permitting operations like Append, Insert, and Remove without creating a new string each time (until you call ToString()). Step-by-Step Solution: Create string s = 'a'; then s += 'b'; → returns a new string 'ab'.Create var sb = new StringBuilder('a'); then sb.Append('b'); → same sb buffer now holds 'ab'. Verification / Alternative check: Use a memory profiler or check Object.ReferenceEquals before and after modifying a string versus a StringBuilder. Why Other Options Are Wrong: Marking the statement as False contradicts the documented behavior of both types. Common Pitfalls: Building long strings with + in loops, causing unnecessary allocations; prefer StringBuilder for repeated concatenations. Final Answer: True

Question 14

Where are C#.NET String objects created? Choose the correct statement about the memory location of a String.

Accepted Answer

Introduction / Context: Understanding where objects live clarifies performance and lifetime semantics in .NET. Strings in C# are reference types managed by the garbage collector. Given Data / Assumptions: C# strings are of type System.String, a reference type. The .NET runtime manages memory for reference types on the managed heap. Concept / Approach: Local variables may be stored on the stack, but the data for reference type instances (like strings) is allocated on the heap. The variable holds a reference to that heap object. String is not a primitive in C#; it is a reference type with special language support. Step-by-Step Solution: Option A → False: only references can be on the stack; object data for strings is heap-allocated.Option B → False: size does not change the allocation model for strings.Option C → False: string is not a primitive in C#.Option D → Incorrect syntax and unnecessary; typical construction uses literals or new string(char[]) overloads.Option E → True: String instances are on the heap. Verification / Alternative check: Inspect IL or use a debugger: references are local; object memory is heap-based. Why Other Options Are Wrong: They either misuse syntax or conflate variable storage (references) with object storage (heap). Common Pitfalls: Assuming small objects are placed on the stack automatically; in .NET, object allocation strategy depends on type category, not just size. Final Answer: A String is created on the heap.

Question 15

String and StringBuilder in C#.NET: select the correct statements.  1) Two strings can be concatenated using s3 = s1 + s2; 2) String is a primitive in C#.NET. 3) A string built with StringBuilder is mutable. 4) A string built with String is immutabl…

Accepted Answer

Introduction / Context: This question reviews fundamental properties of string and StringBuilder and the standard concatenation syntax in C#. Given Data / Assumptions: Statements to validate include concatenation forms and mutability claims. Concept / Approach: In C#, strings are immutable, and the + operator concatenates strings. StringBuilder provides a mutable buffer for efficient concatenations or edits. The & concatenation operator is a VB feature, not C#. Step-by-Step Solution: 1) s3 = s1 + s2 → Valid in C#.2) 'String is a primitive' → False; it is a reference type with special handling.3) StringBuilder-built strings are mutable → True (the builder is mutable; resulting ToString() is immutable).4) Strings are immutable → True.5) s3 = s1 & s2 → Not C# syntax; false. Verification / Alternative check: Creating a StringBuilder and appending confirms mutability; attempting to modify an existing string shows it produces a new instance. Why Other Options Are Wrong: Options including 2 or 5 assert incorrect claims about primitives or use non-C# operators. Common Pitfalls: Assuming VB operators apply in C#; forgetting the performance implications of repeated + in loops. Final Answer: 1, 3, 4

Question 16

Comparing string contents in C#.NET: which of the following are valid ways to determine if two strings s1 and s2 have equal contents?  1) if(s1 = s2) 2) if(s1 == s2) 3) int c; c = s1.CompareTo(s2); 4) if(strcmp(s1, s2)) 5) if (s1 is s2)

Accepted Answer

Introduction / Context: This problem focuses on correct techniques for string equality checks in C#.NET. Understanding operators and methods available in the .NET framework helps avoid logic errors. Given Data / Assumptions: We have two string references s1 and s2. We want to know whether their contents are equal. Concept / Approach: In C#, the == operator is overloaded for string to perform content comparison. CompareTo returns 0 when two strings are equal. C-style strcmp is not a C# function. The is operator checks type compatibility, not content equality. Assignment (=) is not a comparison. Step-by-Step Solution: 2) if (s1 == s2) → Valid for content equality.3) int c = s1.CompareTo(s2); → Valid basis; equality holds if c == 0.1) if (s1 = s2) → Invalid; assignment, not comparison.4) strcmp → Not part of C#.5) s1 is s2 → Type test, not equality. Verification / Alternative check: Using s1.Equals(s2) is another standard approach that returns a boolean, with overloads for culture and case options. Why Other Options Are Wrong: They include non-C# functions, type checks, or misuse assignment. Common Pitfalls: Forgetting to compare CompareTo’s result to zero, and confusing identity vs. equality. Final Answer: 2, 3

Question 17

Copying the contents of one string to another in C#.NET: choose the statement that correctly creates a new string with the same contents as an existing one.

Accepted Answer

Introduction / Context: Copying strings can mean either copying the reference (two variables refer to the same instance) or creating a distinct string object with the same contents. This question targets creating a separate string instance with identical content. Given Data / Assumptions: We want to 'copy the contents' of one string into another. Options include assignment, String.Concat, String.Copy, and invalid usages. Concept / Approach: Assignment (s2 = s1) copies the reference, not the object; both variables point to the same immutable instance. String.Copy(s1) historically created a new string instance with the same content (note: it is obsolete in newer .NET, but within classic C#.NET contexts, it denotes a content copy). Concat concatenates and does not copy content alone. Replace() without arguments is invalid, and StringCopy is not an API. Step-by-Step Solution: Option A: Reference copy only (same instance) → not a distinct content copy.Option B: Concatenates s1 and s2 (undefined s2 content) → incorrect.Option C: String.Copy(s1) → creates a new string with the same contents.Option D: Invalid method usage.Option E: Nonexistent method. Verification / Alternative check: Another way to ensure a distinct instance is new string(s1.ToCharArray()), though rarely necessary. Since strings are immutable, reference sharing is usually safe. Why Other Options Are Wrong: They either do not produce a new object with the same contents or call invalid/nonexistent APIs. Common Pitfalls: Assuming assignment duplicates the object; in .NET it only assigns the reference. Final Answer: String s1 = 'String'; String s2;s2 = String.Copy(s1);

Question 18

C#.NET — What does this program print? namespace CuriousTabConsoleApplication { class SampleProgram { static void Main(string[] args) { string str = "Hello World!"; Console.WriteLine(String.Compare(str, "Hello World?").GetType()); } } } Predict the …

Accepted Answer

Introduction / Context: This C#.NET snippet tests understanding of return types, boxing of value types, and how Console.WriteLine formats objects. Specifically, it explores what happens when you call GetType() on the result of String.Compare. Given Data / Assumptions: String.Compare(string, string) returns an int (-1, 0, or 1 depending on ordering). GetType() is available on all objects and value types (via boxing semantics and methods defined on System.ValueType). Console.WriteLine calls ToString() on the object it receives. Concept / Approach: String.Compare(str, "Hello World?") produces an integer. Calling GetType() on an int yields a System.Type object that represents the type of the value, namely System.Int32. Printing a Type using WriteLine invokes its ToString(), which returns the fully qualified type name. Step-by-Step Solution: Compute comparison → some integer (the actual numeric value is irrelevant to the output).Call GetType() on that integer → returns a Type representing System.Int32.Print the Type → outputs the string System.Int32. Verification / Alternative check: Replace the call with Console.WriteLine(typeof(int)); the output is also System.Int32, confirming the behavior. Why Other Options Are Wrong: 0 or 1 are possible compare results but not what gets printed. String and Hello World? are not the Type name. The exact printed value is the fully qualified type name. Common Pitfalls: Confusing the comparison result with the printed type, or assuming GetType() is unavailable on value types. Final Answer: System.Int32

Question 19

C#.NET — Which is the correct way to find the index of the second 's' in the string: "She sells sea shells on the sea-shore"? Choose the valid code snippet that correctly identifies the second occurrence.

Accepted Answer

Introduction / Context: Locating the second occurrence of a character in a string is a standard string manipulation problem. In C#.NET, the IndexOf method is heavily used to search for substrings or characters, and it has an overload that accepts a starting index. This makes it possible to find subsequent occurrences of a character. Given Data / Assumptions: We are working with the string "She sells sea shells on the sea-shore". We want the index of the second lowercase 's'. The operation must be case-sensitive; uppercase S at the beginning is not the same as lowercase 's'. Concept / Approach: The proper approach is to find the first occurrence using IndexOf("s"). Then, to locate the second occurrence, use the overload IndexOf("s", i + 1), which searches the string starting from the next index position after the first match. Step-by-Step Solution: i = str.IndexOf("s"); → returns the first index of lowercase s.j = str.IndexOf("s", i + 1); → continues the search after the first match to find the second occurrence.The variable j now holds the index of the second s. Verification / Alternative check: A manual scan of the string shows lowercase s at positions 6 (in "sells") and 10 (in "sea"). The code correctly returns index 10 for the second occurrence. Why Other Options Are Wrong: (a) SecondIndexOf does not exist in .NET. (b) FirstIndexOf is not a valid method. (d) LastIndexOf finds the last occurrence, not the second. (e) Mixing uppercase and lowercase S incorrectly addresses the wrong character. Common Pitfalls: Forgetting that strings are zero-indexed or confusing uppercase and lowercase letters. Another frequent mistake is not incrementing the start index, which would simply return the same first occurrence again. Final Answer: String str = "She sells sea shells on the sea-shore"; int i, j; i = str.IndexOf("s"); j = str.IndexOf("s", i + 1);

Question 20

C#.NET strings — identify the correct statements about string type, literals, equality, bounds, and mutability.

Accepted Answer

Introduction / Context: Immutable strings are fundamental in .NET. This item checks knowledge of string type (reference vs value), literal rules, equality operator behavior, bounds checking, and whether contents can change after creation. Given Data / Assumptions: Five statements about strings are presented; select all true ones. C# string is an alias for System.String. Concept / Approach: Evaluate each claim against .NET semantics: immutability, operator overloading for equality, and runtime exceptions on invalid indexing. Step-by-Step Solution: 1) “String is a value type.” → False. It is a reference type.2) “String literals can contain escape sequences.” → True. Examples include "HelloWorld" or verbatim strings @""C:	emp"".3) “Equality operators compare values as well as references.” → False. == for string is overloaded to compare values (contents), not reference identity.4) “Out-of-bounds character access throws IndexOutOfRangeException.” → True for string indexer.5) “String contents can be changed after creation.” → False. Strings are immutable; use StringBuilder for in-place-like edits. Verification / Alternative check: Test object.ReferenceEquals(s1, s2) vs s1 == s2 to see value vs reference behavior; try s[9999] to observe the exception. Why Other Options Are Wrong: Any option containing 1, 3, or 5 is invalid due to the reasons above. Common Pitfalls: Confusing string interning (which can make references equal) with the semantics of ==, which compares contents. Final Answer: 2, 4

Strings Questions