Максимальное умножение 3-х чисел Swift

Question

Я все еще новичок в программировании на Swift, в настоящее время пытаюсь понять, почему в некоторых случаях используется hackerrank (https://www.hackerrank.com/contests/nano-challenge-2-code-contest/challenges/maximum-multiplication/problem). Я всегда получаю ошибку времени выполнения.

Вопрос:

Учитывая массив целых чисел, найдите максимальное умножение элемента из 3 чисел в массиве. Пусть у нас есть [2, 5, 8], тогда 80 - это максимальное число 3 умножения элемента в массиве. Мы получаем 80 из 2 * 5 * 8. Количество элементов в массиве может быть отрицательным.

Формат ввода

Первая строка обозначает n как номер массива. Вторая строка является элементом массива

Ограничения

3 < n < 1000
-1000 < a[i] < 1000

Формат вывода

целое число максимального значения умножения 3 числа

Пример ввода 0

3 

2 5 8

Пример вывода 0

80

Пример ввода 1

6
-10 -3 -1 0 4 8

Пример ввода 1

240

Мое старое решение:

func maxMultiplication(arr: [Int]) -> Int {
    var minus = [Int]()
    var plus = [Int]()

    var answer = 0

    for x in arr {
        if x<0 {
            minus.append(x)
        }
        else {
            plus.append(x)
        }
    }

    minus.sort()
    plus.sort()

    //let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
    //let m = plus[plus.count-1] * minus[0] * minus[1]

    if plus.count==0 {
        let x = minus[minus.count-1] * minus[minus.count-2] * minus[minus.count-3]
        answer = x
    }
    else if minus.count == 0 {
        let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
        answer = p
    }
    else{
        let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
        let m = plus[plus.count-1] * minus[0] * minus[1]
        if p>m {
            answer = p
        }
        else {
            answer = m
        }
    }

    return answer

}

Мое текущее решение:

func maxMultiplication(arr: [Int]) -> Int {
    var minus = [Int]()
    var plus = [Int]()

    var answer = 0

    for x in arr {
        if x<0 {
            minus.append(x)
        }
        else {
            plus.append(x)
        }
    }

    minus.sort()
    plus.sort()

    //let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
    //let m = plus[plus.count-1] * minus[0] * minus[1]

    if plus.count==0 {
        let x = minus[minus.count-1] * minus[minus.count-2] * minus[minus.count-3]
        answer = x
    }
    else if minus.count == 0 {
        let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
        answer = p
    }
    else if plus.count==2 && minus.count == 1{
    answer = plus[0] * plus [1] * minus[0]
    }
    else if plus.count==1 && minus.count == 2{
       answer = plus[0] * minus[1] * minus[0]
    }

    else{
        let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
        let m = plus[plus.count-1] * minus[0] * minus[1]
        if p>m {
            answer = p
        }
        else {
            answer = m
        }
    }

    return answer

}

Я СДЕЛАЛ ЭТО! Спасибо, ребята: ") не могу обойтись без yall

Окончательное решение:

func maxMultiplication(arr: [Int]) -> Int {
    var minus = [Int]()
    var plus = [Int]()

    var answer = 0

    for x in arr {
        if x<0 {
            minus.append(x)
        }
        else {
            plus.append(x)
        }
    }

    minus.sort()
    plus.sort()

    //let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
    //let m = plus[plus.count-1] * minus[0] * minus[1]

    if plus.count==0 {
        let x = minus[minus.count-1] * minus[minus.count-2] * minus[minus.count-3]
        answer = x
    }
    else if minus.count == 0 {
        let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
        answer = p
    }
    else if plus.count==2 && minus.count == 1{
    answer = plus[0] * plus [1] * minus[0]
    }
    else if plus.count==1 && minus.count == 2{
       answer = plus[0] * minus[1] * minus[0]
    }
     else if plus.count==1 && minus.count>=3 {
    let a = plus[plus.count-1] * minus[1] * minus[0]
    let b = minus[2] * minus[1] * minus[0]
    if a>b {
           answer = a
       }
       else {
           answer = b
       }
 }
else if plus.count>=3 && minus.count==1 {
    let a = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
    let b = plus[plus.count-1] * plus[plus.count-2] * minus[0]

    if a>b {
        answer = a
    }
    else {
        answer = b
    }
}

    else{
        let p = plus[plus.count-1] * plus[plus.count-2] * plus[plus.count-3]
        let m = plus[plus.count-1] * minus[0] * minus[1]
        if p>m {
            answer = p
        }
        else {
            answer = m
        }
    }

    return answer

}

• edit: Еще одна разовая ошибка, все еще пытаюсь разберись в чем ошибка

Answer 1

Я собрал быструю версию кода. Не успел его оптимизировать. Я оставлю это тебе. Надеюсь, это поможет.

Протестировано со следующими входами.

values = [-10,-3,-1,0,4,8]
print(findMaxMultiplicationOf3(numbers: values))

values = [-1,2,3,4]
print(findMaxMultiplicationOf3(numbers: values))

values = [1,-2,-3,-4]
print(findMaxMultiplicationOf3(numbers: values))

values = [-1,-2,-3,-4]
print(findMaxMultiplicationOf3(numbers: values))

values = [5, 10, 2, -100, -5]
print(findMaxMultiplicationOf3(numbers: values))

values = [5, 10, 2, -100, -15, -50]
print(findMaxMultiplicationOf3(numbers: values))

values = [-1,-2,-3,-4]
print(self.findMaxMultiplicationOf3(numbers: values))

Выходы: 120, 240, 24, 12, 12, 5000, 50000, -6

func findMaxMultiplicationOf3(numbers: [Int]) -> Int {
    var results: [Int] = []
    // Find the top 3 largest numbers
    let positive = numbers.filter({ $0 > 0 }).sorted(by: { $0 > $1 })
    let negative = numbers.filter({ $0 < 0 }).sorted(by: { $0 < $1 })

    func addPositiveAndNegativeNumbers() {
        // This adds one largest positive number and two largest negative numbers
        results.append(positive[0])
        add2LargestNegativeNumbers()
    }

    func add2LargestNegativeNumbers() {
        if negative.count >= 2 {
            var i: Int = 0
            while i < 2 {
                results.append(negative[i])
                i = i + 1
            }
        }
    }

    func add3LargestPositiveNumbers() {
        var i: Int = 0
        while i < 3 {
            results.append(positive[i])
            i = i + 1
        }
    }

    func multiplyToGetResult() -> Int {
        var i: Int = 0
        var result = 1
        while i < 3 {
            result = result * results[i]
            i = i + 1
        }
        return result
    }

    // Check if there are atleast 3 positive numbers
    if positive.count >= 3 {
        // 1. Are there atleast two negative numbers? If yes, is any one -ve number greater than the largest positive number?
        if negative.count >= 2, let largestNegativeNumber = negative.first, let largestPositiveNumber = positive.first,
            abs(largestNegativeNumber) > abs(largestPositiveNumber) {
            // Pick the largest negative number, and the second negative number and choose 1 positive number
            addPositiveAndNegativeNumbers()
        }
        else {
            add3LargestPositiveNumbers()
        }
    }
    else {
        // Add top positive number
        if positive.count > 0 {
            // Add 2 negative numbers, so that the result becomes positive
            // Make sure to check if there are atleast two negative numbers
            addPositiveAndNegativeNumbers()
        }
        else {
            // There are no positive numbers.
            // pick the least three negative numbers
            if negative.count >= 2 {
                var i: Int = negative.count - 1
                while i >= 0 {
                    results.append(negative[i])
                    i = i - 1
                }
            }
        }
    }
    return multiplyToGetResult()
}

Answer 2

extension Sequence where Element: Numeric & Comparable {
  /// The greatest product of any three elements.
  /// - This will either involve
  /// 1. the greatest 3 elements
  /// 2. the lowest 2, and the single greatest
  var maxProductOf3: (product: Element, factors: [Element])? {
    let sorted = self.sorted()

    guard sorted.count >= 3 else {
      return nil
    }

    let greatest = sorted.last!
    let (product, lesserFactors) =
      [ sorted.dropLast().suffix(2),
        sorted.prefix(2)
      ]
      .map { lesserFactors in
        ( product: lesserFactors.reduce(greatest, *),
          lesserFactors
        )
      }
      .max { $0.product }!
    return (product, lesserFactors + [greatest])
  }
}

public extension Sequence {
  func max<Comparable: Swift.Comparable>(
    _ getComparable: (Element) throws -> Comparable
  ) rethrows -> Element? {
    try self.max {
      try getComparable($0) < getComparable($1)
    }
  }
}