Problem p03201 (python)

Fixed submission:
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
c = Counter(a)

ans = 0
for i in a:
    if c[i] == 0:
        continue
    c[i] -= 1
    k = 1<<i.bit_length()
    j = k-i
    if j in c and c[j] > 0:
        ans += 1
        c[j] -= 1
print(ans)

Buggy submission (verdict: Runtime Error):
import math
N=int(input())
a=list(map(int,input().split()))
a_=sorted(a,key=lambda x:-x)
ans=0
while len(a_)>1:#1になった時点で終わり。
    x,y=0,0
    t=int(math.log2(a_[0]))+1
    if 2**(t-1)==a_[0]:
    #これは、2,4,8とか2のべき乗だけが引っかかる条件
        if a_[0]==a_[1]:
        #2のべきでも、きちんと2個存在するならおｋ
            a_.remove(a_[0])
            a_.remove(a_[0])
            ans+=1
        else:
            a_.remove(a_[0])
    else:
        x+=a_[0]
        y+=2**t-a_[0]
        if y in a_:
        #上で被りうる奴は排除できている。
            ans+=1
            a_.remove(x)
            a_.remove(y)
        else:
            a_.remove(a_[0])
print(ans)

Buggy submission (verdict: Runtime Error):
class Node:
    def __init__(self,data):
        self.data=data
        self.left=None
        self.right=None
class BST:
    def __init__(self,number_list):
        self.root=None
        for node in number_list:
            self.insert(node)
    def insert(self,data):
        n=self.root
        if n is None:
            self.root=Node(data)
            return
        else:
            while True:#これ抜けてた。やばい。
                entry=n.data
                if data<entry:
                    if n.left is None:
                        n.left=Node(data)
                        return
                    n=n.left
                elif data>entry:
                    if n.right is None:
                        n.right=Node(data)
                        return
                    n=n.right
                else:
                    n.data=data
                    return
    def search(self,target):
        n = self.root
        if n is None:
            return None
        else:#深さ優先探索
            lst = []
            lst.append(n)
            while len(lst) > 0:
                node = lst.pop()
                if node is None:
                    return False
                elif node.data == target:
                    self.node_recreate(node)
                    node=None
                    return True
                elif node.data < target :
                    lst.append(node.right)
                elif node.data > target:
                    lst.append(node.left)
            return False
        
    def node_recreate(self,node):
        #ノード再作成機能を装着
        num_lst=[]
        node_lst=[node]
        while len(node_lst)>0:
            node_=node_lst.pop()
            if node_.right is not None:
                node_lst.append(node_.right)
                num_lst.append(node_.right.data)
            if node_.left is not None:
                node_lst.append(node_.left)
                num_lst.append(node_.left.data)
        for num in num_lst:
            self.insert(num)
            
                
    
import math
N=int(input())
a=list(map(int,input().split()))
t_max=int(math.log2(max(a)*2)+1)
ans=0
bst=BST(a)
for t in range(t_max,0,-1):
    i=0
    while i<len(a):
    #forだとout of rangeしてしまうので。
        x,y=0,0
#         bst=BST(a)#二分木も更新しないと。
#更新を削除に変更。大分計算回数は減るはず。
        if bst.search(2**t-a[i]):
            if a[i]!=2**t-a[i]:
                #同じだったらNG
                ans+=1
                x+=a[i]
                y+=2**t-a[i]
                #IDを共有すると、インデックスがずれる。
                a.remove(x)
                bst.search(x)#削除を兼ねて
                print(bst.search(y))
                print(x,y)
                a.remove(y)
            else:
                i+=1#これ忘れてた....sampleも通らないよ
        else:
            i+=1 #ペアが見つからなかったときだけ進めばいい。
print(ans)

Buggy submission (verdict: Runtime Error):
class Node:
    def __init__(self,data):
        self.data=data
        self.left=None
        self.right=None
class BST:
    def __init__(self,number_list):
        self.root=None
        for node in number_list:
            self.insert(node)
    def insert(self,data):
        n=self.root
        if n is None:
            self.root=Node(data)
            return
        else:
            while True:#これ抜けてた。やばい。
                entry=n.data
                if data<entry:
                    if n.left is None:
                        n.left=Node(data)
                        return
                    n=n.left
                elif data>entry:
                    if n.right is None:
                        n.right=Node(data)
                        return
                    n=n.right
                else:
                    n.data=data
                    return
    def search(self,target):
        n = self.root
        if n is None:
            return None
        else:#深さ優先探索
            lst = []
            lst.append(n)
            while len(lst) > 0:
                node = lst.pop()
                if node is None:
                    return False
                if node.data == target:
                    self.node_recreate(node)
                    return True
                elif node.data < target :
                    lst.append(node.right)
                elif node.data > target:
                    lst.append(node.left)
            return False
        
    def node_recreate(self,node):
        #ノード再作成機能を装着
        num_lst=[]
        node_lst=[node]
        while len(node_lst)>0:
            node_=node_lst.pop()
            if node_.right is not None:
                node_lst.append(node_.right)
                num_lst.append(node_.right.data)
            if node_.left is not None:
                node_lst.append(node_.left)
                num_lst.append(node_.left.data)
        node=None
        for num in num_lst:
            self.insert(num)
            
                
    
import math
N=int(input())
a=list(map(int,input().split()))
t_max=int(math.log2(max(a)*2)+1)
ans=0
bst=BST(a)
for t in range(t_max,0,-1):
    i=0
    while i<len(a):
    #forだとout of rangeしてしまうので。
        x,y=0,0
#         bst=BST(a)#二分木も更新しないと。
#更新を削除に変更。大分計算回数は減るはず。
        if bst.search(2**t-a[i]):
            if a[i]!=2**t-a[i]:
                #同じだったらNG
                ans+=1
                x+=a[i]
                y+=2**t-a[i]
                #IDを共有すると、インデックスがずれる。
                a.remove(x)
                bst.search(x)#削除を兼ねて
                a.remove(y)
            else:
                i+=1#これ忘れてた....sampleも通らないよ
        else:
            i+=1 #ペアが見つからなかったときだけ進めばいい。
print(ans)

Buggy submission (verdict: Runtime Error):
class Node:
    def __init__(self,data):
        self.data=data
        self.left=None
        self.right=None
class BST:
    def __init__(self,number_list):
        self.root=None
        for node in number_list:
            self.insert(node)
    def insert(self,data):
        n=self.root
        if n is None:
            self.root=Node(data)
            return
        else:
            while True:#これ抜けてた。やばい。
                entry=n.data
                if data<entry:
                    if n.left is None:
                        n.left=Node(data)
                        return
                    n=n.left
                elif data>entry:
                    if n.right is None:
                        n.right=Node(data)
                        return
                    n=n.right
                else:
                    n.data=data
                    return
    def search(self,target):
        n = self.root
        if n is None:
            return None
        else:#深さ優先探索
            lst = []
            lst.append(n)
            while len(lst) > 0:
                node = lst.pop()
                if node is None:
                    return False
                if node.data == target:
                    self.node_recreate(node)
                    return True
                elif node.data < target :
                    lst.append(node.right)
                elif node.data > target:
                    lst.append(node.left)
            return False
        
    def node_recreate(self,node):
        #ノード再作成機能を装着
        num_lst=[]
        node_lst=[node]
        while len(node_lst)>0:
            node_=node_lst.pop()
            if node_.right is not None:
                node_lst.append(node_.right)
                num_lst.append(node_.right.data)
            if node_.left is not None:
                node_lst.append(node_.left)
                num_lst.append(node_.left.data)
        node=None
        for num in num_lst:
            self.insert(num)
            
                
    
import math
N=int(input())
a=list(map(int,input().split()))
t_max=int(math.log2(max(a)*2)+1)
ans=0
bst=BST(a)
for t in range(t_max,0,-1):
    i=0
    while i<len(a):
    #forだとout of rangeしてしまうので。
        x,y=0,0
#         bst=BST(a)#二分木も更新しないと。
#更新を削除に変更。大分計算回数は減るはず。
        if bst.search(2**t-a[i]):
            if a[i]!=2**t-a[i]:
                #同じだったらNG
                ans+=1
                x+=a[i]
                y+=2**t-a[i]
                #IDを共有すると、インデックスがずれる。
                a.remove(x)
                bst.search(x)#削除を兼ねて
                a.remove(y)
        else:
            i+=1 #ペアが見つからなかったときだけ進めばいい。
print(ans)

Buggy submission (verdict: Runtime Error):
import math
N=int(input())
a=list(map(int,input().split()))
a_=sorted(a)
t_max=int(math.log2(a_[-1]+a_[-2])+1)
ans=0
for t in range(t_max,0,-1):
    i=0
    while i<len(a_):
        x,y=0,0
        if 2**t-a_[i] in a_:
            if a[i]!=2**t-a[i]:
                ans+=1
                x+=a_[i]
                y+=2**t-a_[i]
                a_.remove(x)
                a_.remove(y)
        else:
            i+=1
print(ans)