How to add values of two arrays that are different sizes in length?

user_11666320 0
Viewed 316

If I have two int arrays such as

var array1 = [1,2,3]
var array2 = [1,2,3,5]

I'd like to be able to add the first element of the first array with the first element of the second array, and so on. However if an array has a different length than the other I'd like to keep the element that was not added in the return array. For this example my return array would be [2,4,6,5].

I tried using zip(array1,array2).map(+) but it would exclude the 5 from array2.

swift
5 Answers

After adding the elements at the index positions which are common to both arrays (what you already did with zip and map) just append the remaining elements from both arrays (using append(contentsOf:) and dropFirst):

let array1 = [1, 2, 3]
let array2 = [1, 2, 3, 5]

var combined = zip(array1, array2).map(+)
let commonCount = combined.count
combined.append(contentsOf: array1.dropFirst(commonCount))
combined.append(contentsOf: array2.dropFirst(commonCount))

print(combined) // [2, 4, 6, 5]
user_11874150 
AnySequence(zip: (1...3, [1, 2, 3, 5])).map {
  Optional($0).map(+) ?? firstNonNil($0)!
}

public extension AnySequence {
  /// Like `zip`, but with `nil` elements for the shorter sequence after it is exhausted.
  init<Sequence0: Sequence, Sequence1: Sequence>(
    zip zipped: (Sequence0, Sequence1)
  ) where Element == (Sequence0.Element?, Sequence1.Element?) {
    self.init(
      sequence(
        state: (zipped.0.makeIterator(), zipped.1.makeIterator())
      ) { iterators in
        ((iterators.0.next(), iterators.1.next()) as Optional)
          .filter { $0 != nil || $1 != nil }
      }
    )
  }
}

public extension Optional {
  /// Exchange two optionals for a single optional tuple.
  /// - Returns: `nil` if either tuple element is `nil`.
  init<Wrapped0, Wrapped1>(_ optionals: (Wrapped0?, Wrapped1?))
  where Wrapped == (Wrapped0, Wrapped1) {
    switch optionals {
    case let (wrapped0?, wrapped1?):
      self = (wrapped0, wrapped1)
    default:
      self = nil
    }
  }
  
  /// Transform `.some` into `.none`, if a condition fails.
  /// - Parameters:
  ///   - isSome: The condition that will result in `nil`, when evaluated to `false`.
  func filter(_ isSome: (Wrapped) throws -> Bool) rethrows -> Self {
    try flatMap { try isSome($0) ? $0 : nil }
  }
}

public func firstNonNil<Element>(_ tuple: (Element?, Element?)) -> Element? {
  switch tuple {
  case (let _0?, _):
    return _0
  case (nil, let _1?):
    return _1
  case (nil, nil):
    return nil
  }
}
user_6520380 
func combine2Arrays(array1:[Int], array2:[Int]) -> [Int] {
    var finalArray:[Int] = []
    let maxSize = max(array1.count, array2.count)
    
    for i in 0..<maxSize {
        let valToAdd1 = (array1.count > i ? array1[i] : 0)
        let valToAdd2 = (array2.count > i ? array2[i] : 0)
        let finalVal = valToAdd1 + valToAdd2
        finalArray.append(finalVal)
    }
    return finalArray
}

print(combine2Arrays(array1: [1,2,3], array2: [1,2,3,5]))

OR

func combine2Arrays(array1:[Int], array2:[Int]) -> [Int] {
    var finalArray:[Int] = zip(array1,array2).map(+)
    let largerArray = array1.count > array2.count ? array1 : array2
    let smallerArray = array1.count > array2.count ? array2 : array1
    let min = smallerArray.count
    let max = largerArray.count
    for i in min..<max {
        finalArray.append(largerArray[i])
    }
    return finalArray
}

print(combine2Arrays(array1: [1,2,3], array2: [1,2,3,5]))
user_50094320

You can fill your smaller array with zeroes, then use zip. inout means that arrays are mutable, or you can make the copy of function parameters inside the function to make them mutable.

private func combineArrays(array1: inout [Int], array2: inout [Int]) -> [Int] {
    let maxSize = max(array1.count, array2.count)

    if (array1.count > array2.count) {
        array2.append(contentsOf: [Int](repeating: 0, count: maxSize - array2.count))
    } else if (array2.count > array1.count) {
        array1.append(contentsOf: [Int](repeating: 0, count: maxSize - array1.count))
    }

    return zip(array1, array2).map(+)
}
user_135305470 
//javaScript
var array1 = [1,2,3,4,5];
var array2 = [9,7,8,6,5,6,7];

let a= array1.length;
let b = array2.length;

var array3 = [];

let c = a>b?a:b;

for(let i=0; i<c; i++){
    if(i < a && i < b){
        array3.push(array1[i] + array2[i]);
    } else if(i >= a){
        array3.push(array2[i])
    } else{
        array3.push(array1[i])
    }
}

console.log(array3)
user_170460810
Related