javabat question

Question

Return an array that contains the exact same numbers as the given array, but rearranged so that all the zeros are grouped at the start of the array. The order of the non-zero numbers does not matter. So {1, 0, 0, 1} becomes {0 ,0, 1, 1}. You may modify and return the given array or make a new array.

zeroFront({1, 0, 0, 1}) → {0, 0, 1, 1}
zeroFront({0, 1, 1, 0, 1}) → {0, 0, 1, 1, 1}
zeroFront({1, 0}) → {0, 1}

Here is what I have, but I know that it is incredibly wrong.

public int[] zeroFront(int[] nums) {

  for (int index = 0; index < nums.length; index ++)
  {
     int [] array1 = new int [index]; 
     if (nums [index] == 0)
     {
        array1 = nums [index]; 
     }
  }
  for (int index = 0; index < nums.length; index ++)
  {
     int [] array2 = new int [nums.length-index]; 
     if (nums [index] != 0)
     {
        array2 = nums [index]; 
     }
  }
  return array1 + array2;       
}

Answer 1

The sort method won't work for negative numbers, and the other way won't work for some cases (see comments).

The easiest (and shortest) way would be to sort the array (Works only for non-negative numbers, thanks Tom):

Arrays.sort(nums);

Another way would be to swap values when you find a non 0 :

int lastNonZero = -1;
for(int i = 0; i < nums.length; i++) {
  if(nums[i] == 0 && lastNonZero!=-1) {
     int tmp = nums[i];
     nums[i] = nums[lastNonZero];
     nums[lastNonZero] = tmp;
     lastNonZero = -1;
  }
  else lastNonZero = i;
}

Answer 2

Didn't test this, but should work:

public int[] zeroFront(int[] nums) {
  if (nums == null) {
    return null;
  }

  int[] result = new int[nums.length];
  int zeroesPos = 0;
  int othersPos = result.length - 1;
  for (int i = 0; i < nums.length; ++i) {
    if (nums[i] == 0) {
      result[zeroesPos] = 0;
      ++zeroesPos;
    } else {
      result[othersPos] = nums[i];
      --othersPos;
    }
  }
  return result;
}

This fills a new array up by scanning over the old one, and filling zeroes from the front and other numbers from the back. You can do something similar "in place" if you don't want to return a new array. You can keep track of where the next 0 should go and when you see it, swap it with the number at zeroesPos. Like this:

public void zeroFrontInPlace(int[] nums) {
  if (nums == null) {
    return;
  }

  int zeroesPos = 0;
  for (int i = 0; i < nums.length; ++i) {
    if (nums[i] == 0) {
      nums[i] = nums[zeroesPos];  // move the non-zero number to position i
      nums[zeroesPos] = 0;  // move the zero toward the front
      ++zeroesPos;
    }
  }
}

Notice you don't have to do a normal swap where you create a temporary value since you know the value is 0.

Hope this helps.

Answer 3

Havent tested either but this should be much simpler..

public int[] zeroFront(int[] nums) {
      if (nums == null) {
        return null;
      }
       int zerosPos = 0;

      for (int i = 0; i < nums.length; ++i) {
        if (nums[i] == 0) {      //swap zerosPos with current position
            num[i]=num[zerosPos];
            num[zerosPos]=0;
          ++zerosPos;
             }
      }
      return num;
    }

hope this helped!!

RDJ

Answer 4

For the example data shown, the array could simply be sorted.

If they are not representative, then write a Comparator which compares Math.abs(number) instead of number, and use that for sorting.