Phone interview question # 1:

Given an array (for example, [ 1, 0, 2, 0, 0, 3, 4 ]), implement methods that

1. returns the number of non-zero elements (4)
2. moves the non-zero elements to the beginning of the array (the rest of the elements don't matter)
- both [ 1, 2, 3, 4, 0, 0, 0] and [ 4, 1, 3, 2, X, Y, Z ] are valid

Question

Phone interview question # 1:

Given an array (for example, [ 1, 0, 2, 0, 0, 3, 4 ]), implement methods that

1. returns the number of non-zero elements (4)
2. moves the non-zero elements to the beginning of the array (the rest of the elements don't matter)
  -> both [ 1, 2, 3, 4, 0, 0, 0] and [ 4, 1, 3, 2, X, Y, Z ] are valid

Rupak · Accepted Answer

let givenArray = [1,0,2,0,0,3,4]
var arrayWithNonZeroElements = givenArray.filter({ $0 != 0 })
let arrayWithZeroElements =  givenArray.filter({ $0 == 0 })

print(arrayWithNonZeroElements.count) //"4
"
arrayWithNonZeroElements.appendContentsOf(arrayWithZeroElements) 
print(arrayWithNonZeroElementst) // [1,2,3,4,0,0,0]

Emilie · Answer

The answer from OP is good, but there is a case where it doesn't work : if the last value of the array is @0 and the array contains another @0  (Ex: [@1, @0, @2, @0], then you end up swapping two @0 and not solving fully the problem. There is a little optimization possible on the ending condition of the for loop : ending when we reach exchangeObjectAtIndex:indexOfLastNonZeroItem instead. Here is my full solution : 

- (NSInteger) countAndRearrangeNonZeroElementsFromThisArray: (NSMutableArray*) originalArray {
    NSInteger countOfZeros = 0;
    NSInteger indexOfLastNonZeroItem = [originalArray count] - 1;
   
    while ([originalArray[indexOfLastNonZeroItem] isEqualToNumber: @0]) {
        indexOfLastNonZeroItem--;
    }
    
    for(NSInteger index = 0; index < indexOfLastNonZeroItem; index++) {
        NSNumber * numberFromArray = [originalArray objectAtIndex:index];
        if([numberFromArray isEqualToNumber:@0]){
            countOfZeros++;
            [originalArray exchangeObjectAtIndex:index withObjectAtIndex:indexOfLastNonZeroItem];
            indexOfLastNonZeroItem--;
        }
    }
    
    return countOfZeros;
}

Anónimo · Answer

@interface FB : NSObject
  
- (NSInteger) countAndRearrangeNonZeroElementsFromThisArray: (NSMutableArray *) originalArray;

@end
  
@implementation FB
  
- (NSInteger) countAndRearrangeNonZeroElementsFromThisArray: (NSMutableArray *) originalArray
{
  NSInteger countOfZeros = 0;
  NSInteger indexOfLastNonZeroItem = [originalArray count] - 1;

  for(NSInteger index = 0; index < [originalArray count]; index++)
  {
     NSNumber * numberFromArray = [originalArray objectAtIndex:index];
    
     if([numberFromArray intValue] == 0)
     {
         countOfZeros++;
         [originalArray exchangeObjectAtIndex:indexOfLastNonZeroItem withObjectAtIndex:index];
         indexOfLastNonZeroItem--;
     }
  }
  return(countOfZeros);
}

@end
  
int main (int argc, const char * argv[])
{
  @autoreleasepool {

    FB * fbObj = [[FB alloc] init];
    
    if(fbObj)
    {
      // try different arrays, such as:
      // [@[@1,@0,@2]
      // [@[@1, @0, @2, @0, @0, @3, @4 ]
      
      NSMutableArray *mutableArray = [@[@1,@0,@2] mutableCopy];
       NSInteger numberOfZeros = [fbObj countAndRearrangeNonZeroElementsFromThisArray:mutableArray]; 
      
      NSLog(@"numberOfZeros = %ld %@", numberOfZeros, mutableArray);
    }
  }
}

Ahmed · Answer

modified version of the above answer, that works with inout arrays
func countZerosAndMoveToBegning(array: inout [String]) -> UInt
    {
        
        let nonZeros = array.filter { $0 != "0" }
        let zeros = array.count - nonZeros.count
        let arrayZeros = Array(repeating: "0", count: zeros)
        array.removeAll()
        array.append(contentsOf: arrayZeros)
        array.append(contentsOf: nonZeros)
        return UInt(zeros)
        
    }

Manish Singh · Answer

```    
func solve(_ array: inout [Int]) -> UInt {
        var count: UInt = 0
        for (index, element) in array.enumerated() {
            if element == 0 {
                array.remove(at: index)
                array.insert(element, at: 0)
                count += 1
            }
        }
        return count
    }
```

DennyLou · Answer

import UIKit
    import Foundation

    var str = "Hello, playground"

    /// MARK: Helpers

    // Generate random Int
    func randomInt() -> Int {
        return Int(arc4random_uniform(3))
    }

    // Add a default items array length of 7
    let count = 7

    /// MARK: Solution

    // Generate the arry of items
    var items = [Int]()
    for i in 0..

Martin Stoufer · Answer

At the highest possible level:

void numCount()
{
    NSArray *nums = @[@(1), @(0), @(2), @(0), @(0), @(3), @(4)];
    
    NSArray *nonZeroNums = [nums filteredArrayUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(id  _Nonnull evaluatedObject, NSDictionary * _Nullable bindings) {
        return ([evaluatedObject integerValue] != 0);
    }]];
    if (nonZeroNums) {
        NSLog(@"Conunt: %lu", nonZeroNums.count);
    }
    
    NSSortDescriptor* sortOrder = [NSSortDescriptor sortDescriptorWithKey: @"self"
                                                                ascending: NO];
    NSArray *sortedArray = [nums sortedArrayUsingDescriptors: [NSArray arrayWithObject: sortOrder]];
    NSLog(@"%@", sortedArray);
}

Jeff · Answer

Here are a few other interesting solutions I came up with (in Swift). Here is the order from fastest to slowest execution: one, four, three, two. func one(inout array: [Int]) -> Int { array = array.sort(>) return array.reduce(0) { return $0 + ($1 != 0 ? 1 : 0) } } func two(inout array: [Int]) -> Int { array = array.sort(>) return array.filter({$0 != 0}).count } func three(inout array: [Int]) -> Int { var nonZeros = 0 var left = 0 let count = array.count while left Int { var nonZeros = 0 var left = 0 let count = array.count var right = count - 1 while left < right { while array[left] != 0 { nonZeros += 1 left += 1 } while array[right] == 0 { right -= 1 } if left < right { swap(&array[left], &array[right]) left += 1 right -= 1 nonZeros += 1 } } return nonZeros }

Jeff · Answer

Oops, I messed up the original post. Here is the correct "three" function (the one listed above is truly "four"):

func four(inout array: [Int]) -> Int {
    var nonZeros = 0
    
    var left = 0
    let count = array.count

    while left < count && array[left] != 0 {
        left += 1
        nonZeros += 1
    }
    
    for i in left..

Nik · Answer

The answer by Emilie and IC are partially correct.
Try them with: @[@(1), @(1),@(0),@(0), @(1), @(0), @(19), @(0)]]

I optimized it to be:

- (NSInteger) countAndRearrangeNonZeroElementsFromThisArray: (NSMutableArray *) originalArray
{
    NSInteger indexOfLastNonZeroItem = [originalArray count] - 1;
    
    for(NSInteger index = 0; index < indexOfLastNonZeroItem; index++)
    {
        while ([[originalArray objectAtIndex:indexOfLastNonZeroItem] intValue ] == 0 && index < indexOfLastNonZeroItem)
        {
            indexOfLastNonZeroItem--;
        }
        NSNumber * numberFromArray = [originalArray objectAtIndex:index];

        if([numberFromArray intValue] == 0)
        {
            [originalArray exchangeObjectAtIndex:indexOfLastNonZeroItem withObjectAtIndex:index];
            indexOfLastNonZeroItem--;
        }
    }
    
    return(indexOfLastNonZeroItem+1);
}

Anónimo · Answer

- (int)returnNumbersOfZerosIn:(NSArray *)array {
  NSMutableArray *newArray = [array mutableCopy];
  
  int zeroCounter = 0;
  for (NSNumber *num in newArray) {
    if ([num intValue] == 0)
      zeroCounter++;
  }

  return zeroCounter;
}

- (NSMutableArray *)moveZerosToEndOf:(NSArray *)array {
  NSMutableArray *newArray = [array mutableCopy];
  NSMutableArray *final = [[NSMutableArray alloc] init];
  for (NSNumber *num in newArray) {
    if ([num intValue] != 0) {
      [final insertObject:num atIndex:0];
    } else {
      [final addObject:num];
    }
      
  }
  NSLog(@"final array: %@" , final);
  return final;
}

Diego · Answer

+ (NSArray *)moveZerosToBeginning:(NSMutableArray *)arrayWithNums {
    NSInteger firstNonZero = 0;
    while (((NSNumber *)arrayWithNums[firstNonZero]).integerValue == 0) {
        firstNonZero++;
    }
    
    for (NSInteger lastIndex = arrayWithNums.count - 1; lastIndex > firstNonZero; lastIndex --) {
        if (((NSNumber *)arrayWithNums[lastIndex]).integerValue == 0) {
            arrayWithNums[lastIndex] = arrayWithNums[firstNonZero];
            arrayWithNums[firstNonZero] = @0;
            firstNonZero++;
            while (((NSNumber *)arrayWithNums[firstNonZero]).integerValue == 0) {
                firstNonZero++;
            }
        }
    }
    
    return arrayWithNums;
}

Carlos Carvalho · Answer

var vals = [0,1,5,0,2,0,0,3,4,0,0,0,6,7,8,0,9,0]
        
        var lastZeroIdx = -1
        for (idx, val) in vals.enumerate() {
            if lastZeroIdx == -1 && val == 0 { lastZeroIdx = idx }
            if val != 0 && lastZeroIdx > -1 {
                for i in (lastZeroIdx...idx).reverse() {
                    if lastZeroIdx == i { break }
                    let val1 = vals[i]
                    let val2 = vals[i-1]
                    vals[i-1] = val1
                    vals[i] = val2
                }
                lastZeroIdx += 1
            }
        }

Carlos Carvalho · Answer

import Foundation

var array = [1, 0, 2, 0, 0, 3, 4]

func organiseArray(array: [Int]) -> (count: Int, array: [Int]) {
  
  var newArray = [Int](repeating: 0, count: array.count)
  var idxHead = 0
  var idxTail = array.count - 1
  for item in array {
    if item == 0 {
      newArray[idxHead] = item
      idxHead += 1
    } else {
      newArray[idxTail] = item
      idxTail -= 1
    }
    
  }
  return (count: newArray.count - idxHead, array: newArray)
}

let r = organiseArray(array: array)
print("\(r.count) -> \(r.array)")

Anónimo · Answer

let numbers = [1 ,2 ,3,0,0,0,6,7,8]
let nonZeros = numbers.filter { $0 != 0 }
let zeros = numbers.count - nonZeros.count
var arrayZeros = Array(repeating: 0, count: zeros)
let sorted = arrayZeros + nonZeros

Meta

Pregunta de entrevista de Meta

Respuestas de entrevistas

Empresas seguidas

Búsquedas de empleo