Codility 7.2 Fish [stack and queue]

N voracious fish are moving along a river. Calculate how many fish are alive.

Task description
You are given two non-empty arrays A and B consisting of N integers. Arrays A and B represent N voracious fish in a river, ordered downstream along the flow of the river.

The fish are numbered from 0 to N − 1. If P and Q are two fish and P < Q, then fish P is initially upstream of fish Q. Initially, each fish has a unique position.

Fish number P is represented by A[P] and B[P]. Array A contains the sizes of the fish. All its elements are unique. Array B contains the directions of the fish. It contains only 0s and/or 1s, where:

0 represents a fish flowing upstream,
1 represents a fish flowing downstream.
If two fish move in opposite directions and there are no other (living) fish between them, they will eventually meet each other. Then only one fish can stay alive − the larger fish eats the smaller one. More precisely, we say that two fish P and Q meet each other when P < Q, B[P] = 1 and B[Q] = 0, and there are no living fish between them. After they meet:

If A[P] > A[Q] then P eats Q, and P will still be flowing downstream,
If A[Q] > A[P] then Q eats P, and Q will still be flowing upstream.
We assume that all the fish are flowing at the same speed. That is, fish moving in the same direction never meet. The goal is to calculate the number of fish that will stay alive.

For example, consider arrays A and B such that:

  A[0] = 4    B[0] = 0
  A[1] = 3    B[1] = 1
  A[2] = 2    B[2] = 0
  A[3] = 1    B[3] = 0
  A[4] = 5    B[4] = 0
Initially all the fish are alive and all except fish number 1 are moving upstream. Fish number 1 meets fish number 2 and eats it, then it meets fish number 3 and eats it too. Finally, it meets fish number 4 and is eaten by it. The remaining two fish, number 0 and 4, never meet and therefore stay alive.

Write a function:

def solution(A, B)

that, given two non-empty arrays A and B consisting of N integers, returns the number of fish that will stay alive.

For example, given the arrays shown above, the function should return 2, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..100,000];
each element of array A is an integer within the range [0..1,000,000,000];
each element of array B is an integer that can have one of the following values: 0, 1;
the elements of A are all distinct.
Copyright 2009–2019 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

题目意思：有一些向上游和向下游的鱼，经过了大鱼吃小鱼的操作后，计算还有多少鱼活着。
思路：用stack 的pop来做。
num首先计算确定往上游的鱼（不管是位于首位一开始就往上游的鱼还是经过弱肉强食的往上游的鱼），最后才加上确定往下游的鱼，就是总共存活的鱼。
当鱼往下游时，保存到下游鱼list中，当鱼往上游时，与list里面的下游鱼比较，比下游鱼小则被吃掉，比下游鱼大则pop一下。然后判断下游鱼的list长度，如果为0了，那么有两种情况：1. 下游鱼全被上游鱼吃掉了，那么上游鱼+1。 2. 没有下游鱼，自然上游鱼也是+1

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B):
    # write your code in Python 3.6
    #0： upstream  1: downstream

    down= []
    num = 0
    down_num = 0
    for i in range(len(A)):
        if B[i]==1:
            down.append(A[i])
            down_num += 1
        else:
            while down_num!=0:
                if down[-1] > A[i]: #如果往下游的大于往上游的,吃掉A[i]
                    break
                else:             #否则，往下游的list减少一个
                    down.pop()
                    down_num-=1
            if down_num ==0:  #往上游的吃掉了所有的往下游的
                num +=1
                
                
    num +=len(down)
    return num