Iterate Array and Count Changes from Negative to Positive (and vice versa)

Question

I'm using CoreMotion's GyroData to determine the Z direction of the devise's movement. This returns me an array of doubles. Positive moving forward, negative moving backwards. I'd now like to count how many times the devise moves in one direction. Moving in opposite direction would be one count.

So I'm trying to count how many times the value changes from a positive to a negative value or from a negative to a positive inside an array. If this is the array the count would be 3.

let array = [1, 2, 3, 4, -1, -1, -2, -3, 1, 2, 3, -1, -2]

Is it possible to do this in one line? I feel like I'm totally over complicating things with this code:

var count = 0
var isPositive = false

for (index, value) in array.enumerated() {

  if isPositive == false {
      if value > 0 {
          isPositive = true
          count += 1
      }
   } else {
      if value < 0 
          isPositive = false
          count += 1
      }
   }
}

Thanks!!

This question is appropriate for [codereview](http://codereview.stackexchange.com) not here — mfaani, Mar 14 '17 at 15:55
You say `from a positive to a negative value` I see it only 2 times, not 3. `4` --> `-1` and `3` --> `-1` — erkanyildiz, Mar 14 '17 at 15:55
Makes no sense. What if we have [1,0,-1]. What should the answer be? We never went from positive to negative because we passed thru 0 which is neither. Your spec is deficient. — matt, Mar 14 '17 at 16:01
@erkanyildiz So _you_ say, but the question is what the OP's spec is. — matt, Mar 14 '17 at 16:03
According to OP, answer should be 0, as there is no transition from a `positive value` to `negative value`. But, we can discuss what a `transition` is. In practice, your example may be counted as 1, also. — erkanyildiz, Mar 14 '17 at 16:04
Thanks @matt , but I'm not sure what you mean with passed thru 0. — robinyapockets, Mar 14 '17 at 16:05
OK, I will add onto my question to clarify what I'm trying to do. — robinyapockets, Mar 14 '17 at 16:06
Aside from all caveats your code doesn't work at all since you assume that the initial value is negative and both `count` and `isPositive` are reset to `0 / false` at the beginning of each iteration. And finally an opening brace is missing. — vadian, Mar 14 '17 at 16:08

Alexander · Accepted Answer · 2017-03-14T16:19:04.660

Note: The exact logic about which pairs to count is subject to change, because I'm not exactly sure what you're looking for yet. It should be simple enough to make the proper changes as necessary.

Firstly, I'd clarify what kinds of transitions we're looking for. I'll be looking at transitions from negative numbers (less than 0), to non-negative numbers (0 and all positives). I'll simplify this with the following extension:

extension Integer {
    var isNonNegative: Bool { return !isNegative }
    var isNegative: Bool { return self < 0 }
}

In cases like this, where you're trying to iterate pairs of a Sequence, zip(_:_:) comes in really handy.

let array = [1, 2, 3, 4, -1, -1, -2, -3, 1, 2, 3, -1, -2]
let pairs = zip(array, array.dropFirst(1))
print(Array(pairs))

That results in these pairs:

[(1, 2), (2, 3), (3, 4), (4, -1), (-1, -1), (-1, -2), (-2, -3), (-3, 1), (1, 2), (2, 3), (3, -1), (-1, -2)]

From here, it's a matter of just counting the number of pairs in which the first element (.0) is negative, and the second element (.1) is positive. Like so:

let numRisingEdges = pairs.reduce(0) { count, pair in
    if pair.0.isNegative && pair.1.isNonNegative { return count + 1 }
    else { return count }
}

print(numRisingEdges) // => 1

Thanks @Alexander - will give it a shot. – robinyapockets Mar 14 '17 at 16:17 — robinyapockets, Mar 14 '17 at 16:17

score 0 · Answer 2 · answered Mar 14 '17 at 16:37

I didn't like my own previous answer so here's a slightly different approach:

    let array = [1, 1, 2, 3, 4, -1, -1, -2, -3, 1, 2, 3, -1, -2]
    func sign(_ i: Int) -> Int {
        switch true {
        case i > 0: return 1
        case i < 0: return -1
        default: return 0
        }
    }
    let result = array.map{sign($0)}.reduce([Int]()) { arr, cur in
        var arr = arr
        if arr.count == 0 {
            arr.append(cur)
        } else if arr.last! != cur {
            arr.append(cur)
        }
        return arr
    }
    print(result.count-1) // 3

The idea is that we maintain arr as a scratchpad of sign changes. But the first entry doesn't count because nothing preceded it, so discount it by subtracting 1 from the overall count of changes.

Thanks @matt ! This works great as well! Apologies for the initial unclear question. I appreciate your time. — robinyapockets, Mar 14 '17 at 16:39

Iterate Array and Count Changes from Negative to Positive (and vice versa)

2 Answers2