Test results - Codility

Code: 16:50:11 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 16:50:16 UTC, py, autosave

1 2 3 4 5 6

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

def solution(A):
    # write your code in Python 3.6
    pass

Code: 16:50:23 UTC, py, autosave

1 2 3 4 5

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

def solution(A):

Code: 16:50:44 UTC, py, autosave

1 2 3 4 5 6

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

def solution(A):
    # check if A has a dominator

Code: 16:51:03 UTC, py, autosave

1 2 3 4 5 6

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

def solution(A):
    # check if A has a dominator
    stack = [0]*A

Code: 16:51:34 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size ==

Code: 16:51:44 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:

Code: 16:52:03 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0: 
            stack[size] = A[i]
            size -= 1

Code: 16:52:55 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0: 
            stack[size] = A[i]
            size -= 1

Code: 16:53:12 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0: 
            stack[size] = A[i]
            size -= 1
        else:
            if

Code: 16:53:41 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0: 
            stack[size] = A[i]
            size += 1
        else:
            if stack[size-1] == A[i]
                size -=1
            elif

Code: 16:54:10 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if stack[size-1] == A[i]
                size -=1
        elif
            
        
        if size == 0: 
            stack[size] = A[i]
            size += 1
        else:
            
            elif

Code: 16:54:25 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if stack[size-1] == A[i]
                size -=1
        elif
            stack[size] = A[i]
            size += 1

Code: 16:54:42 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if
        if stack[size-1] == A[i]
            size -=1
        elif
            stack[size] = A[i]
            size += 1

Code: 16:54:59 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            
        elif stack[size-1] == A[i]: 
            size -=1
        elif
            stack[size] = A[i]
            size += 1

Code: 16:55:10 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1

Code: 16:55:20 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1

Code: 16:56:07 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1

Code: 16:56:35 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    for i in range(len(A)):
        if A[i]

Code: 16:56:51 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]

Code: 16:58:46 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]

Code: 16:59:11 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    if count > len(A)/2:

Code: 16:59:33 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1

Code: 17:00:15 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    #

Code: 17:00:45 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers

Code: 17:00:56 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers

Code: 17:08:20 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    ㄑ

Code: 17:08:51 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    
    for i in range(len(A)):

Code: 17:09:00 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    
    for i in range(len(A)):
        if

Code: 17:09:14 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if

Code: 17:09:25 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] ==

Code: 17:09:55 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum

Code: 17:17:09 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum

Code: 17:17:22 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find

Code: 17:17:50 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equi

Code: 17:18:04 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen

Code: 17:18:47 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    f

Code: 17:18:58 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A))

Code: 17:19:09 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if

Code: 17:19:20 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if prefixSum[i]

Code: 17:19:44 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and

Code: 17:19:55 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[]

Code: 17:20:11 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[]

Code: 17:20:25 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] >

Code: 17:20:36 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] > (len(A)-i)/2:

Code: 17:20:50 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] > (len(A)-i)/2:
           ans += 1

Code: 17:21:03 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

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

def solution(A):
    # check if A has a dominator
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    else 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] > (len(A)-i)/2:
           ans += 1

Code: 17:21:27 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*lem(A)
    size = 0
    
    for i in range(len(A)):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > len(A)/2:
        hasDominator = 1
    else 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(len(A)):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] > (len(A)-i)/2:
           ans += 1
    
    return ans

Code: 17:21:53 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*lem(A)
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] > (len(A)-i)/2:
           ans += 1
    
    return ans

Code: 17:22:04 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(len(A)):
        if prefixSum[i] > (i+1)/2 and prefixSum[len(A)-1]-prefixSum[i] > (len(A)-i)/2:
           ans += 1
    
    return ans

Code: 17:22:16 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:25:26 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:25:36 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else： 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:25:40 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
            
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:26:02 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:26:15 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print (hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:26:26 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:26:41 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    print(count)
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:26:57 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:27:07 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] == A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    print(stack)
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:27:33 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    print(stack)
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:27:35 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    
    print(stack)
    
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:28:02 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:28:09 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:28:27 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:28:39 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
            prefixSum[i] = curSum
        else
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:28:58 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:31:49 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:32:18 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i])
        print(prefixSum[length-1]-prefixSum[i])
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:32:46 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i])
        print(prefixSum[length-1]-prefixSum[i])
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:33:13 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i] )
        print(prefixSum[length-1]-prefixSum[i])
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:33:39 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i] + " " + (i+1)/2)
        print(prefixSum[length-1]-prefixSum[i] + " "+ (length-i)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:36:45 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i]  " " + (i+1)/2)
        print(prefixSum[length-1]-prefixSum[i] + " "+ (length-i)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

Code: 17:36:59 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i], " ",  (i+1)/2)
        print(prefixSum[length-1]-prefixSum[i], " ", (length-i)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:37:13 UTC, py, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i], " ",  (i+1)/2)
        print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:37:27 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i], " ",  (i+1)/2)
        print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i-1)/2:
           ans += 1
    
    return ans

Code: 17:37:28 UTC, py, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        print(prefixSum[i], " ",  (i+1)/2)
        print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i-1)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:37:39 UTC, py, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        # print(prefixSum[i], " ",  (i+1)/2)
        # print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i-1)/2:
           ans += 1
    
    return ans

Code: 17:37:52 UTC, py, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    # print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        # print(prefixSum[i], " ",  (i+1)/2)
        # print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i-1)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:41:09 UTC, py, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    # print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        # print(prefixSum[i], " ",  (i+1)/2)
        # print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i-1)/2:
           ans += 1
    
    return ans

The submission is being evaluated.

Code: 17:41:11 UTC, py, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

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

def solution(A):
    # check if A has a dominator
    length = len(A)
    stack = [0]*length
    size = 0
    
    for i in range(length):
        if size == 0:
            stack[size] = A[i]
            size += 1
        elif stack[size-1] != A[i]: 
            size -=1
        else:
            stack[size] = A[i]
            size += 1    
    
    count = 0
    for i in range(length):
        if A[i] == stack[size-1]:
            count += 1
    
    hasDominator = 0
    if count > length/2:
        hasDominator = 1
    else: 
        return 0
    
    # print(hasDominator)
    
    # if A has a dominator -> prefix sum each index of doiminator numbers
    prefixSum = [0]*length
    curSum = 0
    
    for i in range(length):
        if A[i] == stack[size-1]:
            curSum += 1
        prefixSum[i] = curSum
    
    # print(prefixSum)
    
    # final step find all the cuts points that makes equiDominator happen
    ans = 0
    for i in range(length):
        # print(prefixSum[i], " ",  (i+1)/2)
        # print(prefixSum[length-1]-prefixSum[i], " ", (length-i-1)/2)
        if prefixSum[i] > (i+1)/2 and prefixSum[length-1]-prefixSum[i] > (length-i-1)/2:
           ans += 1
    
    return ans

The submission is being evaluated.