Swift maximale aufeinanderfolgende positive Zahlen

Question

Wie kann man die maximalen aufeinanderfolgenden positiven Zahlen mit Verschlüssen zählen?

var numbers = [1,3,4,-1,-2,5,2,-2,-3,-4,5] 
//in this case it should be 3 

print(numbers.reduce(0, { $1 > 0 ? $0 + 1 : $0 }))//this counts total positive numbers 

Answer 1

Update: einfachere Lösung: Teilen des Arrays in Scheiben von positive Elemente und bestimmen die maximale Scheibenlänge:

let numbers = [1,3,4,-1,-2,5,2,-2,-3,-4,5] 
let maxConsecutive = numbers.split(whereSeparator: { $0 <= 0 }).map { $0.count }.max()! 
print(maxConsecutive) // 3 

---

Alte Antwort:) Mit den Ideen von Swift running sum:

let numbers = [1,3,4,-1,-2,5,2,-2,-3,-4,5] 

let maxConsecutive = numbers.map({ 
    () -> (Int) -> Int in var c = 0; return { c = $0 > 0 ? c + 1 : 0; return c } 
}()).max()! 

Hier map() bildet jedes Array-Element zu der Anzahl der aufeinanderfolgenden positiven Zahlen bis zu der Position Elemente, in diesem Fall

[1, 2, 3, 0, 0, 1, 2, 0, 0, 0, 1] 

Die Transformation wird als "sofort ausgewerteter Abschluss" erstellt, um eine Variable c zu erfassen, die die aktuelle Nummer enthält aufeinanderfolgende positive Zahlen. Die Transformation inkrementiert oder setzt c, zurück und gibt den aktualisierten Wert zurück.

Wenn das Array möglicherweise groß ist, dann ist es ändern

let maxConsecutive = numbers.lazy.map(...).max()! 

so daß die maximale Lauflänge, ohne eine Zwischen Array bestimmt wird.

Answer 2

var currentResult = 0 
var maxResult = 0 
for i in numbers { 
    currentResult = i > 0 ? currentResult + 1 : 0 
    if maxResult < currentResult { 
     maxResult = currentResult 
    } 
} 
print(maxResult) 

Lösung ohne Verschlüsse

Answer 3

var numbers = [1, 3, 4, -1, -2, 5, 2, -2, -3, -4, 5] 

let result = numbers.reduce((current: 0, max: 0)) { result, number in 
    var value = result 

    if number > 0 { 
     value.current += 1 
     value.max = max(value.current, value.max) 
    } else { 
     value.current = 0 
    } 

    return value 
} 



result.max 

Answer 4

generieren Teilfolgen:

let numbers = [1,3,4,-1,-2,5,2,-2,-3,-4,5] 
let subsequences: [[Int]] = numbers.reduce(into: []) { (result, number) in 
    guard 
     var currentSequence = result.last, 
     let lastNumber = currentSequence.last 
    else { 
     result = [[number]] 
     return 
    } 

    if number == lastNumber + 1 { 
     currentSequence.append(number) 
     result.removeLast() 
     result.append(currentSequence) 
    } else { 
     result.append([number]) 
    } 
} 
let longest = subsequences.max { $0.count < $1.count } 
print(subsequences) 
print("Longest subsequence: \(longest)") 
print("Longest length: \(longest?.count)")