C# Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

Console.WriteLine("Hello, world!");

Run the project:

dotnet run

This prints a line to standard output. In a small C# app, Console.WriteLine is the usual starting point.

Variables

string name = "Dan";
int count = 1;
bool active = true;
var language = "C#";

This shows common C# types plus var, which lets the compiler infer the type from the value on the right.

Methods

static string Greet(string name)
{
    return $"Hello, {name}!";
}

This is a basic C# method: it accepts an argument, builds a string, and returns the result.

Add

Mon, 01 Jan 0001 00:00:00 +0000

C# Add

static int Add(int param1, int param2)
{
    return param1 + param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

C# Add Border

static string[] AddBorder(string[] picture)
{
    var rows = new List<string> { new string('*', picture[0].Length) };
    rows.AddRange(picture);

    for (int i = 0; i < rows.Count; i++)
    {
        rows[i] = $"*{rows[i]}*";
    }

    rows.Add(new string('*', rows[0].Length));

    return rows.ToArray();
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

C# Adjacent Elements Product

static long AdjacentElementsProduct(int[] inputArray)
{
    long max = long.MinValue;

    for (int i = 0; i < inputArray.Length - 1; i++)
    {
        max = Math.Max(max, (long)inputArray[i] * inputArray[i + 1]);
    }

    return max;
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

C# Almost Magic Square

static int[] AlmostMagicSquare(int[] a)
{
    var rowSum = new int[3];
    var colSum = new int[3];
    var maxSum = 0;

    var grid = new int[3][];
    for (int i = 0; i < 3; i++)
    {
        grid[i] = new[] { a[i * 3], a[i * 3 + 1], a[i * 3 + 2] };
    }

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            rowSum[i] += grid[i][j];
            colSum[i] += grid[j][i];
        }
    }

    for (int k = 0; k < 3; k++)
    {
        maxSum = Math.Max(maxSum, rowSum[k]);
        maxSum = Math.Max(maxSum, colSum[k]);
    }

    for (int i = 0, j = 0; i < 3 && j < 3;)
    {
        var diff = Math.Min(maxSum - rowSum[i], maxSum - colSum[j]);
        grid[i][j] += diff;
        rowSum[i] += diff;
        colSum[j] += diff;

        if (rowSum[i] == maxSum)
        {
            i++;
        }
        if (colSum[j] == maxSum)
        {
            j++;
        }
    }

    var result = new int[9];
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            result[i * 3 + j] = grid[i][j];
        }
    }

    return result;
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

C# Are Equally Strong

static bool AreEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight)
{
    return Math.Max(yourRight, yourLeft) == Math.Max(friendsLeft, friendsRight)
           && Math.Min(yourLeft, yourRight) == Math.Min(friendsRight, friendsLeft);
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

C# Array Change

static long ArrayChange(int[] a)
{
    var arr = new long[a.Length];
    Array.Copy(a, arr, a.Length);
    long min = 0;

    for (int k = 0; k < arr.Length - 1; k++)
    {
        if (arr[k] >= arr[k + 1])
        {
            var dif = arr[k] - arr[k + 1] + 1;
            arr[k + 1] += dif;
            min += dif;
        }
    }

    return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

C# Array Maximal Adjacement Difference

static long ArrayMaximalAdjacentDifference(int[] a)
{
    long dif = 0;

    for (int i = 1; i < a.Length - 1; i++)
    {
        dif = Math.Max(dif, Math.Max(Math.Abs((long)a[i] - a[i - 1]), Math.Abs((long)a[i] - a[i + 1])));
    }

    return dif;
}

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

C# Binary Gap

static int BinaryGap(int n)
{
    var binary = Convert.ToString(n, 2).Trim('0');
    var gap = 0;

    foreach (var zero in binary.Split('1'))
    {
        gap = Math.Max(gap, zero.Length);
    }

    return gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

C# Bracket

static int Bracket(string s)
{
    var stack = new Stack<char>();

    foreach (var v in s)
    {
        switch (v)
        {
            case ')':
                if (stack.Count == 0 || stack.Pop() != '(')
                {
                    return 0;
                }
                break;
            case ']':
                if (stack.Count == 0 || stack.Pop() != '[')
                {
                    return 0;
                }
                break;
            case '}':
                if (stack.Count == 0 || stack.Pop() != '{')
                {
                    return 0;
                }
                break;
            default:
                stack.Push(v);
                break;
        }
    }

    return stack.Count == 0 ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

C# Century From Year

static int CenturyFromYear(int year)
{
    return (int)Math.Ceiling(year / 100.0);
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

C# Check Palindrome

static bool CheckPalindrome(string inputString)
{
    var reversed = new string(inputString.Reverse().ToArray());

    return reversed == inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

C# Chocolates By Numbers

static long ChocolatesByNumbers(long n, long m)
{
    long Gcd(long x, long y) => x % y == 0 ? y : Gcd(y, x % y);

    return (n * m) / Gcd(n, m) / m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

C# Common Prime Divisors

static int CommonPrimeDivisors(int[] a, int[] b)
{
    long Gcd(long n, long m) => n % m == 0 ? m : Gcd(m, n % m);

    long RemoveCommonPrimeDivisors(long n, long m)
    {
        while (n != 1)
        {
            var d = Gcd(n, m);
            if (d == 1)
            {
                break;
            }
            n /= d;
        }

        return n;
    }

    var counter = 0;
    for (int i = 0; i < a.Length; i++)
    {
        long x = a[i];
        long y = b[i];
        var d = Gcd(x, y);

        x = RemoveCommonPrimeDivisors(x, d);
        if (x != 1)
        {
            continue;
        }

        y = RemoveCommonPrimeDivisors(y, d);
        if (y == 1)
        {
            counter++;
        }
    }

    return counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Div

static long CountDiv(long a, long b, long k)
{
    var firstDiv = a % k == 0 ? a : a + (k - a % k);
    var lastDiv = b - b % k;

    return (lastDiv - firstDiv) / k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Factors

static int CountFactors(long n)
{
    var count = 0;
    long i = 1;

    while (i * i < n)
    {
        if (n % i == 0)
        {
            count += 2;
        }
        i++;
    }
    if (i * i == n)
    {
        count++;
    }

    return count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Non Divisible

static int[] CountNonDivisible(int[] a)
{
    var size = a.Length;
    var nondivisor = new int[size];
    var occurrences = new int[a.Max() + 1];

    foreach (var v in a)
    {
        occurrences[v]++;
    }

    for (int k = 0; k < size; k++)
    {
        var v = a[k];
        var count = 0;
        var i = 1;
        while (i * i <= v)
        {
            if (v % i == 0)
            {
                count += occurrences[i];
                if (v / i != i)
                {
                    count += occurrences[v / i];
                }
            }
            i++;
        }
        nondivisor[k] = size - count;
    }

    return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

C# Count Semi Primes

static int[] CountSemiPrimes(int n, int[] p, int[] q)
{
    var primes = new bool[n + 1];
    Array.Fill(primes, true);
    var semiPrimes = new int[n + 1];

    for (int i = 2; i * i <= n; i++)
    {
        if (primes[i])
        {
            for (int k = i * i; k <= n; k += i)
            {
                primes[k] = false;
            }
        }
    }

    for (int k = 2; k * k <= n; k++)
    {
        if (primes[k])
        {
            for (int i = 2; i * k <= n; i++)
            {
                if (primes[i])
                {
                    semiPrimes[k * i] = 1;
                }
            }
        }
    }

    for (int i = 1; i <= n; i++)
    {
        semiPrimes[i] += semiPrimes[i - 1];
    }

    var semiPrimeCounts = new int[p.Length];
    for (int k = 0; k < p.Length; k++)
    {
        semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
    }

    return semiPrimeCounts;
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

C# Cyclic Rotation

static int[] CyclicRotation(int[] a, int k)
{
    if (a.Length == 0)
    {
        return a;
    }

    var list = new List<int>(a);
    for (int i = 0; i < k; i++)
    {
        var last = list[^1];
        list.RemoveAt(list.Count - 1);
        list.Insert(0, last);
    }

    return list.ToArray();
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

C# Distinct

static int Distinct(int[] a)
{
    return new HashSet<int>(a).Count;
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

C# Dominator

static int Dominator(int[] a)
{
    var size = 0;
    var value = 0;
    var index = 0;

    for (int k = 0; k < a.Length; k++)
    {
        var v = a[k];
        if (size == 0)
        {
            size++;
            value = v;
            index = k;
        }
        else if (value != v)
        {
            size--;
        }
        else
        {
            size++;
        }
    }

    var candidate = size > 0 ? value : -1;
    var count = 0;
    foreach (var v in a)
    {
        if (v == candidate)
        {
            count++;
        }
    }

    if (count <= a.Length / 2.0)
    {
        index = -1;
    }

    return index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

C# Equi Leader

static int EquiLeader(int[] a)
{
    var leaderSize = 0;
    var value = 0;

    foreach (var v in a)
    {
        if (leaderSize == 0)
        {
            leaderSize++;
            value = v;
        }
        else if (value != v)
        {
            leaderSize--;
        }
        else
        {
            leaderSize++;
        }
    }

    var candidate = leaderSize > 0 ? value : -1;
    var leaderCount = 0;
    foreach (var v in a)
    {
        if (v == candidate)
        {
            leaderCount++;
        }
    }

    var leader = -1;
    if (leaderCount > a.Length / 2.0)
    {
        leader = candidate;
    }

    var count = a.Length;
    var lLeaderCount = 0;
    var equiLeaders = 0;

    for (int k = 0; k < count; k++)
    {
        var v = a[k];
        var leftHalf = (k + 1) / 2;
        var rightHalf = (count - k - 1) / 2;
        if (v == leader)
        {
            lLeaderCount++;
        }

        var rLeaderCount = leaderCount - lLeaderCount;
        if (lLeaderCount > leftHalf && rLeaderCount > rightHalf)
        {
            equiLeaders++;
        }
    }

    return equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

C# Fib Frog

static int FibFrog(int[] a)
{
    var size = a.Length;

    var fib = new List<int> { 0, 1 };
    for (int i = 1; fib[i] <= size;)
    {
        i++;
        fib.Add(fib[i - 1] + fib[i - 2]);
    }

    var queue = new Queue<(int Idx, int Jmp)>();
    queue.Enqueue((-1, 0));

    var visited = new bool[size];

    while (queue.Count > 0)
    {
        var (idx0, jmp) = queue.Dequeue();
        for (int i = fib.Count - 1; i >= 2; i--)
        {
            var idx = idx0 + fib[i];
            if (idx == size)
            {
                return jmp + 1;
            }
            if (idx > size || visited[idx] || a[idx] == 0)
            {
                continue;
            }
            if (a[idx] == 1)
            {
                visited[idx] = true;
                queue.Enqueue((idx, jmp + 1));
            }
        }
    }

    return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

C# Fish

static int Fish(int[] a, int[] b)
{
    var size = a.Length;
    var dead = 0;
    var fish = new Stack<int>();

    for (int i = 0; i < size; i++)
    {
        if (b[i] == 1)
        {
            fish.Push(a[i]);
        }
        else
        {
            while (fish.Count > 0)
            {
                dead++;
                if (a[i] > fish.Peek())
                {
                    fish.Pop();
                }
                else
                {
                    break;
                }
            }
        }
    }

    return size - dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

C# Flags

static int Flags(int[] a)
{
    var size = a.Length;
    if (size == 0)
    {
        return 0;
    }

    var peaks = new bool[size];
    var next = new int[size];

    for (int i = 1; i < size; i++)
    {
        var right = i + 1 < size ? a[i + 1] : 0;
        peaks[i] = a[i - 1] < a[i] && a[i] > right;
    }

    next[size - 1] = -1;
    for (int i = size - 2; i >= 0; i--)
    {
        next[i] = peaks[i] ? i : next[i + 1];
    }

    var result = 0;
    for (int i = 1; i * (i - 1) <= size; i++)
    {
        var pos = 0;
        var num = 0;
        while (pos < size && num < i)
        {
            pos = next[pos];
            if (pos == -1)
            {
                break;
            }
            num++;
            pos += i;
        }
        result = Math.Max(result, num);
    }

    return result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

C# Frog Jmp

static long FrogJmp(long x, long y, long d)
{
    return (long)Math.Ceiling((double)(y - x) / d);
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

C# Frog River One

static int FrogRiverOne(int x, int[] a)
{
    var existing = new HashSet<int>();

    for (int k = 0; k < a.Length; k++)
    {
        var i = a[k];
        if (i <= x && existing.Add(i) && existing.Count == x)
        {
            return k;
        }
    }

    return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

C# Genomic Range Query

static int[] GenomicRangeQuery(string s, int[] p, int[] q)
{
    var r = new int[p.Length];

    for (int k = 0; k < p.Length; k++)
    {
        var pi = p[k];
        var length = q[k] - pi + 1;
        var subStr = s.Substring(pi, length);

        if (subStr.Contains('A'))
        {
            r[k] = 1;
        }
        else if (subStr.Contains('C'))
        {
            r[k] = 2;
        }
        else if (subStr.Contains('G'))
        {
            r[k] = 3;
        }
        else
        {
            r[k] = 4;
        }
    }

    return r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

C# Is Ipv 4 Adress

static bool IsIPv4Address(string inputString)
{
    var parts = inputString.Split('.');

    foreach (var v in parts)
    {
        if (!long.TryParse(v, out var n) || n > 255 || v == "" || v != n.ToString())
        {
            return false;
        }
    }

    return parts.Length == 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

C# Ladder

static int[] Ladder(int[] a, int[] b)
{
    var size = a.Length;
    var r = new int[size];
    var mod = (1 << b.Max()) - 1;

    var limit = a.Max();
    var fib = new int[limit + 2];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i < limit + 2; i++)
    {
        fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
    }

    for (int i = 0; i < size; i++)
    {
        r[i] = fib[a[i] + 1] & ((1 << b[i]) - 1);
    }

    return r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

C# Largest String

static string LargestString(string s)
{
    var chars = s.ToCharArray();
    var len = chars.Length;
    var cur = "";

    for (int i = len - 1; i >= 0; i--)
    {
        cur = chars[i] + cur;

        if (cur.Length == 3)
        {
            if (cur == "abb")
            {
                chars[i] = 'b';
                chars[i + 1] = 'a';
                chars[i + 2] = 'a';

                if (i + 4 < len && chars[i + 4] == 'b')
                {
                    i += 4 + 1;
                }
                else if (i + 3 < len && chars[i + 3] == 'b')
                {
                    i += 3 + 1;
                }
                else if (chars[i + 2] == 'b')
                {
                    i += 2 + 1;
                }
            }

            if (chars[i + 1] == 'b')
            {
                i += 1 + 1;
            }
            else
            {
                i++;
            }
            cur = "";
        }
    }

    return new string(chars);
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Counters

static int[] MaxCounters(int n, int[] a)
{
    var counters = new int[n];
    var maxCounter = 0;
    var lastUpdate = 0;
    var condition = n + 1;

    foreach (var v in a)
    {
        if (v <= n)
        {
            var index = v - 1;
            if (counters[index] < lastUpdate)
            {
                counters[index] = lastUpdate;
            }
            counters[index]++;
            maxCounter = Math.Max(counters[index], maxCounter);
        }
        if (v == condition)
        {
            lastUpdate = maxCounter;
        }
    }

    // apply all max operations to avoid O(M*N) complexity
    for (int k = 0; k < counters.Length; k++)
    {
        if (counters[k] < lastUpdate)
        {
            counters[k] = lastUpdate;
        }
    }

    return counters;
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Double Slice Sum

static long MaxDoubleSliceSum(int[] a)
{
    var size = a.Length;
    if (size < 3)
    {
        return 0;
    }

    var p1 = new long[size];
    var p2 = new long[size];
    p1[1] = 0;
    p2[size - 2] = 0;

    for (int i = 2; i < size - 1; i++)
    {
        p1[i] = Math.Max(0, p1[i - 1] + a[i - 1]);
        p2[size - i - 1] = Math.Max(0, p2[size - i] + a[size - i]);
    }

    var sum = p1[1] + p2[1];
    for (int i = 1; i < size - 1; i++)
    {
        sum = Math.Max(sum, p1[i] + p2[i]);
    }

    return sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Product Of Three

static long MaxProductOfThree(int[] a)
{
    var sorted = (int[])a.Clone();
    Array.Sort(sorted);
    var c = sorted.Length;

    return Math.Max(
        (long)sorted[c - 1] * sorted[c - 2] * sorted[c - 3],
        (long)sorted[0] * sorted[1] * sorted[c - 1]
    );
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Profit

static int MaxProfit(int[] a)
{
    var price = a[0];
    var profit = 0;

    foreach (var v in a)
    {
        price = Math.Min(price, v);
        profit = Math.Max(profit, v - price);
    }

    return profit;
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C# Max Slice Sum

static long MaxSliceSum(int[] a)
{
    long tmp = long.MinValue;
    long max = long.MinValue;

    foreach (var v in a)
    {
        tmp = Math.Max(tmp + v, v);
        max = Math.Max(max, tmp);
    }

    return max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

C# Min Avg Two Slice

static int MinAvgTwoSlice(int[] a)
{
    var idx = 0;
    double min = (a[0] + a[1]) / 2.0;

    for (int i = 0; i < a.Length - 1; i++)
    {
        double cur = (a[i] + a[i + 1]) / 2.0;
        if (i + 2 < a.Length)
        {
            double three = (a[i] + a[i + 1] + a[i + 2]) / 3.0;
            cur = cur < three ? cur : three;
        }
        if (cur < min)
        {
            min = cur;
            idx = i;
        }
    }

    return idx;
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

C# Min Perimeter Rectangle

static long MinPerimeterRectangle(long n)
{
    long i = 1;
    long min = long.MaxValue;

    while (i * i < n)
    {
        if (n % i == 0)
        {
            min = Math.Min(min, 2 * (i + n / i));
        }
        i++;
    }

    return min;
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

C# Missing Integer

static int MissingInteger(int[] a)
{
    var min = 1;
    var distinct = new HashSet<int>(a).ToList();
    distinct.Sort();

    foreach (var v in distinct)
    {
        if (v > 0)
        {
            if (min != v)
            {
                break;
            }
            min++;
        }
    }

    return min;
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

C# Nesting

static int Nesting(string s)
{
    if (string.IsNullOrEmpty(s))
    {
        return 1;
    }

    var stack = new Stack<char>();
    foreach (var v in s)
    {
        if (v == ')')
        {
            if (stack.Count == 0 || stack.Pop() != '(')
            {
                return 0;
            }
        }
        else
        {
            stack.Push(v);
        }
    }

    return stack.Count == 0 ? 1 : 0;
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

C# Number Of Disc Intersections

static long NumberOfDiscIntersections(int[] a)
{
    long sum = 0;
    long active = 0;
    var c = a.Length;
    var start = new int[c];
    var end = new int[c];

    for (int k = 0; k < c; k++)
    {
        var v = a[k];
        var startKey = k < v ? 0 : k - v;
        start[startKey]++;

        var endKey = (long)k + v >= c ? c - 1 : k + v;
        end[(int)endKey]++;
    }

    for (int k = 0; k < c; k++)
    {
        sum += active * start[k] + (long)start[k] * (start[k] - 1) / 2;
        active += start[k] - end[k];
        if (sum > 10000000)
        {
            return -1;
        }
    }

    return sum;
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

C# Odd Occurrences In Array

static int? OddOccurrencesInArray(int[] a)
{
    var count = new Dictionary<int, int>();

    foreach (var value in a)
    {
        if (!count.ContainsKey(value))
        {
            count[value] = 1;
        }
        else
        {
            count.Remove(value);
        }
    }

    return count.Count > 0 ? count.Keys.First() : (int?)null;
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

C# Palindrome Rearranging

static bool PalindromeRearranging(string inputString)
{
    var counts = new Dictionary<char, int>();
    foreach (var ch in inputString)
    {
        counts[ch] = counts.GetValueOrDefault(ch) + 1;
    }

    var oddCount = counts.Values.Count(v => v % 2 != 0);

    return oddCount <= 1;
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

C# Passing Cars

static long PassingCars(int[] a)
{
    long passingCars = 0;
    long multiply = 0;

    foreach (var i in a)
    {
        if (i == 0)
        {
            multiply++;
        }
        else if (multiply > 0)
        {
            passingCars += multiply;
            if (passingCars > 1000000000)
            {
                return -1;
            }
        }
    }

    return passingCars;
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

C# Peaks

static int Peaks(int[] a)
{
    var n = a.Length;
    if (n <= 2)
    {
        return 0;
    }

    var sum = new int[n];
    var last = -1;
    var dist = 0;

    for (int i = 1; i + 1 < n; i++)
    {
        sum[i] = sum[i - 1];
        if (a[i] > a[i - 1] && a[i] > a[i + 1])
        {
            dist = Math.Max(dist, i - last);
            last = i;
            sum[i]++;
        }
    }

    sum[n - 1] = sum[n - 2];
    if (sum[n - 1] == 0)
    {
        return 0;
    }

    dist = Math.Max(dist, n - last);

    for (int i = (dist >> 1) + 1; i < dist; i++)
    {
        if (n % i == 0)
        {
            last = 0;
            int j;
            for (j = i; j <= n; j += i)
            {
                if (sum[j - 1] <= last)
                {
                    break;
                }
                last = sum[j - 1];
            }
            if (j > n)
            {
                return n / i;
            }
        }
    }

    for (last = dist; n % last != 0;)
    {
        last++;
    }

    return n / last;
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

C# Perm Check

static int PermCheck(int[] a)
{
    var sorted = (int[])a.Clone();
    Array.Sort(sorted);

    for (int k = 0; k < sorted.Length; k++)
    {
        if (k + 1 < sorted.Length && sorted[k] != k + 1)
        {
            return 0;
        }
    }

    return 1;
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

C# Perm Missing Element

static int PermMissingElement(int[] a)
{
    var sorted = (int[])a.Clone();
    Array.Sort(sorted);

    for (int k = 0; k < sorted.Length; k++)
    {
        if (sorted[k] != k + 1)
        {
            return k + 1;
        }
    }

    return sorted.Length + 1;
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

C# Plagiarism Check

static bool PlagiarismCheck(string[] code1, string[] code2)
{
    var c1 = string.Join(" ", code1);
    var c2 = string.Join(" ", code2);
    if (c1 == c2)
    {
        return false;
    }

    var d1 = Regex.Matches(c1, @"\w+");
    var d2 = Regex.Matches(c2, @"\w+");

    var rCand = new Dictionary<string, string>();
    for (int k = 0; k < d1.Count; k++)
    {
        var v = d1[k].Value;
        var w = d2[k].Value;
        if (v != w && !double.TryParse(v, out _))
        {
            rCand[v] = w;
        }
    }

    foreach (var pair in rCand)
    {
        var orig = Regex.Escape(pair.Key);
        c1 = Regex.Replace(c1, $@"(\W){orig}(\W*)", $"$1PLACEHOLDER{pair.Key}$2");
        c1 = Regex.Replace(c1, $@"(\W){orig}", $"$1PLACEHOLDER{pair.Key}");
    }

    foreach (var pair in rCand)
    {
        var orig = Regex.Escape(pair.Key);
        c1 = Regex.Replace(c1, $@"(\W)PLACEHOLDER{orig}(\W)", $"$1{pair.Value}$2");
        c1 = Regex.Replace(c1, $@"(\W)PLACEHOLDER{orig}", $"$1{pair.Value}");
    }

    return c1 == c2;
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

C# Shape Area

static long ShapeArea(long n)
{
    return n > 1 ? ShapeArea(n - 1) + 4 * (n - 1) : 1;
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

C# Stone Blocks

static int StoneBlocks(int[] h)
{
    var height = new List<int>();
    var index = 0;
    var blocks = 0;

    foreach (var i in h)
    {
        while (index > 0 && height[index - 1] > i)
        {
            index--;
        }
        if (index > 0 && height[index - 1] == i)
        {
            continue;
        }

        if (index < height.Count)
        {
            height[index] = i;
        }
        else
        {
            height.Add(i);
        }
        blocks++;
        index++;
    }

    return blocks;
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

C# Tape Equilibrium

static long TapeEquilibrium(int[] a)
{
    long firstPart = 0;
    long secondPart = a.Sum(x => (long)x);
    long min = long.MaxValue;

    for (int i = 0; i < a.Length - 1; i++)
    {
        firstPart += i;
        secondPart -= i;
        var difference = Math.Abs(firstPart - secondPart);
        min = difference < min ? difference : min;
    }

    return min;
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

C# Triangle

static int Triangle(int[] a)
{
    var sorted = (int[])a.Clone();
    Array.Sort(sorted);
    var c = sorted.Length;
    if (c < 3)
    {
        return 0;
    }

    for (int i = 0; i < c - 2; i++)
    {
        if (sorted[i] > 0 && sorted[i] > (long)sorted[i + 2] - sorted[i + 1])
        {
            return 1;
        }
    }

    return 0;
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.