Building a training set of tags for csharp about csharp HOT 21 CLOSED


namespace HelloWorld
{
    public static class HelloWorld
    {
        public static string Hello()
        {
            return "Hello, World!";
        }
    }
}

using System;

namespace Exercism.Csharp
{
    /**
        on every year that is evenly divisible by 4
        except every year that is evenly divisible by 100
        unless the year is also evenly divisible by 400
    */
    public static class Leap
    {
        public static bool IsLeapYear(int year) => 
            year % 400 == 0 || 
            (year % 100 != 0 && year % 4 == 0);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public static class SumOfMultiples
{
    public static int Sum(IEnumerable<int> multiples, int max)
    {
        int sum = 0;

        for(int i = 1; i < max; i++)
        {
            if (multiples.Where(n => i % n == 0).Count() >= 1)
                sum += i;
        }

        return sum;
    }
}

using System;

public static class CollatzConjecture
{
    public static int Steps(int number)
    {
        if (number < 1) throw new ArgumentException("Number less than 1 prohibited.");

        int steps = 0;
        while (number != 1) {
            steps++;
            if (number % 2 == 0) {
                number /= 2;
            }
            else
            {
                number = 3 * number + 1;
            }
        }
        return steps;
    }
}

public class BinarySearch
{

	private readonly int[] source;

	public BinarySearch(int[] input)
	{
		source = input;
	}

	public int Find(int value)
	{

		if (source.Length == 0) return -1;

		var result = -1;
		var startIndex = 0;
		var endIndex = source.Length - 1;
		var halfIndex = (endIndex - startIndex) / 2 + startIndex;
		var currDirection = "?";

		// easily found
		if (source[halfIndex] == value) result = halfIndex;

		while (source[halfIndex] != value)
		{

			var lastHalfIndex = halfIndex;
			var lastDirection = currDirection;

			startIndex = source[halfIndex] < value ? halfIndex + 1 : 0;
			endIndex = source[halfIndex] < value ? source.Length - 1 : halfIndex - 1;
			halfIndex = (endIndex - startIndex) / 2 + startIndex;
			currDirection = lastHalfIndex > halfIndex ? "-" : "+";

			// changed direction, so not in array
			if (lastDirection != "?" && lastDirection != currDirection) break;

			// found
			if (source[halfIndex] == value) result = halfIndex;

			// made it to beginning or the end
			if (halfIndex == 0 || halfIndex == source.Length - 1) break;

		}

		return result;

	}

}

using System;
using System.Collections.Generic;

public static class Etl
{
    public static Dictionary<string, int> Transform(Dictionary<int, string[]> old)
    {
        var newDict = new Dictionary<string, int>();
        int oldKey;

        foreach (KeyValuePair<int, string[]> item in old)
        {
          oldKey = item.Key;

          foreach (var letter in item.Value)
          {
            newDict.Add(letter.ToLower(), oldKey);
          }

        }

        return newDict;

    }
}

using System;
using System.Linq;

public class Anagram
{
    public string baseWord;

    public Anagram(string baseWord)
    {
        this.baseWord = baseWord;    
    }

    public string[] Anagrams(string[] potentialMatches)
    {
        // To detect if a string is an anagram of another, we sort the string characters and compare the sorted strings.
        // This must be case insensitive, so let's make everything lowercase, even the sort rule.

        return potentialMatches.Where(x => (x.ToLower() != this.baseWord.ToLower() )        // "BANANA" is not an anagram of "Banana"
        && (String.Concat(this.baseWord.OrderBy(c => c.ToString().ToLower())).ToLower()    
        == String.Concat(x.OrderBy(c => c.ToString().ToLower())).ToLower() ) )             
        .ToArray();                                                                        
    }
}

using System.Collections.Generic;
using System.Linq;

namespace PascalsTriangle
{
    public static class PascalsTriangle
    {
        public static IEnumerable<IEnumerable<int>> Calculate(int rows)
        {
            var response = new List<List<int>>();
            for (int i = 0; i < rows; i++)
            {
                response.Add(i > 0 ? NextRow(response.Last()) : new List<int> {1});
            }

            return response;
        }

        private static List<int> NextRow(IReadOnlyList<int> previous)
        {
            var newRow = new List<int>();
            if (previous.Count > 0)
            {
                newRow.Add(previous.First());
            }

            for (int i = 1; i < previous.Count; i++)
            {
                newRow.Add(previous[i - 1] + previous[i]);
            }

            newRow.Add(1);
            return newRow;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Exercism_Test.csharp.pascals_triangle
{
    class PascalsTriangle
    {
        public static int[][] Calculate(int tierNum)
        {
            int[][] tier = new int[tierNum][];
            tier[tierNum-1] = new int[tierNum];
            tier[tierNum-1][0] = 1;
            if (tierNum == 1)
                return tier;

            tier[tierNum-1][tierNum-1] = 1;
            int[][] pTier = Calculate(tierNum - 1);
            for (int r = 0; r < tierNum - 1; r++)
                tier[r] = pTier[r];
            for (int i = 1; i < tierNum - 1; i++)
                tier[tierNum-1][i] = tier[tierNum-2][i] + tier[tierNum-2][i - 1];
            return tier;
        }
    }
}

using System;

public static class IsbnVerifier
{
    public static class IsbnVerifier
    {
        public static bool IsValid(string number)
        {
            var list = number.ToList();
            list.RemoveAll(c => c == '-');

            if (list.Count != 10)
                return false;

            for (int i = 0; i < list.Count() - 1; i++)
            {
                if (!char.IsDigit(list[i]))
                    return false;
            }

            if (!char.IsDigit(list[list.Count - 1]) && (list[list.Count - 1] != 'X'))
            {
                return false;
            }
            var listonfStrings = list.Select(c => c.ToString()).ToList();
            listonfStrings[9] = listonfStrings[9] == "X" ? "10" : listonfStrings[9];
            var listonfInts = listonfStrings.Select(c => Convert.ToInt32(c)).ToList();

            return (listonfInts[0] * 10 + listonfInts[1] * 9 + listonfInts[2] * 8 + listonfInts[3] * 7 + listonfInts[4] * 6 + listonfInts[5] * 5 + listonfInts[6] * 4 + listonfInts[7] * 3 + listonfInts[8] * 2 + listonfInts[9] * 1) % 11 == 0;

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public class Atbash
{
    public static string Encode (string given)
    {
        var converted = given
          .ToLower()
          .Where(Char.IsLetterOrDigit)
          .Select(EncodeChar);
        return String.Join(" ", Chunk(5, converted));
    }

    private static char EncodeChar (char ch)
    {
        return Char.IsDigit(ch) ? ch : (char)('a' + 'z' - ch);
    }

    private static IEnumerable<String> Chunk (int size, IEnumerable<char> source)
    {
        while (source.Any())
        {
            yield return String.Concat(source.Take(size));
            source = source.Skip(size);
        }
    }
}

using System;
using System.Collections.Generic;

public static class BracketPush
{
    public static bool IsPaired(string input)
    {
        Stack<char> stackBracket = new Stack<char>();
        char[] arrayInput = input.ToCharArray();
        Dictionary<char, char> dicBracket = new Dictionary<char, char> { { ')', '(' }, { ']', '['}, { '}', '{' } };
        List<char> listBracket = new List<char> { '(', ')', '[', ']', '{', '}'};
        foreach (var charTemp in arrayInput)
        {
            if(listBracket.Contains(charTemp))
            {               
                if (!dicBracket.ContainsKey(charTemp))
                {
                    stackBracket.Push(charTemp);
                }
                else
                {
                    if (stackBracket.Count != 0 && dicBracket[charTemp] == stackBracket.Peek())
                    {
                        stackBracket.Pop();
                    }
                    else return false;
                }
            }
        }
        return stackBracket.Count == 0 ? true : false;
    }
}

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

public static class CryptoSquare
{
    public static string NormalizedPlaintext(string plaintext)
    {
        return new Regex(@"[^a-z0-9]").Replace(plaintext.ToLower(), "");
    }

    public static IEnumerable<string> PlaintextSegments(string plaintext)
    {
        int length = plaintext.Length;
        int columns = (int)Math.Ceiling(Math.Sqrt(length));
        int rows = (int)Math.Ceiling((double)length / columns);
        if (rows <= 1) yield return plaintext;
        else
        {
            var filter = Enumerable.Range(0, rows).SelectMany(f => Enumerable.Range(0, columns));

            var h = plaintext
                .Zip(filter, (character, filter) => (character, filter))
                .GroupBy(pair => pair.filter)
                .Select(group => 
                    string.Concat(group.Select(pair => pair.character)));
            
            var o = string.Join(" ", h);
            
            yield return o;
        }
    }

    public static string Ciphertext(string plaintext)
    {
        return string.Join(" ", PlaintextSegments(NormalizedPlaintext(plaintext)).ToList());
    }
}

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

namespace pig_latin
{
    public static class PigLatin
    {
        internal static string Translate(string sentence)
        {
            const string ay = "ay";
            var words = (sentence ?? "").Split(' ');
            var plWords = new List<string>();
            foreach (var word in words)
            {
                var temp = word.ToLowerInvariant();
                if (Regex.Match(temp, "^([aeiou]|yt|xr)").Success)
                    plWords.Add(temp + ay);
                else if (Regex.Match(temp, "^(thr|sch)").Success)
                    plWords.Add(temp.Remove(0, 3) + temp.Substring(0, 3) + ay);
                else if (Regex.Match(temp, "^(ch|qu|th)").Success)
                    plWords.Add(temp.Remove(0, 2) + temp.Substring(0, 2) + ay);
                else if (Regex.Match(temp, "^\\wqu").Success)
                    plWords.Add(temp.Remove(0, 3) + temp.Substring(0, 3) + ay);
                else
                    plWords.Add(temp.Remove(0, 1) + temp.Substring(0, 1) + ay);
            }
            return string.Join(" ", plWords);
        }
    }
}

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

public class PigLatin
{
  public static string Translate(string input)
  {
    string output = "";
    Regex vowels = new Regex(@"^[aeiou]");

    Regex special = new Regex(@"^xr|^yt");
    Regex trios = new Regex(@"^sch|^squ|^thr");
    Regex duos = new Regex(@"^ch|^qu|^th");

    string[] inputArray = input.Split(' ');

    foreach (string word in inputArray)
    {
      if (vowels.Match(word).Success || special.Match(word).Success)
        output += word + "ay ";
      else if (trios.Match(word).Success)
        output += word.Substring(3) + word.Substring(0, 3) + "ay ";
      else if (duos.Match(word).Success)
        output += word.Substring(2) + word.Substring(0, 2) + "ay ";
      else
        output += word.Substring(1) + word.Substring(0, 1) + "ay ";
    }
    return output.Trim();
  }
}

using System;

public struct ComplexNumber
{
    public double RealPart {get;set;}
    public double ImaginaryPart { get; set; }

    public ComplexNumber(double real, double imaginary)
    {
        RealPart = real;
        ImaginaryPart = imaginary;
    }

    public double Real()
    {
        return RealPart;
    }

    public double Imaginary()
    {
        return ImaginaryPart;
    }

    public ComplexNumber Mul(ComplexNumber other)
    {
        return new ComplexNumber(RealPart * other.RealPart - ImaginaryPart * other.ImaginaryPart,
            ImaginaryPart * other.RealPart + RealPart * other.ImaginaryPart);
    }

    public ComplexNumber Add(ComplexNumber other)
    {
        return new ComplexNumber(RealPart + other.RealPart, ImaginaryPart + other.ImaginaryPart);
    }

    public ComplexNumber Sub(ComplexNumber other)
    {
        return new ComplexNumber(RealPart - other.RealPart, ImaginaryPart - other.ImaginaryPart);
    }

    public ComplexNumber Div(ComplexNumber other)
    {
        return new ComplexNumber(
            (RealPart * other.RealPart + ImaginaryPart * other.ImaginaryPart) /
            (other.RealPart * other.RealPart + other.ImaginaryPart * other.ImaginaryPart),
            (ImaginaryPart * other.RealPart - RealPart * other.ImaginaryPart) /
            (other.RealPart * other.RealPart + other.ImaginaryPart * other.ImaginaryPart));
    }

    public double Abs()
    {
        return Math.Sqrt(RealPart * RealPart + ImaginaryPart * ImaginaryPart);
    }

    public ComplexNumber Conjugate()
    {
        return new ComplexNumber(RealPart, -ImaginaryPart);
    }
    
    public ComplexNumber Exp()
    {
        return new ComplexNumber(Math.Exp(RealPart) * Math.Cos(ImaginaryPart), Math.Sin(ImaginaryPart));
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public class WordProblem
{
    static Dictionary<string, Func<int, int, int>> Ops = new Dictionary<string, Func<int, int, int>> {
        { "plus", (a, b) => a + b },
        { "minus", (a, b) => a - b },
        { "divided", (a, b) => a / b },
        { "multiplied", (a, b) => a * b }
    };

    public static int Solve(string phrase)
    {
        if (phrase[phrase.Length - 1] == '?') phrase = phrase.Substring(0, phrase.Length - 1);
        var words = phrase.Substring(8, phrase.Length - 8).Split(' ').Where(w => w != "by");
        int memo;
        try
        {
            memo = Int32.Parse(words.First());
        }
        catch (FormatException e)
        {
            throw new ArgumentException();
        }
        words = words.Skip(1);
        while (words.Any())
        {
            Func<int, int, int> op;
            try
            {
                op = Ops[words.First()];
            }
            catch (KeyNotFoundException e)
            {
                throw new ArgumentException();
            }
            var operand = Int32.Parse(words.Skip(1).First());
            memo = op(memo, operand);
            words = words.Skip(2);
        }
        return memo;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public static class Forth
{
    private static string twoOperandsOperators = "+-*/swapover";
    private static string operators = twoOperandsOperators + "dupdrop";

    private static Dictionary<string, Func<int, int, int>> arthemicOperations = new Dictionary<string, Func<int, int, int>>
    {
        ["+"] = (d,e) => (d + e),
        ["-"] = (d,e) => (e - d),
        ["*"] = (d,e) => (d * e),
        ["/"] = (d,e) => d != 0? (e / d) : throw new InvalidOperationException()
    };

    private static IEnumerable<string> Evaluate(Stack<string> stack)
    {
        while (stack.Count != 0)
        {
            var element = ((string)stack.Pop()).ToLower();
            if (int.TryParse(element, out int number))
            {
                yield return number.ToString();
                continue;
            }
            else if(!operators.Contains(element))
            {
                throw new InvalidOperationException();
            }

            // drop is handled here as a no operator (no-op)
            var a = int.Parse(Evaluate(stack).First());

            if(twoOperandsOperators.Contains(element))
            {
                var b = int.Parse(Evaluate(stack).First());
                if(arthemicOperations.ContainsKey(element))
                {
                    yield return arthemicOperations[element](a, b).ToString();
                }
                else if (element == "swap")
                {
                    stack.Push(a.ToString());
                    stack.Push(b.ToString());
                }
                else if (element == "over")
                {
                    stack.Push(b.ToString());
                    stack.Push(a.ToString());
                    stack.Push(b.ToString());
                }
            }
            else if (element == "dup")
            {
                stack.Push(a.ToString());
                stack.Push(a.ToString());
            }
        }
    }

    private static string Transform(string instruction, string transformation)
    {
        var transformationPart = transformation.Split(' ')
        .Skip(1)
        .SkipLast(1)
        .ToArray();

        var word = transformationPart[0];
        var replacement = string.Join(' ', transformationPart.Skip(1));
        return instruction.Replace(word, replacement);
    }
    public static string Evaluate(string[] instructions)
    {
        var loweredInstructions = instructions.Select(instruction => instruction.ToLower())
                                              .ToArray();
        var lastLine = loweredInstructions.Last();
        var replacementInstructions = loweredInstructions.SkipLast(1)
                                                       .Select((i,j) => new {i,j})
                                                       .OrderByDescending( _=> _.j)
                                                       .Select(_ => _.i)
                                                       .ToArray();
        foreach (var replacement in replacementInstructions)
        {
            lastLine = Transform(lastLine, replacement);
        }

        var stack = new Stack<string>();
        lastLine.Split(' ')
                .ToList()
                .ForEach(stack.Push);
        return string.Join(' ', Evaluate(stack).Reverse());
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public class DndCharacter
{
    public int Strength { get; }
    public int Dexterity { get; }
    public int Constitution { get; }
    public int Intelligence { get; }
    public int Wisdom { get; }
    public int Charisma { get; }
    public int Hitpoints { get; }

    public DndCharacter()
    {
        Strength = Ability();
        Dexterity = Ability();
        Constitution = Ability();
        Intelligence = Ability();
        Wisdom = Ability();
        Charisma = Ability();
        Hitpoints = 10 + Modifier(Constitution);
    }

    public static int Modifier(int score) => (int)Math.Floor((score - 10) / 2.0);

    public static int Ability() => 3 + new Random().Next() % 16;

    public static DndCharacter Generate() => new DndCharacter();
}

using System;

public static class ResistorColor
{
    public static int ColorCode(string color)
    {
        // throw new NotImplementedException("You need to implement this function.");
        
        switch (color.ToLower())
        {
            case "black" :
                return 0;
                break;

            case "brown" :
                return 1;
                break;

            case "red" :
                return 2;
                break;

            case "orange" :
                return 3;
                break;

            case "yellow" :
                return 4;
                break;

            case "green" :
                return 5;
                break;

            case "blue" :
                return 6;
                break;

            case "violet" :
                return 7;
                break;

            case "grey" :
                return 8;
                break;

            case "white" :
                return 9;
                break;

            // No Default Expected
            default:
                return 10;
                break;

            
        }

    }

    public static string[] Colors()
    {
        //throw new NotImplementedException("You need to implement this function.");
        string[] colors = new string[10];
        colors[0] = "Black";
        colors[1] = "Brown";
        colors[2] = "Red";
        colors[3] = "Orange";
        colors[4] = "Yellow";
        colors[5] = "Green";
        colors[6] = "Blue";
        colors[7] = "Violet";
        colors[8] = "Grey";
        colors[9] = "White";

 
        return colors;
    }
}