Problem p03201 (python)

Fixed submission:
import bisect
N=int(input())
A=list(map(int,input().split()))
A.sort()
A.append(999999999999999)
B=[]
for i in range(1,35):
    B.append(2**i)
ans=0
for i in range(N):
    if A[N-1-i]==int(A[N-1-i]):
        for j in range(len(B)):
            if A[N-1-i]<B[j]:
                break
        if A[bisect.bisect_left(A,B[j]-A[N-1-i])]==B[j]-A[N-1-i]:
            if bisect.bisect_left(A,B[j]-A[N-1-i])<N-1-i:
                A[bisect.bisect_left(A,B[j]-A[N-1-i])]-=0.1
                A[N-1-i]+=0.1
                ans+=1
print(ans)

Buggy submission (verdict: Runtime Error):
import bisect

N=int(input())
A=list(map(int,input().split()))
A.sort()
B=[]
for i in range(1,10):
    if 2**i>2*(10**9):
        break
    else:
        B.append(2**i)
B.append(2**(i+1))
ans=0
#print(B)
for i in range(N):
    X=bisect.bisect_left(B,A[N-1-i])
    if B[X]==A[N-1-i]:
        X+=1
    #print(X)
    if B[X]==2*A[N-1-i]:
        #print(B[X],A[N-i])
        A[N-1-i]+=0.3
        #print(A[bisect.bisect_left(A,B[X]-A[N-i]+0.3)],B[X]-A[N-i]+0.3)
        if A[bisect.bisect_left(A,B[X]-A[N-1-i]+0.3)]==B[X]-A[N-1-i]+0.3:
            ans+=1
            #print(B[X],i)
            #print(B[X])
            A[bisect.bisect_left(A,B[X]-A[N-1-i]-0.2)]-=0.1
    elif A[bisect.bisect_left(A,B[X]-A[N-1-i])]==B[X]-A[N-1-i]:
        ans+=1
        #print(B[X],i)
        A[bisect.bisect_left(A,B[X]-A[N-1-i])]-=0.1
        A[N-1-i]+=0.2
print(ans)
#print(A)
#print(B)

Buggy submission (verdict: Runtime Error):
import bisect

N=int(input())
A=list(map(int,input().split()))
A.sort()
B=[]
for i in range(1,100):
    if 2**i>2*(10**9):
        break
    else:
        B.append(2**i)
B.append(2**(i+1))
ans=0
#print(B)
for i in range(N):
    X=bisect.bisect_left(B,A[N-1-i])
    if B[X]==A[N-1-i]:
        X+=1
    #print(X)
    if A[bisect.bisect_left(A,B[X]-A[N-1-i])]==B[X]-A[N-1-i]:
        ans+=1
        A[bisect.bisect_left(A,B[X]-A[N-1-i])]-=0.1
        A[N-1-i]-=0.1
print(ans)

Buggy submission (verdict: Runtime Error):
import bisect

N=int(input())
A=list(map(int,input().split()))
A.sort()
B=[]
for i in range(1,10):
    if 2**i>2*(10**9):
        break
    else:
        B.append(2**i)
B.append(2**(i+1))
ans=0
#print(B)
for i in range(N):
    X=bisect.bisect_left(B,A[N-1-i])
    #print(X)
    if A[bisect.bisect_left(A,B[X]-A[N-1-i])]==B[X]-A[N-1-i]:
        ans+=1
        A[bisect.bisect_left(A,B[X]-A[N-1-i])]-=0.1
print(ans)

Buggy submission (verdict: Runtime Error):
N=int(input())

A=[0 for i in range(10**5+10)]

a=list(map(int,input().split()))

for i in range(len(a)):
    A[a[i]]+=1
    
ans=0

for j in range(len(A)):
    if A[len(A)-1-j]==0:
        pass
    else:
        t=0
        while (len(A)-j-1)>(2**t):
            t+=1
        if A[(2**t)-(len(A)-1-j)]>0:
            ans+=min(A[len(A)-1-j],A[2**t-(len(A)-1-j)])
            A[2**t-(len(A)-1-j)]-=min(A[len(A)-1-j],A[2**t-(len(A)-1-j)])
print(ans)

Buggy submission (verdict: Runtime Error):
import bisect

N=int(input())

E=[]
O=[]

a=list(map(int,input().split()))

for i in range(len(a)):
    if a[i]%2==0:
        E.append(a[i])
    else:
        O.append(a[i])
        
E.sort()
O.sort()

ans=0
for e in range(len(E)):
    t=0
    while E[len(E)-1-e]>2**t:
       t=t+1
       #print(t)
    if E[bisect.bisect_left(E,2**t-E[len(E)-1-e])]+E[len(E)-1-e]==2**t:
        ans+=1
        del E[bisect.bisect_left(E,2**t-E[len(E)-1-e])]
        
for o in range(len(O)):
    t=0
    while O[len(O)-1-o]>2**t:
       t=t+1
       #print(t)
    if O[bisect.bisect_left(O,2**t-O[len(O)-1-o])]+O[len(O)-1-o]==2**t:
        ans+=1
        del O[bisect.bisect_left(O,2**t-O[len(O)-1-o])]
print(ans)