CareerCup

Firstly, the question is to find the first common factor not the least common factor. I've used a simple recursive approach:

Given p and q nodes.
Check If p.parent == q.parent
- if yes, return p
- if no, traverse p and q upwards. (i.e p.parent, q.parent), until we find a equal nodes.

public static Node<int> CheckCommonAncestor(Node<int> p, Node<int> q)
        {
            if (p.Parent == q.Parent)
            {
                if (p.Parent == null)
                    return p;
                else
                    return p.Parent;
            }
            else
            {
                if (p.Parent != null && q.Parent != null)
                {
                    return CheckCommonAncestor(p.Parent, q.Parent);
                }
                else if (p.Parent == null)
                {
                    return CheckCommonAncestor(p, q.Parent);
                }
                else if (q.Parent == null)
                {
                    return CheckCommonAncestor(p.Parent, q);
                }

            }

            return null;            
        }

//Amazon Question: You have given an array of integers. The appearance of integers vary (ie some integers appears twice or once or more than once) How would you determine which integers appeared odd number of times ?   
//Using Dict C# (Hashmap alternate of Java)
//Time Complexity: O(N)

namespace Noofoccurenceofint
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = new int[] { 1, 1, 1, 2, 2, 5, 8, 9, 5, 9, 10 };

            List<int> oddocc =  OddTimes(a);

            foreach(int n in oddocc)
            {
                Console.WriteLine(n);


            }
        }


        public static List<int> OddTimes(int[] a)
        {
            Dictionary<int, int> D = new Dictionary<int, int>();
            List<int> oddocc = new List<int>();

            for (int i = 0; i < a.Length; i++)
            {
                if (D.ContainsKey(a[i]))
                    D[a[i]]++;
                else
                    D[a[i]] = 1;

            }

            foreach(KeyValuePair<int,int> kvp in D)
            {
                if (kvp.Value % 2 != 0)
                    oddocc.Add(kvp.Key);
                
            }


            return oddocc;

        }
    }

For a duplicate array:

public static int Findmissing2(int[] A1, int[] A2)
        {

            for (int i = 0; i < A2.Length; i++)            //Since second array is a copy
            {
                if (A1[i] != A2[i])
                    return A1[i];
            }

            return A1[A1.Length-1];
        }

C# code:

//Time Complexity: O(n)
        public static int Findmissing(int[] A1, int[] A2)
        {

            Dictionary<int, int> D = new Dictionary<int, int>();

            for (int i = 0; i < A1.Length; i++)
            {
                if (D.ContainsKey(A1[i]))
                    D[A1[i]]++;
                else
                    D[A1[i]] = 1;
            }

            for (int i = 0; i < A2.Length; i++)
            {
                if (D.ContainsKey(A2[i]))
                    D[A2[i]]++;
                else
                    D[A2[i]] = 1;
            }

            int missing=0;
            foreach (KeyValuePair<int, int> pair in D)
            {
                if (pair.Value == 1)
                {
                    missing = pair.Key; // Found
                    break;
                }
            }

            return missing;
        }

Dictionary<int, int> D = new Dictionary<int, int>();

            for (int i = 0; i < A.Length; i++)
            {
                if (!D.ContainsKey(A[i]))
                    D.Add(A[i], 1);
                else
                    D[A[i]]++;

            }

public static int counting2s(int num)                        
        {

            int cnt = 0;
            for (int i = 0; i <= num; i++)
            {

                int currnum = i;
                while (currnum!= 0)
                {
                    int digit = currnum % 10;
                    if (digit == 2)
                        cnt++;

                    currnum = currnum / 10;
                }

            }

            return cnt;
        }

public static int counting2s(int num)                        //Time Complexity: 
        {

            int cnt = 0;
            for (int i = 0; i <= num; i++)
            {

                int currnum = i;
                while (currnum!= 0)
                {
                    int digit = currnum % 10;
                    if (digit == 2)
                        cnt++;

                    currnum = currnum / 10;
                }

            }

            return cnt;
        }

What do you think?