C# Pattern Matching Exercises: 20 Coding Problems with Solutions

using System;

class Program
{
    static string GetStatusMessage(int statusCode) => statusCode switch
    {
        200 => "OK",
        404 => "Not Found",
        500 => "Internal Server Error",
        _ => "Unknown Status Code"
    };

    static void Main()
    {
        Console.WriteLine(GetStatusMessage(404));
    }
}Code language: C# (cs)

Explanation:

• statusCode switch { ... }: A switch expression evaluates directly to a value, unlike a switch statement which executes a block of code.
• 200 => "OK": Each arm matches a literal value and produces the corresponding string.
• _ => "Unknown Status Code": The discard pattern acts as a default case, catching any status code not explicitly listed.
• Expression-bodied method: The switch expression is returned directly using =>, keeping the method compact.

using System;

class Program
{
    static string Simplify(bool? value) => value switch
    {
        true => "Yes",
        false => "No",
        null => "Maybe"
    };

    static void Main()
    {
        Console.WriteLine(Simplify(null));
    }
}Code language: C# (cs)

Explanation:

• bool? value: A nullable bool parameter, allowing three possible states: true, false, and null.
• true => "Yes" and false => "No": Match the two literal boolean values directly.
• null => "Maybe": Matches the absence of a value as its own distinct pattern.
• No discard needed: Because true, false, and null cover every possible value of bool?, the compiler doesn’t require a fallback _ arm.

using System;

class Program
{
    static string ClassifyDay(DayOfWeek day) => day switch
    {
        DayOfWeek.Saturday or DayOfWeek.Sunday => "Weekend",
        _ => "Weekday"
    };

    static void Main()
    {
        Console.WriteLine(ClassifyDay(DayOfWeek.Saturday));
    }
}Code language: C# (cs)

Explanation:

• DayOfWeek.Saturday or DayOfWeek.Sunday: Combines two enum values into a single case using the or pattern, avoiding two separate arms with the same result.
• _ => "Weekday": Matches every other day of the week with a single fallback arm.
• day switch { ... }: The switch expression evaluates the enum value once and returns the matching string.
• System.DayOfWeek: Reused directly from the framework instead of declaring a custom enum.

using System;

class Circle
{
    public double Radius { get; set; }
    public Circle(double radius) { Radius = radius; }
}

class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
}

class Program
{
    static string DescribeShape(object shape) => shape switch
    {
        Circle c => "It's a circle with radius " + c.Radius,
        Rectangle => "It's a rectangle",
        _ => "Unknown shape"
    };

    static void Main()
    {
        Console.WriteLine(DescribeShape(new Circle(5)));
    }
}Code language: C# (cs)

Explanation:

• Circle c => ...: A type pattern that checks whether shape is a Circle and, if so, captures it in the variable c so its Radius can be used directly.
• Rectangle => "It's a rectangle": A type pattern that only needs to confirm the type, so no variable name is required here.
• _ => "Unknown shape": Handles any object that isn’t a Circle or a Rectangle, since type patterns never match null either.
• Single expression: Replaces what would otherwise be an is check followed by a manual cast, combining both steps into one pattern.

using System;

class Program
{
    static int ToInt(object value) => value switch
    {
        int i => i,
        string s when int.TryParse(s, out int result) => result,
        _ => 0
    };

    static void Main()
    {
        Console.WriteLine(ToInt(42));
        Console.WriteLine(ToInt("100"));
        Console.WriteLine(ToInt("abc"));
    }
}Code language: C# (cs)

Explanation:

• int i => i: Matches when the value is already an int, returning it directly without any conversion.
• string s when int.TryParse(s, out int result) => result: Matches a string only if it can be successfully parsed, using a when clause to add that extra condition to the pattern.
• Failed parse: If TryParse fails, as with "abc", the pattern doesn’t match, so the switch expression moves on to the next arm instead of throwing an exception.
• _ => 0: The fallback for any value that is neither an int nor a parseable string.

using System;
using System.Collections.Generic;

class Program
{
    static string DescribeCollection(object collection) => collection switch
    {
        List<int> => "List<int>",
        int[] => "int array",
        _ => "Other collection type"
    };

    static void Main()
    {
        Console.WriteLine(DescribeCollection(new List<int> { 1, 2, 3 }));
        Console.WriteLine(DescribeCollection(new int[] { 1, 2, 3 }));
        Console.WriteLine(DescribeCollection(new Dictionary<string, int>()));
    }
}Code language: C# (cs)

Explanation:

• List<int> => "List<int>": Matches only when the object’s runtime type is exactly List<int>, not other generic list types.
• int[] => "int array": Matches when the object is an integer array specifically.
• Pattern order: More specific patterns are placed before the general fallback, since a switch expression evaluates its arms in order.
• _ => "Other collection type": Catches everything else, including other generic collections like Dictionary<string, int>.

using System;

class Order
{
    public decimal TotalPrice { get; set; }
    public bool IsPremiumCustomer { get; set; }
}

class Program
{
    static string GetDiscount(Order order) => order switch
    {
        { IsPremiumCustomer: true } when order.TotalPrice > 100 => "Discount = 20%",
        { IsPremiumCustomer: true } => "Discount = 10%",
        _ => "Discount = 0%"
    };

    static void Main()
    {
        Order order = new Order { TotalPrice = 150, IsPremiumCustomer = true };
        Console.WriteLine(GetDiscount(order));
    }
}Code language: C# (cs)

Explanation:

• { IsPremiumCustomer: true } when order.TotalPrice > 100: A property pattern combined with a when clause, matching only premium customers whose order also exceeds $100.
• { IsPremiumCustomer: true } => "Discount = 10%": Matches any remaining premium customer that didn’t satisfy the first, more specific arm.
• Arm order matters: The over-$100 premium case is placed first so it is checked before the general premium case.
• _ => "Discount = 0%": Covers every non-premium customer, regardless of their total price.

using System;

class Address
{
    public string Country { get; set; }
}

class Profile
{
    public Address Address { get; set; }
}

class User
{
    public Profile Profile { get; set; }
}

class Program
{
    static string CheckCountry(User user) => user switch
    {
        { Profile: { Address: { Country: "Canada" } } } => "User is from Canada",
        _ => "User is not from Canada"
    };

    static void Main()
    {
        User user = new User
        {
            Profile = new Profile
            {
                Address = new Address { Country = "Canada" }
            }
        };

        Console.WriteLine(CheckCountry(user));
    }
}Code language: C# (cs)

Explanation:

• { Profile: { Address: { Country: "Canada" } } }: A nested property pattern that drills into Profile, then Address, then Country, all in a single expression.
• Implicit null safety: If Profile or Address were null anywhere along the chain, the pattern simply fails to match instead of throwing a NullReferenceException.
• Compared to manual checks: This replaces what would otherwise require checking user.Profile != null, then user.Profile.Address != null, before finally comparing Country.
• _ => "User is not from Canada": Handles every case where the nested pattern doesn’t match, including a null Profile or Address.

using System;

class Button
{
    public bool IsEnabled { get; set; }
    public bool IsHovered { get; set; }
    public bool IsPressed { get; set; }
}

class Program
{
    static string GetState(Button button) => button switch
    {
        { IsEnabled: false } => "Disabled",
        { IsHovered: true } => "Highlighted",
        { IsPressed: true } => "Clicked",
        _ => "Normal"
    };

    static void Main()
    {
        Button button = new Button { IsEnabled = true, IsHovered = false, IsPressed = true };
        Console.WriteLine(GetState(button));
    }
}Code language: C# (cs)

Explanation:

• { IsEnabled: false } => "Disabled": Checked first, since a disabled button should report its state regardless of hover or press flags.
• { IsHovered: true } => "Highlighted": Checked next, taking priority over the pressed state in this ordering.
• { IsPressed: true } => "Clicked": Only reached if the button is enabled and not currently hovered.
• _ => "Normal": The fallback for a button that is enabled, not hovered, and not pressed.

using System;

record Point(int X, int Y);

class Program
{
    static string GetQuadrant(Point point) => point switch
    {
        (> 0, > 0) => "Quadrant 1",
        (< 0, > 0) => "Quadrant 2",
        (< 0, < 0) => "Quadrant 3",
        (> 0, < 0) => "Quadrant 4",
        _ => "On an axis"
    };

    static void Main()
    {
        Point point = new Point(3, 4);
        Console.WriteLine(GetQuadrant(point));
    }
}Code language: C# (cs)

Explanation:

• record Point(int X, int Y): A record with positional parameters, which automatically supports deconstruction into X and Y for pattern matching.
• (> 0, > 0) => "Quadrant 1": A positional pattern that deconstructs the point and applies a relational pattern to each coordinate in one step.
• Relational patterns: Patterns like > 0 and < 0 check numeric ranges directly inside the pattern instead of requiring separate if conditions.
• _ => "On an axis": Handles any point where X or Y is exactly zero, since none of the four quadrant patterns would match.

using System;

class Program
{
    static bool ValidateLogin((string username, string password) credentials) => credentials switch
    {
        ("admin", "P@ssw0rd") => true,
        _ => false
    };

    static void Main()
    {
        Console.WriteLine(ValidateLogin(("admin", "P@ssw0rd")));
        Console.WriteLine(ValidateLogin(("admin", "wrongpass")));
    }
}Code language: C# (cs)

Explanation:

• (string username, string password) credentials: A tuple parameter that groups the username and password into a single value.
• ("admin", "P@ssw0rd") => true: A tuple pattern that matches only when both elements equal the specified literals at the same time.
• _ => false: Catches every other combination, including a correct username paired with an incorrect password.
• Single expression: Replaces what would otherwise require two separate == comparisons joined by &&.

using System;

enum LightState
{
    Red,
    Yellow,
    Green
}

class Program
{
    static LightState GetNextState((LightState current, bool pedestrianWaiting) state) => state switch
    {
        (LightState.Red, true) => LightState.Red,
        (LightState.Red, false) => LightState.Green,
        (LightState.Green, true) => LightState.Yellow,
        (LightState.Green, false) => LightState.Green,
        (LightState.Yellow, _) => LightState.Red
    };

    static void Main()
    {
        LightState next = GetNextState((LightState.Red, true));
        Console.WriteLine(next);
    }
}Code language: C# (cs)

Explanation:

• (LightState current, bool pedestrianWaiting): A tuple parameter combining the current light and whether a pedestrian is waiting.
• (LightState.Red, true) => LightState.Red: Matches both elements together, keeping the light red as long as a pedestrian is still waiting.
• (LightState.Red, false) => LightState.Green: Matches when no pedestrian is waiting, allowing the light to change.
• (LightState.Yellow, _) => LightState.Red: Uses a discard for the second element since a yellow light always moves to red regardless of pedestrian status.

using System;

class Program
{
    static string CategorizeAge(int age) => age switch
    {
        < 13 => "Child",
        >= 13 and <= 19 => "Teenager",
        >= 20 and <= 64 => "Adult",
        >= 65 => "Senior"
    };

    static void Main()
    {
        Console.WriteLine(CategorizeAge(45));
    }
}Code language: C# (cs)

Explanation:

• < 13 => "Child": A relational pattern matching any age below 13.
• >= 13 and <= 19 => "Teenager": Combines two relational patterns with the and pattern to express an inclusive range.
• >= 20 and <= 64 => "Adult": Applies the same technique to the adult range.
• >= 65 => "Senior": A single relational pattern covers every remaining age, since it’s the highest range in the sequence.

using System;

class Program
{
    static bool IsValidTemperature(double temperature) => temperature is > 0.0 and <= 100.0;

    static void Main()
    {
        Console.WriteLine(IsValidTemperature(37.5));
    }
}Code language: C# (cs)

Explanation:

• temperature is > 0.0 and <= 100.0: A single pattern-matching expression combining two relational patterns, equivalent to temperature > 0.0 && temperature <= 100.0.
• and pattern: Requires the value to satisfy both relational conditions at once rather than either one alone.
• is expression: Returns a bool directly, making it well suited for a single validation check instead of a full switch expression.
• Boundary behavior: A temperature of exactly 100.0 still returns true, while 0.0 itself returns false, since the lower bound is exclusive.

using System;

class Program
{
    static bool IsValid(object value) => value is not null and not "";

    static void Main()
    {
        Console.WriteLine(IsValid("Hello"));
        Console.WriteLine(IsValid(""));
    }
}Code language: C# (cs)

Explanation:

• not null: A negated pattern that matches any value except null.
• not "": A negated constant pattern that matches any value except the specific empty string.
• and: Requires both negated patterns to hold true, so a null value or an empty string returns false.
• object value: Because the parameter type is object, the same check works for any value, not just strings, since a non-string value would already satisfy not "".

using System;

class Program
{
    static bool StartsWithOneTwoThree(int[] numbers) => numbers is [1, 2, 3, ..];

    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        Console.WriteLine(StartsWithOneTwoThree(numbers));
    }
}Code language: C# (cs)

Explanation:

• numbers is [1, 2, 3, ..]: A list pattern matching an array whose first three elements are exactly 1, 2, and 3.
• .. (slice pattern): Matches any number of remaining elements, including zero, so the array can be any length as long as it starts correctly.
• List patterns: Work directly against arrays and other countable, indexable types without needing to call methods like Take or manually index into the array.
• Short-circuit behavior: If the array has fewer than three elements, the pattern simply fails to match instead of throwing an exception.

using System;

class Program
{
    static bool IsActiveIdRow(string[] row) => row is ["ID", _, "Active"];

    static void Main()
    {
        string[] row = { "ID", "42", "Active" };
        Console.WriteLine(IsActiveIdRow(row));
    }
}Code language: C# (cs)

Explanation:

• row is ["ID", _, "Active"]: A list pattern requiring exactly three elements, since no slice pattern is present.
• "ID" and "Active": Literal patterns pinning the first and last elements to specific values.
• _: A discard pattern for the middle element, matching any value without capturing it.
• Exact length requirement: A row with two elements or four elements would not match this pattern at all, regardless of its content.

using System;

class Program
{
    static bool StartsAndEndsCorrectly(int[] numbers) => numbers is [0, .., 9];

    static void Main()
    {
        int[] numbers = { 0, 4, 7, 9 };
        Console.WriteLine(StartsAndEndsCorrectly(numbers));
    }
}Code language: C# (cs)

Explanation:

• numbers is [0, .., 9]: A list pattern pinning the first element to 0 and the last element to 9, with .. absorbing everything in between.
• .. in the middle: Matches zero or more elements, so both [0, 9] and [0, 4, 7, 9] satisfy the same pattern.
• Minimum length: The pattern still requires at least two elements, since the first and last positions cannot overlap.
• No extra discard needed: The slice pattern already ignores its contents entirely, so a separate _ for the middle section isn’t required.

using System;

class Program
{
    static string CheckFirstRow(char[][] board)
    {
        return board[0] switch
        {
            ['X', 'X', 'X'] => "First row is a winning line",
            _ => "First row is not a winning line"
        };
    }

    static void Main()
    {
        char[][] board =
        {
            new char[] { 'X', 'X', 'X' },
            new char[] { 'O', 'X', 'O' },
            new char[] { 'O', 'O', 'X' }
        };

        Console.WriteLine(CheckFirstRow(board));
    }
}Code language: C# (cs)

Explanation:

• board[0]: Extracts the first row from the jagged array before the pattern is applied to it.
• ['X', 'X', 'X']: A list pattern requiring exactly three elements, each matching the literal character 'X'.
• Switch expression on a single row: Applies the same list pattern technique used for one-dimensional arrays, just to a row extracted from a larger grid.
• _ => "First row is not a winning line": Handles any row that doesn’t consist of exactly three X’s, including rows with a mix of X, O, or a different length.