Positional patterns in C Sharp (C#) - Time & Space Complexity

Time Complexity: Positional patterns

O(n)

Understanding Time Complexity

We want to understand how long it takes for a program using positional patterns to run as the input grows.

Specifically, how does the time change when matching patterns in data structures?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

record Point(int X, int Y);

string DescribePoint(Point p) => p switch
{
    (0, 0) => "Origin",
    (var x, 0) => $"X={x} on X-axis",
    (0, var y) => $"Y={y} on Y-axis",
    (var x, var y) => $"Point at ({x},{y})"
};

This code uses positional patterns to check where a point lies and returns a description.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Matching the input point against each pattern in the switch.
• How many times: Each call checks up to 4 patterns in order until one matches.

How Execution Grows With Input

Each point checked runs through the same fixed number of pattern checks.

Input Size (n)	Approx. Operations
10	About 40 pattern checks (10 points x 4 patterns)
100	About 400 pattern checks
1000	About 4000 pattern checks

Pattern observation: The number of operations grows directly with the number of points checked.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line as you check more points.

Common Mistake

[X] Wrong: "Positional patterns make the code run slower exponentially because of multiple checks."

[OK] Correct: Each pattern check is constant time and fixed in number, so total time grows linearly with input size, not exponentially.

Interview Connect

Understanding how pattern matching scales helps you explain your code's efficiency clearly and confidently.

Self-Check

What if we added more patterns to the switch? How would the time complexity change?

Practice

1.

What is the main purpose of positional patterns in C#?

record Point(int X, int Y);
Using case Point(var x, var y): inside a switch statement helps to:

easy

A. Extract values of X and Y from a Point object easily

B. Create a new Point object with given X and Y

C. Change the values of X and Y in the Point object

D. Call a method named Deconstruct on the Point object

Solution

1. Step 1: Understand positional pattern usage

   Positional patterns allow matching an object and extracting its parts in one step, like case Point(var x, var y):.

2. Step 2: Identify what the pattern does with Point

   It extracts the X and Y values from the Point object into variables x and y for use inside the case block.

3. Final Answer:

   Extract values of X and Y from a Point object easily -> Option A

4. Quick Check:

   Positional pattern extracts values [OK]

Hint: Positional patterns extract parts of an object [OK]

Common Mistakes:

• Thinking positional patterns create or modify objects
• Confusing Deconstruct method call with pattern matching
• Assuming positional patterns only check types without extracting

2.

Which of the following is the correct syntax for using a positional pattern with a record Person(string Name, int Age) inside a switch expression?

switch(person) {
    case ???:
        // code
        break;
}

easy

A. Person(var name, var age)

B. Person[name, age]

C. Person{name, age}

D. Person(name: name, age: age)

Solution

1. Step 1: Recall positional pattern syntax

   Positional patterns use parentheses with variables: Type(var1, var2).

2. Step 2: Match syntax to options

   Person(var name, var age) uses parentheses and variables correctly: Person(var name, var age). Others use invalid syntax for positional patterns.

3. Final Answer:

   Person(var name, var age) -> Option A

4. Quick Check:

   Positional pattern syntax uses parentheses [OK]

Hint: Positional patterns always use parentheses, not brackets or braces [OK]

Common Mistakes:

• Using square brackets or curly braces instead of parentheses
• Trying to use named arguments syntax inside patterns
• Omitting var keyword or variable names

3.

What is the output of the following code?

record Point(int X, int Y);

var p = new Point(3, 4);
switch (p)
{
    case Point(0, 0):
        Console.WriteLine("Origin");
        break;
    case Point(var x, var y) when x == y:
        Console.WriteLine("On diagonal");
        break;
    case Point(var x, var y):
        Console.WriteLine($"Point at ({x}, {y})");
        break;
}

medium

A. Origin

B. Point at (3, 4)

C. On diagonal

D. No output

Solution

1. Step 1: Check first case Point(0, 0)

   p is (3,4), so it does not match (0,0).

2. Step 2: Check second case with condition x == y

   x=3, y=4, so x != y; condition fails.

3. Step 3: Third case matches any Point and prints coordinates

   It matches and prints "Point at (3, 4)".

4. Final Answer:

   Point at (3, 4) -> Option B

5. Quick Check:

   Pattern matches last case with output [OK]

Hint: Check cases top to bottom; first match runs [OK]

Common Mistakes:

• Assuming (3,4) matches (0,0)
• Ignoring the when condition in second case
• Thinking no case matches and no output

4.

Identify the error in this code snippet using positional patterns:

record Rectangle(int Width, int Height);

var rect = new Rectangle(5, 10);
switch(rect)
{
    case Rectangle(var w, var h):
        Console.WriteLine($"Width: {w}, Height: {h}");
        break;
    case Rectangle(w, h):
        Console.WriteLine("Invalid pattern");
        break;
}

medium

A. Switch expression cannot use records

B. First case should use named arguments instead of positional pattern

C. Second case uses variables without var keyword, causing a syntax error

D. No error, code runs fine

Solution

1. Step 1: Review positional pattern variable declaration

   Variables in positional patterns must be declared with var or a type.

2. Step 2: Identify error in second case

   Second case uses Rectangle(w, h) without var, which is invalid syntax.

3. Final Answer:

   Second case uses variables without var keyword, causing a syntax error -> Option C

4. Quick Check:

   Variables need var keyword in patterns [OK]

Hint: Always declare variables with var in positional patterns [OK]

Common Mistakes:

• Omitting var keyword for variables in patterns
• Thinking records can't be used in switch
• Confusing named arguments with pattern variables

5.

Given the record Person(string Name, int Age), write a switch expression using positional patterns that returns:

• "Child" if Age < 13
• "Teen" if Age is between 13 and 19 inclusive
• "Adult" otherwise

Which of the following switch expressions correctly implements this?

hard

A. person switch {
Person(_, var age) when age < 13 => "Child",
Person(_, var age) when age > 13 && age <= 19 => "Teen",
Person(_, _) => "Adult"
};

B. person switch {
Person(var name, var age) when age < 13 => "Child",
Person(var name, var age) when age > 13 && age < 19 => "Teen",
_ => "Adult"
};

C. person switch {
Person(var name, var age) when age <= 13 => "Child",
Person(var name, var age) when age >= 13 && age <= 19 => "Teen",
Person(var name, var age) => "Adult"
};

D. person switch {
Person(var name, var age) when age < 13 => "Child",
Person(var name, var age) when age >= 13 && age <= 19 => "Teen",
Person(var name, var age) => "Adult"
};

Solution

1. Step 1: Check age ranges and conditions

   Child: age < 13, Teen: 13 ≤ age ≤ 19, Adult: otherwise.

2. Step 2: Analyze each option's conditions

   person switch { Person(var name, var age) when age < 13 => "Child", Person(var name, var age) when age >= 13 && age <= 19 => "Teen", Person(var name, var age) => "Adult" }; correctly uses age < 13 for Child, age >= 13 && age <= 19 for Teen, and default Adult case. person switch { Person(_, var age) when age < 13 => "Child", Person(_, var age) when age > 13 && age <= 19 => "Teen", Person(_, _) => "Adult" }; misses age=13 (falls to Adult) because Teen condition uses > 13. person switch { Person(var name, var age) when age < 13 => "Child", Person(var name, var age) when age > 13 && age < 19 => "Teen", _ => "Adult" }; excludes age == 13 and 19 for Teen. person switch { Person(var name, var age) when age <= 13 => "Child", Person(var name, var age) when age >= 13 && age <= 19 => "Teen", Person(var name, var age) => "Adult" }; overlaps Child and Teen at age 13.

3. Step 3: Confirm the correct implementation

   person switch { Person(var name, var age) when age < 13 => "Child", Person(var name, var age) when age >= 13 && age <= 19 => "Teen", Person(var name, var age) => "Adult" }; matches all conditions correctly and clearly.

4. Final Answer:

   Option D code correctly implements the age groups -> Option D

5. Quick Check:

   Check age ranges carefully in when clauses [OK]

Hint: Check boundary conditions carefully in when clauses [OK]

Common Mistakes:

• Overlapping or missing age boundaries
• Using _ wildcard instead of variables when needed
• Incorrect logical operators in conditions