Test results - Codility

Tasks Details

medium

1. CommonPrimeDivisors

Check whether two numbers have the same prime divisors.

Task Score

69%

Correctness

85%

Performance

50%

A prime is a positive integer X that has exactly two distinct divisors: 1 and X. The first few prime integers are 2, 3, 5, 7, 11 and 13.

A prime D is called a prime divisor of a positive integer P if there exists a positive integer K such that D * K = P. For example, 2 and 5 are prime divisors of 20.

You are given two positive integers N and M. The goal is to check whether the sets of prime divisors of integers N and M are exactly the same.

For example, given:

N = 15 and M = 75, the prime divisors are the same: {3, 5};

N = 10 and M = 30, the prime divisors aren't the same: {2, 5} is not equal to {2, 3, 5};

N = 9 and M = 5, the prime divisors aren't the same: {3} is not equal to {5}.

Write a function:

def solution(A, B)

that, given two non-empty arrays A and B of Z integers, returns the number of positions K for which the prime divisors of A[K] and B[K] are exactly the same.

For example, given:

A[0] = 15 B[0] = 75 A[1] = 10 B[1] = 30 A[2] = 3 B[2] = 5

the function should return 1, because only one pair (15, 75) has the same set of prime divisors.

Write an efficient algorithm for the following assumptions:

Z is an integer within the range [1..100,000];

each element of arrays A and B is an integer within the range [1..2,147,483,647].

Solution

Programming language used Python

Time spent on task 35 minutes

Notes

not defined yet

Code: 08:08:19 UTC, java, autosave

show code in pop-up

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, int[] B) {
        // write your code in Java SE 8
    }
}

Code: 08:08:30 UTC, py, autosave

show code in pop-up

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, B):
    # write your code in Python 3.6
    pass

Code: 08:08:50 UTC, py, verify, result: Passed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        if gcd_value % (a / gcd_value) == 0 and gcd_value % (b / gcd_value) == 0:
            count += 1 
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:09:09 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        

        if gcd_value % (a / gcd_value) == 0 and gcd_value % (b / gcd_value) == 0:
            count += 1 
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:09:40 UTC, py, verify, result: Passed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a / gcd_value) == 0 and gcd_value % (b / gcd_value) == 0:
            count += 1 
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:10:34 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a / gcd_value) == 0 and gcd_value % (b / gcd_value) == 0:
            count += 1 
            
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:12:24 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a / gcd_value) == 0 a gcd_value % (b / gcd_value) == 0:
            count += 1 
        
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:12:30 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a / gcd_value) ==  gcd_value % (b / gcd_value) :
            count += 1 
        
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:12:49 UTC, py, verify, result: Passed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a / gcd_value) == 0 and gcd_value % (b / gcd_value) == 0:
            count += 1 
            
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:13:48 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a // gcd_value) == 0 and gcd_value % (b / gcd_value) == 0:
            count += 1 
            
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:13:56 UTC, py, verify, result: Passed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        if gcd_value % (a // gcd_value) == 0 and gcd_value % (b // gcd_value) == 0:
            count += 1 
            
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:15:27 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)
        
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:15:58 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)

        gcd(max(a/gcd_value, b/))
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:16:14 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)

        gcd(max(a/gcd_value, b/gcd_value), min(a/gcd_value, b/gcd_value))
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:16:20 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)
        print(a/gcd_value)
        print(b/gcd_value)

        print(gcd(max(a/gcd_value, b/gcd_value), min(a/gcd_value, b/gcd_value)))
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:16:33 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        #print(gcd_value)
        #print(a/gcd_value)
        #print(b/gcd_value)

        print(gcd(max(a/gcd_value, b/gcd_value), min(a/gcd_value, b/gcd_value)))
        
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd_value)
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:17:05 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd_value)
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:18:19 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(a,gcd_value)
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:18:32 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd(a, gcd_value))
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:19:12 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd(a, gcd_value))
    #print(count)
    return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:19:16 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd(a, gcd_value))
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:19:24 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd(a, gcd_value))
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

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

show code in pop-up

1 2 3 4 5 6 7 8

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


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:20:24 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        print(gcd(a, gcd_value))
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:20:34 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(pcd_value)

        print(gcd(a, gcd_value))
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:20:39 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)

        print(gcd(a, gcd_value))
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:21:00 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)

        print(gcd(a/, gcd_value))
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:21:27 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))
        print(gcd_value)

        print(gcd(max(a/gcd_value, gcd_value)), min(a/gcd_value, gcd_value))
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:21:35 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        gcd_value = gcd(max(a, b), min(a, b))

        
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:21:48 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        pass
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:23:05 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:23:30 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:23:35 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd = 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:24:04 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = gcd()
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:24:16 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a/gcd(a, ab_gcd)
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:24:29 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a/gcd(a, ab_gcd)
        print(a_gcd_mod)
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:24:46 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a /gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:25:01 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        print(b_gcd_mod)
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        print(b_gcd_mod)

        if a_gcd_mod == 1 and b_
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:25:31 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:25:39 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:26:03 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        #print(b_gcd_mod)

        if int(a_gcd_mod) == 1 and int(b_gcd_mod) == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        #print(b_gcd_mod)

        if ina_gcd_mod) == 1 and int(b_gcd_mod) == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:26:36 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = (a / gcd(a, ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = b / gcd(b, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

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

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = gcd(a / ab_gcd , ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = gcd(b / ab_gcd, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:28:53 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = gcd(a / ab_gcd , ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = gcd(b / ab_gcd, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:29:26 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        
        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = gcd(a / ab_gcd , ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = gcd(b / ab_gcd, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:29:32 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        print(a, b)
        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = gcd(a / ab_gcd , ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = gcd(b / ab_gcd, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:29:53 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        print(a, b)
        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        a_gcd_mod = gcd(a / ab_gcd , ab_gcd)
        print(a_gcd_mod)
        b_gcd_mod = gcd(b / ab_gcd, ab_gcd)
        print(b_gcd_mod)
        #print(b_gcd_mod)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:30:26 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        print(a, b)
        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)

        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:30:30 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        print(a, b)
        ab_gcd = gcd(max(a, b), min(a,b))
        print(ab_gcd)
        
        if a_gcd_mod == 1 and b_gcd_mod == 1:
            count += 1 
    return count 
    #print(count)
    #return count 

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:30:42 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:31:13 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a,b), min(a,b))
        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:31:14 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):

        ab_gcd = gcd(max(a,b), min(a,b))
        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:35:31 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))
        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:35:44 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:35:55 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))
        
        

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:36:59 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:37:30 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:37:44 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:38:06 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))
        
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:38:15 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        la
        
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:38:46 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        last_gcd = gcd(max(a_gcd, ab_gcd), min(a_gcd))
        
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:39:00 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

 
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:40:28 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))
        
 
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:40:43 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_gcd_gcd = 
 
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:40:54 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = 
 
        print(a_gcd, b_gcd)

        print(a,b, ab_gcd)

def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:41:24 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        print(a_div_gcd, b_div_gcd)


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:41:25 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        print(a_div_gcd, b_div_gcd)


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:41:54 UTC, py, autosave

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        print(a_div_gcd, b_div_gcd)
        if a_div_gcd == 1 and b_div_gcd:
            count += 1 
    return count 


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

Code: 08:41:57 UTC, py, verify, result: Failed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        #print(a_div_gcd, b_div_gcd)
        if a_div_gcd == 1 and b_div_gcd:
            count += 1 
    return count 


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:42:09 UTC, py, verify, result: Passed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        #print(a_div_gcd, b_div_gcd)
        if a_div_gcd == 1 and b_div_gcd == 1:
            count += 1 
    return count 


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:42:14 UTC, py, verify, result: Passed

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        #print(a_div_gcd, b_div_gcd)
        if a_div_gcd == 1 and b_div_gcd == 1:
            count += 1 
    return count 


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.

Code: 08:42:17 UTC, py, final, score: 69

show code in pop-up

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

def solution(A, B):
    # write your code in Python 3.6
    count = 0
    for (a, b) in zip(A, B):
        ab_gcd = gcd(max(a,b), min(a,b))

        a_gcd = gcd(max(a / ab_gcd, ab_gcd), min(a/ ab_gcd, ab_gcd))
        b_gcd = gcd(max(b / ab_gcd, ab_gcd), min(b/ ab_gcd, ab_gcd))

        a_div_gcd = a / ab_gcd / a_gcd
        b_div_gcd = b / ab_gcd / b_gcd

        #print(a_div_gcd, b_div_gcd)
        if a_div_gcd == 1 and b_div_gcd == 1:
            count += 1 
    return count 


def gcd(N, M):
    if M == 0:
        return N 
    return gcd(M, N % M)

The submission is being evaluated.