Problem p03061 (python)

Fixed submission:
import sys
input = sys.stdin.readline
import math
from fractions import gcd
import operator
from functools import reduce
from itertools import accumulate

def read():
    N = int(input().strip())
    A = list(map(int, input().strip().split()))
    return N, A


def prime_factorization_preprocess(n):
    """
    エラトステネスの篩を用いて、sqrt(n)以下の素数を列挙する
    """
    m = math.floor(math.sqrt(n)) + 1
    primes = []
    is_prime = [True for i in range(m)]
    for i in range(2, m):
        if is_prime[i]:
            primes.append(i)
            for j in range(i+i, m, i):
                is_prime[j] = False
    return primes


def prime_factorization(x, primes):
    """
    試し割り法により、数値の素因数分解を求める
    """
    factors = defaultdict(int)
    for p in primes:
        if x % p == 0:
            n = 0
            while x % p == 0:
                x //= p
                n += 1
            factors[p] = n
    return factors


def solve(N, A, AMAX = 10**9, INF=10**9):
    sl = list(accumulate(A, gcd))
    sr = list(reversed(list(accumulate(reversed(A), gcd))))
    max_gcd = sl[-1]
    for i in range(N):
        # gcdの単位元は0
        v = 0
        if i > 0:
            v = gcd(v, sl[i-1])
        if i < N-1:
            v = gcd(v, sr[i+1])
        max_gcd = max(max_gcd, v)
    return max_gcd


if __name__ == '__main__':
    inputs = read()
    print(solve(*inputs))

Buggy submission (verdict: Runtime Error):
import sys
input = sys.stdin.readline
import math
import operator
from functools import reduce
from itertools import accumulate

def read():
    N = int(input().strip())
    A = list(map(int, input().strip().split()))
    return N, A


def prime_factorization_preprocess(n):
    """
    エラトステネスの篩を用いて、sqrt(n)以下の素数を列挙する
    """
    m = math.floor(math.sqrt(n)) + 1
    primes = []
    is_prime = [True for i in range(m)]
    for i in range(2, m):
        if is_prime[i]:
            primes.append(i)
            for j in range(i+i, m, i):
                is_prime[j] = False
    return primes


def prime_factorization(x, primes):
    """
    試し割り法により、数値の素因数分解を求める
    """
    factors = defaultdict(int)
    for p in primes:
        if x % p == 0:
            n = 0
            while x % p == 0:
                x //= p
                n += 1
            factors[p] = n
    return factors


def solve(N, A, AMAX = 10**9, INF=10**9):
    sl = list(accumulate(A, math.gcd))
    sr = list(reversed(list(accumulate(reversed(A), math.gcd))))
    max_gcd = sl[-1]
    for i in range(N):
        # gcdの単位元は0
        v = 0
        if i > 0:
            v = math.gcd(v, sl[i-1])
        if i < N-1:
            v = math.gcd(v, sr[i+1])
        max_gcd = max(max_gcd, v)
    return max_gcd


if __name__ == '__main__':
    inputs = read()
    print(solve(*inputs))

Buggy submission (verdict: Runtime Error):
import math
from itertools import combinations, chain

def gcd(numbers):
  gcds = numbers.__next__()
  for x in numbers:
    gcds = math.gcd(gcds, x)
  return gcds

def main():
  N = int(input().strip())
  A = list(map(int, input().strip().split()))
  
  gcds = []
  for i in range(N):
    gcds.append(gcd(chain(A[:i], A[i+1:])))
  
  print(max(gcds))
 
if __name__ == '__main__':
  main()

Buggy submission (verdict: Runtime Error):
import math
from itertools import combinations

def gcd(x):
  gcds = x[0]
  for i in range(1, len(x)):
    gcds = math.gcd(gcds, x[i])
  return gcds

def main():
  N = int(input().strip())
  A = list(map(int, input().strip().split()))
  
  gcds = []
  for i in range(N):
    gcds.append(gcd([*A[:i], *A[i+1:]]))
  
  print(max(gcds))
 
if __name__ == '__main__':
  main()

Buggy submission (verdict: Runtime Error):
import math

def leave_one_out(array):
  max_gcd = -1
  for i in range(len(array)):
    if i == 0:
      gcd = array[1]
      k = 2
    elif i == 1:
      gcd = array[0]
      k = 2
    else:
      gcd = array[0]
      k = 1
    for j in range(k, len(array)):
      if i == j:
        continue
      gcd = math.gcd(array[j], gcd)
    max_gcd = max(gcd, max_gcd)
  return max_gcd

def main():
  N = int(input().strip())
  A = list(map(int, input().strip().split()))
  print('%d' % leave_one_out(A))

if __name__ == '__main__':
  main()

Buggy submission (verdict: Runtime Error):
import math

def leave_one_out(array):
  max_gcd = -1
  for i in range(len(array)):
    if i == 0:
      gcd = array[1]
      k = 2
    elif i == 1:
      gcd = array[0]
      k = 2
    else:
      gcd = array[0]
      k = 1
    for j in range(k, len(array)):
      if i == j:
        continue
      gcd = math.gcd(array[j], gcd)
    max_gcd = max(gcd, max_gcd)
  return max_gcd

def main():
  N = int(input().strip())
  A = list(map(int, input().strip().split()))
  print(leave_one_out(A))

if __name__ == '__main__':
  main()

Buggy submission (verdict: Runtime Error):
import math
from itertools import combinations

def leave_one_out(array):
  max_gcd = 0
  for i in range(len(array)):
    if i == 0:
      gcd = array[1]
      k = 2
    elif i == 1:
      gcd = array[0]
      k = 2
    else:
      gcd = array[0]
      k = 1
    for j in range(k, len(array)):
      if i == j:
        continue
      gcd = math.gcd(array[j], gcd)
    max_gcd = max(gcd, max_gcd)
  return max_gcd

def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i:
        divisors.append(n//i)
  return divisors

def main():
  N = int(input().strip())
  A = list(map(int, input().strip().split()))
  #N = int(1e3)
  #A = [int(1e9)] * N
  divs_dict = dict()
  
  print(leave_one_out(A))
  """
  for a in A:
    divs = make_divisors(a)
    for d in divs:
      if d in divs_dict.keys():
        divs_dict[d] += 1
      else:
        divs_dict[d] = 1
  
  result_divs = []
  for k in divs_dict.keys():
    if divs_dict[k] >= N-1:
      result_divs.append(k)
  print(sorted(result_divs)[-1])
  """

if __name__ == '__main__':
  main()