CareerCup

public static int[] MoveZeros(int[] arr)
        {
            int cnt = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                if(arr[i] != 0)
                {
                    arr[i - cnt] = arr[i];
                }
                else
                {
                    cnt++;
                }
            }


            for (int i = 1; i <= cnt; i++)
            {
                arr[arr.Length - i] = 0;
            }
            return arr;
        }

The complexity is o(n^2)
create dictionary where key is Y coordinate and values are Hashset of X coordinates.

public struct Point
        {
            public int X { get; set; }
            public int Y { get; set; }

            public Point(int x, int y)
            {
                X = x;
                Y = y;
            }
        }
        public static int RectanglesCount(List<Point> points)
        {

            Dictionary<int, HashSet<int>> dic = new Dictionary<int, HashSet<int>>();

            foreach (var item in points)
            {
                if (dic.ContainsKey(item.Y))
                    dic[item.Y].Add(item.X);
                else
                    dic.Add(item.Y, new HashSet<int>() { item.X });
            }

            int cnt = 0;
            int[] ycoords = dic.Keys.OrderBy(i => i).ToArray();
            for (int i = 0; i < ycoords.Length; i++)
            {
                for (int j = i+1; j < ycoords.Length; j++)
                {
                    cnt += dic[i].Intersect(dic[j]).Count() / 2;
                }
            }

            return cnt;
        }

public struct Point
        {
            public int X { get; set; }
            public int Y { get; set; }

            public Point(int x, int y)
            {
                X = x;
                Y = y;
            }
        }
        public static int RectanglesCount(List<Point> points)
        {

            Dictionary<int, HashSet<int>> dic = new Dictionary<int, HashSet<int>>();

            foreach (var item in points)
            {
                if (dic.ContainsKey(item.Y))
                    dic[item.Y].Add(item.X);
                else
                    dic.Add(item.Y, new HashSet<int>() { item.X });
            }

            int cnt = 0;
            int[] ycoords = dic.Keys.OrderBy(i => i).ToArray();
            for (int i = 0; i < ycoords.Length; i++)
            {
                for (int j = i+1; j < ycoords.Length; j++)
                {
                    cnt += dic[i].Intersect(dic[j]).Count() / 2;
                }
            }

            return cnt;
        }

Time O(n)

public class Node
    {
        public int Value { get; set; }
        public Node Next { get; set; }
    }

    public class  SinglyLinkedList
    {
        public Node Head { get; set; }
        public Node Tail { get; set; }
        public int Count { get; set; }
    }

public static bool IsPolindrom(SinglyLinkedList list)
        {
            Stack<int> store = new Stack<int>();
            Node current = list.Head;
            for (int i = 0; i < list.Count; i++)
            {
                if (i <= list.Count / 2)
                    store.Push(current.Value);
                else
                {
                    int tmp = store.Pop();
                    if (tmp != current.Value)
                        return false;
                }
                current = current.Next;
            }

            return true;
        }

Use BitArray, because of the limited memory requirement

BitArray store = new BitArray(10000000, false);
            int num = GetNum();
            while (num != -1)
            {
                if (!store.Get(num - 1))
                    store.Set(num - 1, true);

                num = GetNum();
            }


            for (int i = 0; i < store.Length; i++)
            {
                if (store.Get(i))
                    Console.WriteLine(i + 1);
            }

Is there requirements about time or space complexity?

public class AccountHackHelper
{
int n;
SortedList<DateTime, DateTime> store;

public AccountHackHelper(int n)
{
this.n = n;
store = new SortedList<DateTime, DateTime>(n);
}



public bool IsAccountHacked(string userName, DateTime currentDate)
{
StoreFailedLogin(currentDate);

if (store.Count == n && (currentDate - store.First().Value).TotalSeconds < 3600 )
{
return true;
}

return false;
}

private void StoreFailedLogin(DateTime currentDate)
{
if (store.Count == n) { store.RemoveAt(0); }
store.Add(currentDate, currentDate);
}

}