public static class Kata
{
  public static int SameCase(char a, char b) =>
    char.IsLetter(a) && char.IsLetter(b) ? 
      (char.IsUpper(a) == char.IsUpper(b) ? 1 : 0)
    : -1;
}

public static class Kata 
{
  public static int SameCase(char a, char b) =>
    !char.IsLetter(a) || !char.IsLetter(b)
      ? -1 
    : char.IsUpper(a) == char.IsUpper(b)
      ? 1 : 0;
}

public static class Kata 
{
  public static int SameCase(char a, char b) =>
    char.IsLetter(a) && char.IsLetter(b)
      ? char.IsUpper(a) == char.IsUpper(b)
      ? 1 : 0
      : -1;
}

public static class Kata 
{
  public static int SameCase(char a, char b) =>
    (!char.IsLetter(a) || !char.IsLetter(b))
      ? -1
    
    : (char.IsLower(a) == char.IsLower(b))
      ? 1
      : 0;
}

using System;
using System.Diagnostics;
using System.Numerics;
using System.Linq;

public class Math
{
    public static T Max<T>(params T[] nums) where T : struct, IComparable<T>
    {
        if (nums.Length == 0)
            throw new InvalidOperationException("No nums were provided to find the maximum value.");
      
        T max;
        Span<T> items = nums;
        if (items.Length / Vector<T>.Count > 1)
        {
            // We have at least two vectors
            var maxVector = new Vector<T>(items); // first vector
            items = items[Vector<T>.Count..]; // skip first vector
            while (items.Length >= Vector<T>.Count)
            {
                var nextVector = new Vector<T>(items);  // next vector
                items = items[Vector<T>.Count..]; // skip next vector
                maxVector = Vector.Max(maxVector, nextVector); // evaluate maxVector
            }
          
            // Evaluate Max for maxVector
            max = maxVector[0];
            for (var i = 1; i < Vector<T>.Count; ++i)
                if (maxVector[i] is var item && item.CompareTo(max) > 0)
                    max = item;
        }
        else
        {
            max = items[0]; // max is first item
            items = items[1..]; // skip first item
        }

        // Evaluate Max for items in span
        for (var i = 0; i < items.Length; ++i)
            if (items[i] is var item && item.CompareTo(max) > 0)
                max = item;
      
        Debug.Assert(max.CompareTo(nums.Max()) == 0);
        return max;
    }
}  

using System;
public static class Math
{
    public static T Max<T>(params T[] items) where T : IComparable<T>
    {
        if (items.Length == 0)
            throw new InvalidOperationException("No items were provided to find the maximum value.");

        T max = items[0];
        for (int i = 1; i < items.Length; i++)
            if (items[i].CompareTo(max) > 0)
                max = items[i];

        return max;
    }
}

"""
Returns True if year is a Leap Year else False.
if (year is not divisible by 4) then (it is a common year)
else if (year is not divisible by 100) then (it is a leap year)
else if (year is divisible by 400) then (it is a leap year)
else (it is a common year)
"""
def is_leap_year(year: str) -> bool:
    return year % 4 == 0 and year % 100 != 0 or year % 400 == 0

using System;

public static class LeapYears
{
  // if (year is not divisible by 4) then (it is a common year)
  // else if (year is not divisible by 100) then (it is a leap year)
  // else if (year is divisible by 400) then (it is a leap year)
  // else (it is a common year) 
  public static bool IsLeapYear(int year) => year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}

using System;

public static class Math
{
    public static T Max<T>(params T[] items) where T : IComparable<T>
    {
        if (items.Length <= 0)
            throw new InvalidOperationException();

        var max = items[0];
        for (var i = 1; i < items.Length; ++i)
            if (max.CompareTo(items[i]) < 0)
                max = items[i];

        return max;
    }
}

public static class Kata 
{
  public static int SameCase(char a, char b) => 
    (!char.IsLetter(a) || !char.IsLetter(b)) ? -1 :
    (char.IsLower(a) == char.IsLower(b)) ? 1 : 0;
}