isCryptSolution

My solution:

bool isCryptSolution(string[] crypt, char[][] solution) 
{
    var words = new List<decimal>();
    foreach (var word in crypt)
    {
        decimal wordsum = 0;
        for (var ci = 0; ci < word.Length; ci++)
            foreach (char[] t in solution)
            {
                if (word[ci] != t[0]) continue;
                if (word[0] == t[0] && t[1] == '0' && word.Length != 1) return false;
                wordsum += Convert.ToInt32(t[1].ToString()) *
                           Convert.ToDecimal(Math.Pow(10, word.Length - 1 - ci));
                break;
            }

        words.Add(wordsum);
    }

    return words[2] == words[0] + words[1];
}

Previous

sudoku2

My solution:

bool sudoku2(char[][] grid) 
{
    var columnList = new List<Dictionary<char, int>>();
    var rowList = new List<Dictionary<char, int>>();
    var nineList = new List<Dictionary<char, int>>();
    foreach (var t in grid)
    {
        var dict = new Dictionary<char, int>();
        for (var j = 0; j < grid[0].Length; j++)
            if (dict.ContainsKey(t[j]))
                dict[t[j]]++;
            else
                dict[t[j]] = 1;

        rowList.Add(dict);
    }

    if (rowList.Any(d => d.Count(pair => pair.Key != '.' && pair.Value > 1) > 0))
        return false;

    for (var i = 0; i < grid.Length; i++)
    {
        var dict = new Dictionary<char, int>();
        for (var j = 0; j < grid[0].Length; j++)
            if (dict.ContainsKey(grid[j][i]))
                dict[grid[j][i]]++;
            else
                dict[grid[j][i]] = 1;

        columnList.Add(dict);
    }

    if (columnList.Any(d => d.Count(pair => pair.Key != '.' && pair.Value > 1) > 0))
        return false;

    for (var i = 0; i < grid.Length / 3; i++)
    {
        for (var j = 0; j < grid[0].Length / 3; j++)
        {
            var dict = new Dictionary<char, int>();
            if (dict.ContainsKey(grid[i * 3][j * 3]))
                dict[grid[i * 3][j * 3]]++;
            else
                dict[grid[i * 3][j * 3]] = 1;

            if (dict.ContainsKey(grid[i * 3][j * 3 + 1]))
                dict[grid[i * 3][j * 3 + 1]]++;
            else
                dict[grid[i * 3][j * 3 + 1]] = 1;

            if (dict.ContainsKey(grid[i * 3][j * 3 + 2]))
                dict[grid[i * 3][j * 3 + 2]]++;
            else
                dict[grid[i * 3][j * 3 + 2]] = 1;

            if (dict.ContainsKey(grid[i * 3 + 1][j * 3]))
                dict[grid[i * 3 + 1][j * 3]]++;
            else
                dict[grid[i * 3 + 1][j * 3]] = 1;

            if (dict.ContainsKey(grid[i * 3 + 1][j * 3 + 1]))
                dict[grid[i * 3 + 1][j * 3 + 1]]++;
            else
                dict[grid[i * 3 + 1][j * 3 + 1]] = 1;

            if (dict.ContainsKey(grid[i * 3 + 1][j * 3 + 2]))
                dict[grid[i * 3 + 1][j * 3 + 2]]++;
            else
                dict[grid[i * 3 + 1][j * 3 + 2]] = 1;

            if (dict.ContainsKey(grid[i * 3 + 2][j * 3]))
                dict[grid[i * 3 + 2][j * 3]]++;
            else
                dict[grid[i * 3 + 2][j * 3]] = 1;

            if (dict.ContainsKey(grid[i * 3 + 2][j * 3 + 1]))
                dict[grid[i * 3 + 2][j * 3 + 1]]++;
            else
                dict[grid[i * 3 + 2][j * 3 + 1]] = 1;

            if (dict.ContainsKey(grid[i * 3 + 2][j * 3 + 2]))
                dict[grid[i * 3 + 2][j * 3 + 2]]++;
            else
                dict[grid[i * 3 + 2][j * 3 + 2]] = 1;

            nineList.Add(dict);
        }
    }

    return !nineList.Any(d => d.Count(pair => pair.Key != '.' && pair.Value > 1) > 0);
}

Previous Next

firstNotRepeatingCharacter

My solution:

char firstNotRepeatingCharacter(string s) 
{
    var d = new Dictionary<char, int>();
    foreach (var c in s)
        if (!d.ContainsKey(c))
            d[c] = 1;
        else
            d[c]++;

    return d.Any(pair => pair.Value == 1) ? d.Where(pair => pair.Value == 1).Select(pair => pair.Key).First() : '_';
}

Previous Next

firstDuplicate

My solution:

int firstDuplicate(int[] a) 
{
    var list = new SortedSet<int>();
    foreach (int d in a)
    {
        if (list.Contains(d))
            return d;
        
        list.Add(d);
    }
    
    return -1;
}

Next

rotateImage

My solution:

int[][] rotateImage(int[][] a) 
{
    var list = new List<List<int>>();
    foreach (var t in a)
    {
        var column = new List<int>();
        for (var j = 0; j < a[0].Length; j++)
            column.Add(t[j]);

        list.Add(column);
    }

    var solution = new int[a.Length][];
    for (var i = 0; i < a.Length; i++)
        solution[i] = new int[a.Length];

    for (var i = 0; i < a.Length; i++)
        for (var j = 0; j < a[0].Length; j++)
            solution[i][j] = list[a.Length - 1 - j][i];

    return solution;
}

Previous Next

Make Array Consecutive 2

My solution:

int makeArrayConsecutive2(int[] statues) 
{
    return statues.Max() - statues.Min() + 1 - statues.Length;
}

Previous

Replace Middle

My solution:

int[] replaceMiddle(int[] arr) 
{
    return arr.Length % 2 == 1
                ? arr
                : arr.Select((i, i1) => i1 != arr.Length / 2 - 1 ? i : arr[arr.Length / 2 - 1] + arr[arr.Length / 2])
                    .Where((i, i1) => i1 != arr.Length / 2)
                    .ToArray();
}

Previous Next

Is Smooth?

My solution:

bool isSmooth(int[] arr) 
{
    return arr.Length % 2 == 0
                ? arr.First().Equals(arr.Last()) && arr.First().Equals(arr[arr.Length / 2 - 1] + arr[arr.Length / 2])
                : arr.First().Equals(arr.Last()) && arr.First().Equals(arr[arr.Length / 2]);
}

Previous Next

Remove Array Part

My solution:

int[] removeArrayPart(int[] inputArray, int l, int r) 
{
    return inputArray.Select(i => i).Where((i, i1) => i1 < l || i1 > r).ToArray();
}

Previous Next

Concatenate Arrays

My solution:

int[] concatenateArrays(int[] a, int[] b) 
{
    return a.Concat(b).ToArray();
}

Previous Next

First Reverse Try

My solution:

int[] firstReverseTry(int[] arr) 
{
    return arr.Select((i, i1) => i1 == 0 || i1 == arr.Length - 1 ? i1 == 0 ? arr.Last() : arr.First() : i).ToArray();
}

Previous Next

Array Replace

My solution:

int[] arrayReplace(int[] inputArray, int elemToReplace, int substitutionElem) 
{
    return inputArray.Select(i => i == elemToReplace ? substitutionElem : i).ToArray();
}

Previous Next

Create Array

My solution:

int[] createArray(int size) 
{
    return Enumerable.Repeat(1, size).ToArray();
}

Previous Next

Candles

My solution:

int candles(int candlesNumber, int makeNew) 
{
    var sum = candlesNumber;
    while (candlesNumber >= makeNew)
    {
        sum += candlesNumber / makeNew;
        candlesNumber = candlesNumber / makeNew + (candlesNumber - candlesNumber / makeNew * makeNew);
    }

    return sum;
}

Previous Next

Rounders

My solution:

int rounders(int value) 
{
    if (value < 10)
        return value;

    var ic = value.ToString().Reverse().ToList();
    var s = "0";
    for (var i = 1; i < ic.Count; i++)
    {
        if (ic[i - 1] > '4')
        {
            if (ic[i] == '9')
                ic.Add('1');

            ic[i] = ic[i] != '9' ? (char) (ic[i] + 1) : '0';
        }

        if (i != ic.Count - 1)
            s += "0";
        else if (ic[i] != '9')
            s += ic[i];
        else
            s += "01";
    }

    return int.Parse(new string(s.Reverse().ToArray()));
}

Previous Next

Increase Number Roundness

My solution:

bool increaseNumberRoundness(int n) 
{
    return n.ToString().TrimEnd('0').Contains('0');
}

Previous Next

Apple Boxes

My solution:

int appleBoxes(int k) 
{
    return Enumerable.Range(1, k).Select(i => Convert.ToInt32(Math.Pow(-1, i) * Math.Pow(i, 2))).Sum();
}

Previous Next

Addition Without Carrying

My solution:

int additionWithoutCarrying(int param1, int param2) 
{
    return (param1 / 10000 + param2 / 10000) % 10 * 10000 + (param1 / 1000 + param2 / 1000) % 10 * 1000 + (param1 / 100 + param2 / 100) % 10 * 100 + (param1 / 10 + param2 / 10) % 10 * 10 + (param1 + param2) % 10;
}

Previous Next

Lineup

My solution:

int lineUp(string commands) 
{
    var b = true;
    var count = 0;
    foreach (var c in commands)
        if ((c == 'L' || c == 'R') && b)
            b = false;
        else if ((c == 'L' || c == 'R') && !b)
        {
            b = true;
            count++;
        }
        else if (c == 'A')
            if (b)
                count++;

    return count;
}

Previous Next

Magical Well

My solution:

int magicalWell(int a, int b, int n) 
{
    var sum = 0;
    while (n != 0)
    {
        sum += a * b;
        a++;
        b++;
        n--;
    }

    return sum;
}

Previous Next