30 C# Coding Interview Problems for Freshers

Most fresher coding rounds draw from the same small set of problems. For each one below you get the idea, the complexity, and working C# code that was compiled and run. Type each solution yourself before you read the next, then test it with an empty input, a single item and a duplicate.

Before you code, always say three things aloud: what the input and output are, what the edge cases are (null, empty, one item, duplicates, negative numbers), and what complexity you are aiming for.

Strings (problems 1, 2, 11, 12, 13, 18, 19, 28, 29)

#	Problem	Idea	Time
1	Reverse a string	Swap characters from both ends of a `char[]`	O(n)
2	Palindrome (ignore case and punctuation)	Compare from both ends, skipping non-alphanumeric characters	O(n)
11	Character frequency	`Dictionary<char, int>`	O(n)
12	First non-repeating character	Count first, then scan in order	O(n)
13	Anagram check	Compare character counts	O(n)
18	Longest word in a sentence	Split on non-letters and keep the longest	O(n)
19 and 28	Word frequency, as a sorted table	Split, lower-case, count in a dictionary, then order by count	O(n) plus sorting
29	Remove duplicate characters, keep order	`HashSet<char>` of what you have already seen	O(n)

Console.WriteLine(Reverse("interview"));                              // weivretni
Console.WriteLine(IsPalindrome("A man, a plan, a canal: Panama"));    // True
Console.WriteLine(FirstNonRepeating("swiss"));                        // w
Console.WriteLine(IsAnagram("listen", "silent"));                     // True
Console.WriteLine(LongestWord("Hello, wonderful world!"));            // wonderful
Console.WriteLine(RemoveDuplicateChars("programming"));               // progamin

foreach (var pair in WordFrequency("the cat and the hat and the bat"))
    Console.WriteLine($"{pair.Key}: {pair.Value}");

static string Reverse(string text)
{
    char[] chars = text.ToCharArray();
    for (int left = 0, right = chars.Length - 1; left < right; left++, right--)
        (chars[left], chars[right]) = (chars[right], chars[left]);
    return new string(chars);
}

static bool IsPalindrome(string text)
{
    int left = 0, right = text.Length - 1;
    while (left < right)
    {
        if (!char.IsLetterOrDigit(text[left])) { left++; continue; }
        if (!char.IsLetterOrDigit(text[right])) { right--; continue; }
        if (char.ToLowerInvariant(text[left]) != char.ToLowerInvariant(text[right])) return false;
        left++;
        right--;
    }
    return true;
}

static char? FirstNonRepeating(string text)
{
    var counts = new Dictionary<char, int>();
    foreach (char c in text) counts[c] = counts.GetValueOrDefault(c) + 1;
    foreach (char c in text) if (counts[c] == 1) return c;
    return null;
}

static bool IsAnagram(string a, string b)
{
    if (a.Length != b.Length) return false;
    var counts = new Dictionary<char, int>();
    foreach (char c in a) counts[c] = counts.GetValueOrDefault(c) + 1;
    foreach (char c in b)
    {
        if (!counts.TryGetValue(c, out int n) || n == 0) return false;
        counts[c] = n - 1;
    }
    return true;
}

static string LongestWord(string sentence)
{
    string longest = "";
    foreach (string word in sentence.Split(new[] { ' ', ',', '.', '!', '?' }, StringSplitOptions.RemoveEmptyEntries))
        if (word.Length > longest.Length) longest = word;
    return longest;
}

static string RemoveDuplicateChars(string text)
{
    var seen = new HashSet<char>();
    var result = new System.Text.StringBuilder();
    foreach (char c in text)
        if (seen.Add(c)) result.Append(c);
    return result.ToString();
}

static IEnumerable<KeyValuePair<string, int>> WordFrequency(string text)
{
    var counts = new Dictionary<string, int>();
    foreach (string word in text.ToLowerInvariant().Split(' ', StringSplitOptions.RemoveEmptyEntries))
        counts[word] = counts.GetValueOrDefault(word) + 1;
    return counts.OrderByDescending(p => p.Value).ThenBy(p => p.Key);
}

Standalone versions: reverse and palindrome and character frequency.

Numbers and maths (problems 3 to 8)

#	Problem	Idea	Time
3	Reverse an integer, detect 32-bit overflow	Pop digits with `% 10`, build with `checked` arithmetic	O(digits)
4	Factorial	Loop (or recursion) with `checked` to catch overflow, reject negatives	O(n)
5	Fibonacci	Keep only the last two values	O(n) time, O(1) space
6	Prime test	Try divisors up to the square root of n	O(sqrt n)
7	Armstrong number	Sum of each digit raised to the number of digits	O(digits)
8	Swap two values without a temp variable	Tuple swap, or XOR	O(1)

Notes worth saying aloud: the XOR swap does not work if both names refer to the same variable, and the tuple swap is the readable choice. Factorial overflows a above 20, which is why matters.

Arrays and searching (problems 9, 10, 14 to 17, 21, 22)

#	Problem	Idea	Time
9	Largest and second largest in one pass	Track two variables while scanning	O(n)
10	Remove duplicates without	of seen values	O(n)
14	Missing number from 1 to N	Expected sum minus actual sum	O(n)
15	Find all duplicates	returns false for a repeat	O(n)
16	Two sum	Dictionary of value to index, look up the complement	O(n)
17	Sort without library sort	Bubble sort (stop early if no swaps)	O(n squared)
21	Intersection of two arrays	Put one in a , scan the other	O(n + m)
22	Merge two sorted arrays	Two pointers, always take the smaller	O(n + m)

See also the standalone two sum snippet. For "missing number", mention that the sum formula can overflow for a huge , and that XOR is an overflow-free alternative.

Stacks, queues and caches (problems 20, 23, 24, 30)

#	Problem	Idea	Time
20	Balanced parentheses	Push openers on a , pop and match on closers	O(n)
23	Stack from scratch	Array plus a field; grow when full	O(1) per operation
24	Queue from scratch	Circular array with head and tail indexes	O(1) per operation
30	In-memory cache with expiry	Dictionary of value plus expiry time, for thread safety	O(1) average

Standalone: balanced parentheses. For production caching, mention (), which also handles eviction and size limits.

LINQ problems (problems 25, 26, 27)

#	Problem	Idea
25	Sort employees by department, then salary descending	then
26	Total inventory value per product category	then
27	Second highest distinct salary	, , , ,

Standalone: group and total with LINQ and second highest salary with LINQ.

How to practise

Do three problems a day. Type them from memory, then compare with the solution here.
For each, write down the complexity and one edge case that breaks a naive version.
Explain your solution aloud as if the interviewer were in the room. Then run the Top 50 questions as a speaking drill.