קאווע שטיבל

קוד: וועל אויס אלע

        public static int solution(int X, int[] A)
        {
            Dictionary<int, int> dict = new Dictionary<int, int>();//A dictionary only holds unique keys
            for (int i = 0; i < A.Length; i++)
            {
                dict.TryAdd(A[i], i);//puts the content as the key and the index as the value. If the key is already there, the item (key & value) is discarded and not added.
                if (dict.Count() == X)//max of each element is X as that covers all positions across the stream.
                    break;
            }
            if (dict.Count() < X)
                return -1;
            else
                return dict.Values.Max();

        }

קוד: וועל אויס אלע

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {


        System.out.println();
        mineFinder(new char[][]{
                {'*', '.', '.', '.'},
                {'.', '.', '.', '.'},
                {'.', '*', '.', '.'},
                {'.', '.', '.', '.'}
        });
        System.out.println();
        mineFinder(new char[][]{//example of two asterisks next to each other
                {'*', '.', '.', '.'},
                {'.', '*', '.', '.'},
                {'.', '.', '.', '.'},
                {'.', '.', '.', '.'}
        });
    }

    public static int[][] mineFinder(char[][] arr) {
        int[][] mapped = new int[arr.length][arr[0].length];

        for (char i = 0; i < arr.length; i++) {//loop to replace 0 for dots and a number below zero representing
            // the number of possible adjacent asterisk you can have next to each other; as we don't want to override
            //an asterisk which sits next to another.
            for (char j = 0; j < arr[0].length; j++) {
                if (arr[i][j] == '.')
                    mapped[i][j] = 0;
                else

                    mapped[i][j] = -8;

            }
        }

        for (int i = 0; i < mapped.length; i++) {//outer nested loop to traverse 2D array
            for (int j = 0; j < mapped[0].length; j++) {

                if (mapped[i][j] < 0) {

                    for (int r = i - 1; r < i + 2; r++) {//inner nested loop to check all round a given asterisk for out of bounds
                        for (int c = j - 1; c < j + 2; c++) {

                            if (r >= 0 && c >= 0 && r < arr.length && c < arr[0].length && !(r == i && c == j)) {
                                mapped[r][c]++;//every time we find an asterisk, we're bumping up all indices around it by one

                            }

                        }
                    } //inner two loops ends

                }
            }
        }

        for (int i = 0; i < arr.length; i++) {//formats arr back to numbers and asterisks
            for (int j = 0; j < arr[0].length; j++) {
                if (mapped[i][j] < 0)
                    arr[i][j] = '*';
                else
                    arr[i][j] = (char) (mapped[i][j] + '0');//49 is ASCII value for 1. (0 is 48.)
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }

        return mapped;
    }
}
 

קוד: וועל אויס אלע

 public static int solution(int[] A)
        {
            int numOfOs = A.Count(i => i == 0);
            int count = 0;
            var zerosFound = 0;
            for (int i = 0; i < A.Length; i++)
            {
                if (A[i] == 0)
                {
                    zerosFound++;//record every zero found


                    count += (A.Length - (i + 1)) - (numOfOs - zerosFound);//the number of permutations is: for every zero found, the sums of all the subsequent 1s added together
                                                                           //or, the number of 1s multiplied by the number of 0s that come strictly before (leftwards) themselves. 
                                                                           //So each time we encounter a 0, the number of 1s left to find is the number of indices left, minus the number of 0s left to find.


                    if (count > 1000000000)
                        return -1;
                }

            }
            return count;
        } 

קוד: וועל אויס אלע

 public static int solution(int[] A)
        {
            HashSet<int> hashSet = new HashSet<int>();
            foreach (var e in A)
                hashSet.Add(e);//deals with duplicates

            if (hashSet.Count() < A.Count())
                return 0; 

           return A.Except(Enumerable.Range(1, A.Length)).Count()==0 ? 1 : 0; //deals with omissions
        } 

קוד: וועל אויס אלע

  public static int countArithmeticMeans(int[] a)
        {
            int count = 0;
            int prev = 0;
            int i;
            for (i = 0; i < a.Length - 1; i++)
            {

                if (a[i] * 2 == prev + a[i + 1])
                    count++;
                prev = a[i];
            }
            if (a[i] * 2 == prev)
                count++;

            return count;
        }

קוד: וועל אויס אלע

(0, 0, 1, 0, 0)
(0, 0, 1, 1, 0)
(0, 0, 1, 2, 0)
(2, 2, 2, 2, 2)
(3, 2, 2, 2, 2)
(3, 2, 2, 3, 2)
(3, 2, 2, 4, 2)

קוד: וועל אויס אלע

     
using System.Collections;
using System.Linq;

Console.WriteLine(string.Join(",", solution(5, new int[] { 3, 4, 4, 6, 1, 4, 4 })));//-> [3, 2, 2, 4, 2] 

 public static int[] solution(int N, int[] A)
        {


            var max = 0;
            int[] counters = new int[N];//we're going to store here the results of the Increase(X) (or 'bumpup') operations; ignoring the MaxCounter(all Xs) operations for now.
            Hashtable indexesChanged = new Hashtable();

            if (A.Where(i => i <= counters.Length).Count() < 1)
                return counters;
            else
            {


                for (int i = 0; i < A.Length; i++)
                {
                    if (A[i] <= counters.Length)
                    {
                        counters[A[i] - 1]++;
                        if (!indexesChanged.ContainsKey(A[i] - 1))//stores how many changes (Increase ops) we've made to this index in 'counters' in between MaxCounter operations
                            indexesChanged.Add(A[i] - 1, 1);
                        else
                            indexesChanged[A[i] - 1] = ((int)indexesChanged[A[i] - 1]) + 1;
                    }
                    else
                    {
                        if (indexesChanged.Count > 0)//each time we have an MaxCounter operation, if any bumpups were made in between, we're adding to max 
                                                     //the biggest new change (since the last MaxCounter operation) we've made to a single index in 'countres'
                        {
                            max += indexesChanged.Values.Cast<int>().Max();
                            indexesChanged.Clear();//we're clearing the hashtable in order to start a new 'bumpup series'
                        }

                    }
                }

                for (int j = 0; j < counters.Length; j++)
                {
                    if (indexesChanged.Contains(j) && counters[j] < max)//if we've changed this index in 'counters' since the last MaxCounter we need this index to be 'max' plus the last changes/bumpups
                        //except if it's the same index that was the max at the last MaxCounter operation in which case it will already have the additional changes as well as max.. 
                        counters[j] = max + (int)indexesChanged[j];
                    else if (counters[j] < max)//if this index had no changes done to it the last time round (or also if the last instruction was a MaxCounter) or if it had increasements but is already >=max, we don't want to override it with a lower number.
                        counters[j] = max;

                }

                return counters;
            }
        }

קוד: וועל אויס אלע

  static int[] diagonalsArranging(string[,] a)
        {
            int diagonals = (a.GetLength(0) * 2) - 1;//GetLength(0) gets the length of rows (GetLength(1) the length of columns and so on for each dimension)
            Dictionary<int, string> concatenatedStrs = new Dictionary<int, string>();//we're using a dictionary where the index of each diagonal is the key

            for (int r = a.GetLength(0) - 1; r >= 0; r--)//starts off with row equaling to bottom left corner, decreasing row (until row = 0) after every inner traversal of columns (to the right)
            {

                string concat = "";
                int row = r;
                for (int c = 0; c < a.GetLength(0) - r; c++)//number of columns to traverse to the right gets ever so more  as we decrease row (or is proportional to row reduction)
                {

                    concat += a[row, c];
                    row++;
                }
                concatenatedStrs.Add((a.GetLength(0) * 2) - diagonals, concat);//the first index should be 1; not 0. Since we're not on row 1 (nor col 1) we have to do this trick)
                diagonals--;


            }

            for (int c = 1; c < a.GetLength(1); c++)//now we do the second half diagonals (top right corner)
            {

                string concat = "";
                int col = c;
                for (int r = 0; r < a.GetLength(0) - c; r++)//number of rows left to traverse to the right gets ever so diminished as we increase col number (or is proportional to column increase)

                {

                    concat += a[r, col];
                    col++;
                }
                concatenatedStrs.Add((a.GetLength(0) * 2) - diagonals, concat);
                diagonals--;


            }




            var ordered = concatenatedStrs.OrderBy(i => i.Value);//re-order

            return ordered.Select(i => i.Key).ToArray();//a map function to extract keys only from dictionary and transform to array which is the returned value
        }