using System;
using System.Linq;

public class Basic
{  
    public static string GetLoweredFirstLetter(string text) 
    {
        return text.Select(x => x.ToString().ToLower())
          .Where(x => char.IsLetter(x[0])).First();
    }
  
    public static string CalculateStudentPoints(string[] answers) 
    {
      int tickCount = (answers != null) ? answers.Where(x => x.Equals("O")).Count() : 0; 
      int errorCount = (answers != null) ? answers.Where(x => x.Equals("X")).Count() : 0;
      int score = tickCount - errorCount;
      return (answers != null && answers.Length > 0) ? answers
        .Select(x => $"{(errorCount > 5 ? "eliminated" : score > 5 ? score + 1 : score)}"
            + ((errorCount <= 5) ?
            $"{(Math.Abs(score) > 1 || Math.Abs(score) == 0 ? " points" : " point")}" 
            : ""))
        .First() : "-1 point";
    }
}

using System;
using System.Linq;
using System.Text.RegularExpressions;

public class Basic
{
    public static string[] ToLowerCaseArray(string text) 
    {        
        return (!string.IsNullOrWhiteSpace(text)) 
          ? text.Split(' ').Select(x => x.ToLower())
          .Where(x => !string.IsNullOrWhiteSpace(x))
          .ToArray()
          : new string[] { "" };
    }
  
    public static string ToUpperCaseString(string[] words) 
    {        
      string upperCaseWord = "";
      for (int i = 0; i < words.Length; i++) 
      {
         upperCaseWord = (i != words.Length - 1) 
           ? upperCaseWord + words[i].ToUpper() + " " 
           : upperCaseWord + words[i].ToUpper();  
      }
      return upperCaseWord;
    }
  
    public static string RemoveUnnecessarySpaces(string text) 
    {
        return Regex.Replace(text, "([\\s]^|[\\s]$|[\\s]+)", " ").Trim();
    }
  
    public static string GetTheFirstLetter(string text) 
    {
        return $"{text.Where(x => char.IsLetter(x)).First()}";
    }
  
    public static string UpperCaseFirstLetter(string text) 
    {
        return RemoveUnnecessarySpaces(
          new string(
            text
            .Select(x => x.ToString().ToUpper().ToCharArray()[0])
            .Take(1)
            .Concat
            (
                text
                .Select(x => x.ToString().ToLower().ToCharArray()[0])
                .Skip(1)
            )
            .ToArray()
          )
        );       
    }
  
    public static string ToCamelCase(string text) 
    {
        return string.Join("", RemoveUnnecessarySpaces(text)
                .Split(' ').Select(x => UpperCaseFirstLetter(x)));
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Basic
{  
    public static long ConvertTextToLong(string numberAsText)
    {
        return long.Parse(numberAsText);
    }
  
    public static decimal ConvertTextToDecimal(string numberAsText)
    {
      return decimal.Parse(numberAsText);
    }
  
    public static long ConvertIntToLong(int number)
    {
      return Convert.ToInt64(number);
    }  
    
    public static string[] ToUpperCaseArray(string text) 
    {
      string[] wordList = 
        text.Split(' ').Select(x => x.ToUpper())
        .Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
      return wordList.Any() ? wordList : new string[] { "" };
    }
  
    public static string ToLowerCaseString(string[] words) 
    {        
      string lowerCaseWord = "";
      for (int i = 0; i < words.Length; i++) 
      {
         lowerCaseWord = (i != words.Length - 1) 
           ? lowerCaseWord + words[i].ToLower() + " " 
           : lowerCaseWord + words[i].ToLower();  
      }
      return lowerCaseWord;
    }
  
    public static int IsUpperCase(string text)
    {
      int count = (text != null) ? text.Where(x => char.IsUpper(x)).Count() : -1;
      int strLen = (text != null) ? text.Where(x => !char.IsWhiteSpace(x)).Count() : -1;
      return count >= 0 && strLen > 0 ? count == strLen ? 1 : 0 : -1;
    }
  
    public static string RemoveUnnecessarySpaces(string text) 
    {
      return Regex.Replace(text, "([\\s]^|[\\s]$|[\\s]+)", " ").Trim();
    }
}

public class Math
{
  public int Max(int a, int b)
  {
    return a.CompareTo(b) > 0 ? a : b;
  }
}  

using System.Collections.Generic;

public class ColorAdder
{
    public static string AddColor(string color, string text)
    {
      string baseCode = "\033[";
      string resetCode = baseCode + "0m";
      Dictionary<string, int> colourCodes = new() 
      {
        { "Red", 31 },
        { "Green", 32 },
        { "Yellow", 33 },
        { "Blue", 34 },
        { "Magenta", 35 },
        { "Cyan", 36 },
        { "White", 37 }
      };
      return colourCodes.TryGetValue(color, out int code) ? $"{baseCode}{code}m{text}{resetCode}" : "";
    }
}

using System;
using System.Linq;

public class Kumite 
{
  public static bool IsThree(int number) 
  {
    return number.ToString().Contains('3');
  }
}

// Given 2 Arrays, Return True if arrays contain common item, else false.
// e.g a = ['a','b','g','c'] and b = ['z','e','c'] returns true

using System.Linq;

public class Kata
{
  public static bool ContainsCommonItemBetter(char[] a, char[] b)
  { 
    return a.Intersect(b).Any();
  } 
}

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