python中的街道中央分隔带。在除第一个测试用例之外的所有测试用例上都失败_Python_Algorithm_Priority Queue_Median

python中的街道中央分隔带。在除第一个测试用例之外的所有测试用例上都失败

python algorithm

python中的街道中央分隔带。在除第一个测试用例之外的所有测试用例上都失败,python,algorithm,priority-queue,median,Python,Algorithm,Priority Queue,Median,所以我写了这段代码，它通过了第一个测试用例，其余的都失败了。然而，我似乎找不到破坏它的输入。也许是因为我盯着代码看的时间太长了，但如果有任何帮助，我将不胜感激。该算法对当前列表的最小和最大部分使用两个优先级队列。代码如下： #!/bin/python import heapq def fix(minset, maxset): if len(maxset) > len(minset): item = heapq.heappop(maxset) he

所以我写了这段代码，它通过了第一个测试用例，其余的都失败了。然而，我似乎找不到破坏它的输入。也许是因为我盯着代码看的时间太长了，但如果有任何帮助，我将不胜感激。该算法对当前列表的最小和最大部分使用两个优先级队列。代码如下：

#!/bin/python
import heapq

def fix(minset, maxset):
    if len(maxset) > len(minset):
        item = heapq.heappop(maxset)
        heapq.heappush(minset, -item)
    elif len(minset) > (len(maxset) + 1):
        item = heapq.heappop(minset)
        heapq.heappush(maxset, -item)

N = int(raw_input())

s = []
x = []

for i in range(0, N):

        tmp = raw_input()
        a, b = [xx for xx in tmp.split(' ')]
        s.append(a)
        x.append(int(b))

minset = []
maxset = []

for i in range(0, N):
    wrong = False
    if s[i] == "a":
        if len(minset) == 0:
            heapq.heappush(minset,-x[i])
        else:
            if x[i] > minset[0]:
                heapq.heappush(maxset, x[i])
            else:
                heapq.heappush(minset, -x[i])
        fix(minset, maxset)
    elif s[i] == "r":
        if -x[i] in minset:
            minset.remove(-x[i])
            heapq.heapify(minset)
        elif x[i] in maxset:
            maxset.remove(x[i])
            heapq.heapify(maxset)
        else:
            wrong = True
        fix(minset, maxset)
    if len(minset) == 0 and len(maxset) == 0:
        wrong = True

    if wrong == False:
        #Calculate median
        if len(minset) > len(maxset):
            item = - minset[0]
            print int(item)
        else:
            item = ((-float(minset[0])) + float(maxset[0])) / 2
            if item.is_integer():
                print int(item)
                continue
            out =  str(item)
            out.rstrip('0')
            print out
    else:
        print "Wrong!"

你的原稿不太清晰，所以我先把它做成面向对象的：

MedianHeapq

支持方法

rebalance（）、add（）、remove（）、size（）、median（）

。我们很想从客户机代码中隐藏成员

minset、maxset

，原因有很多：防止客户机交换、修改等。如果客户机需要查看它们，您只需编写一个访问器即可。我们还添加了一个

\uuu str\uu（）

方法，我们将使用该方法进行可视化调试，使您的生活更加轻松

还添加了易读性更改，以避免到处使用

[i]

索引，将

s，x

数组重命名为

op，val

，在

原始输入（）上添加提示，在输入阶段拒绝无效的操作。
你对中位数的实际计算让我很困惑（你什么时候想要浮点和整数？rstrip（'0'）

有点古怪），所以我重写了它，如果你想要别的东西，就改变它。对算法进行了讨论

现在，它是清晰的和独立的。也使得它可以测试。您可能在代码中出现符号错误，我不知道，稍后我会再看。接下来，我们将通过编写一些PyUnit测试用例来实现自动化。博士测试也是一种可能性。待定

好的，我想我看到了一个错误，就是关于定位中间带的草率。请记住，minset和maxset的大小不匹配可能为+/-1。因此，请更加注意中间带的确切位置

#!/bin/python
import heapq    

class MedianHeapq(object):
    def __init__(self):
        self.minset = []
        self.maxset = []        
    def rebalance(self):
        size_imbalance = len(self.maxset) - len(self.minset)
        if len(self.maxset) > len(self.minset):
        #if size_imbalance > 0:
            item = heapq.heappop(self.maxset)
            heapq.heappush(self.minset, -item)
        #elif size_imbalance < -1:
        elif len(self.minset) > (len(self.maxset) + 1):
            item = heapq.heappop(self.minset)
            heapq.heappush(self.maxset, -item)
    def add(self, value, verbose=False):
        if len(self.minset) == 0:
            heapq.heappush(self.minset,-value)
        else:
            if value > self.minset[0]:
                heapq.heappush(self.maxset, value)
            else:
                heapq.heappush(self.minset, -value)
        self.rebalance()
        if verbose: print self.__str__()
        return False
    def remove(self,value,verbose=False):
        wrong = False
        if -value in self.minset:
            minset.remove(-value)
            heapq.heapify(self.minset)
        elif value in maxset:
            maxset.remove(value)
            heapq.heapify(self.maxset)
        else:
            wrong = True
        self.rebalance()
        if verbose: print self.__str__()
        return wrong
    def size(self):
        return len(self.minset)+len(self.maxset)
    def median(self):
        if len(self.minset) > len(self.maxset):
            item = - self.minset[0]
            return int(item)
        else:
            item = (-self.minset[0] + self.maxset[0]) / 2.0
            # Can't understand the intent of your code here: int, string or float?
            if item.is_integer():
                return int(item)
            #    continue # intent???
            else:
               return item
            # The intent of this vv seems to be round floats and return '%.1f' % item ?? 
            #out =  str(item)
            #out.rstrip('0') # why can't you just int()? or // operator?
            #return out


    def __str__(self):
        return 'Median: %s Minset:%s Maxset:%s' % (self.median(), self.minset,self.maxset)

# Read size and elements from stdin
N = int(raw_input('Size of heap? '))
op = []
val = []
while(len(val)<N):
        tmp = raw_input('a/r value : ')
        op_, val_ = tmp.split(' ')
        if op_ not in ['a','r']: # reject invalid ops
            print 'First argument (operation) must be a:Add or r:Remove! '
            continue
        op.append(op_)
        val.append(int(val_))

mhq = MedianHeapq()
for op_,val_ in zip(op,val): # use zip to avoid indexing with [i] everywhere
    wrong = False
    if op_ == 'a':
        wrong = mhq.add(val_)
    elif op_ == 'r':
        wrong = mhq.remove(val_)

    assert (mhq.size()>0), 'Heap has zero size!'

    assert (not wrong), 'Heap structure is wrong!'

    if not wrong:
        print mhq.__str__()

#/bin/python
进口heapq
类MedianHeapq（对象）：
定义初始化（自）：
self.minset=[]
self.maxset=[]
def再平衡（自我）：
大小不平衡=len（self.maxset）-len（self.minset）
如果len（self.maxset）>len（self.minset）：
#如果尺寸不平衡>0：
item=heapq.heapop（self.maxset）
heapq.heappush（self.minset，-项）
#elif尺寸不平衡<-1：
elif len（self.minset）>（len（self.maxset）+1）：
项目=heapq.heapop（self.minset）
heapq.heappush（self.maxset，-项）
def add（self、value、verbose=False）：
如果len（self.minset）==0：
heapq.heappush（self.minset，-值）
其他：
如果值>self.minset[0]：
heapq.heappush（self.maxset，value）
其他：
heapq.heappush（self.minset，-值）
自我再平衡
如果详细：打印自我
返回错误
def删除（self、value、verbose=False）：
错误的
if-self.minset中的值：
minset.remove（-value）
heapq.heapify（self.minset）
maxset中的elif值：
maxset.remove（值）
heapq.heapify（self.maxset）
其他：
错=真
自我再平衡
如果详细：打印自我
返回错误
def大小（自身）：
返回len（self.minset）+len（self.maxset）
def中位数（自我）：
如果len（self.minset）>len（self.maxset）：
item=-self.minset[0]
返回整数（项目）
其他：
item=（-self.minset[0]+self.maxset[0]）/2.0
#无法理解此处代码的意图：int、string或float？
如果item.is_integer（）：
返回整数（项目）
#继续#意图？？？
其他：
退货项目
#此vv的目的似乎是圆浮点数并返回“%.1f”%item？？
#out=str（项目）
#out.rstrip（'0'）#为什么不能只使用int（）？还是接线员？
#返回
定义（自我）：
返回“中值：%s最小集：%s最大集：%s%”（self.Median（），self.Minset，self.Maxset）
#从stdin读取大小和元素
N=int（原始输入（'堆大小？'））
op=[]
val=[]
而（len（val）0），“堆的大小为零！”
断言（没有错），“堆结构错误！”
如果没有错：
打印mhq.\uuuuu str\uuuuuuuuuu（）

您的原稿不太清晰，因此首先我将其设置为面向对象：

MedianHeapq