CareerCup

Approach:
1. Set the iterator in both the array
2. Compare the item and do just increment, or increment with FirstArray right shift by one position.
3. Augment Second array to FirstArray if it still remains after first iterator finishes.

int [] MergeSortedArray(int FirstArray[], int elementCountInFirstArray, int SecondArray[], int sizeofSecondArray){
   int i=0,j=0;
   while(i<elementCountInFirstArray){
      if(FirstArray[i] >= SecondArray[j]){
          if(FirstArray[i] == SecondArray[j]){
              i++;
          }
          int k= i;
          while(k<elementCountInFirstArray){
              FirstArray[k+1] = FirstArray[k];
              k++;
          }
          FirstArray[i]=SecondArray[j];
          j++;
          elementCountInFirstArray++;
     }
          i++;
   }
   while(j<sizeofSecondArray){
    FirstArray[i++] = SecondArray[j++];
   }
   return FirstArray;
}

Please feel free to comment.

Thanks
Ankush

Algorithm:-

Let the two arrays be a[n], b[m+n+c]//m elements & c >=0
Let i be the iterator for a[]
Let j be the iterator for b[]
Let k be the position that needs to be filled

i = index for last element of a[] = n-1
j = index for last element of b[] = m-1
k = m+n-1;

while(i>=0 && j>=0)
{
    if(a[i]>b[j])
        b[k--] = a[i--]
    else
        b[k--] = b[j--]
}
while(i>=0)
{
    b[k--] = a[i--];
}

Copy all the items into the large array and perform a sort again. O(n log n) if you compare each item and push into the large array from the small array it will require moving items in the large array which is boring and useless.

let i & j point to element in arrays A & B
and k points to position to be filled in B(assuming B is larger one)

k = m+n-1
i = m-1
j = n-1

instead of merging from the beginning, start merging from the end(in decreasing order).