Python CodingBat sum67：为什么这个解决方案是错误的？

我正在处理以下codingbat问题：

返回数组中数字的总和，但忽略以6开头并延伸到下一个7的数字部分除外（每6后面至少有一个7）。返回0表示没有数字

sum67([1, 2, 2]) → 5
sum67([1, 2, 2, 6, 99, 99, 7]) → 5
sum67([1, 1, 6, 7, 2]) → 4

我的解决办法是：

def sum67(nums):
    sum = 0 
    throwaway = 0
    for i in range(len(nums)):
        if throwaway == 0:
            if nums[i] == 6:
                throwaway = 1
        elif throwaway == 1 and i > 0 and nums[i-1] == 7:
            throwaway = 0
        if throwaway == 0:
            sum += nums[i]
    return sum

---

我完全知道这不是最好的解决方案，但我只是想知道为什么这是错误的。你能解释一下为什么这是错误的，在哪种情况下它给出了错误的结果吗？

好吧，你的程序有一个bug。检查以下各项的结果：

print sum67([1,2,5])
print sum67([1,2,6,5,7])
print sum67([1,2,6,5,7,6,7])

这将打印：

8
3
16 <-- wrong

---

此外，如果出于某些模糊的原因不需要使用索引，则可以直接迭代列表中的元素（

for element in list:…

）。

以下是我对该问题的解决方案。如前所述，问题是在7之后立即出现6。我用一种稍微不同的方式解决了这个问题，所以我想我应该发布它

def sum67(nums):
  total = 0
  i=0  
  while i < len(nums):
    if nums[i] == 6:
      while nums[i] != 7:
        i+=1
      i+=1
    if i<len(nums) and nums[i]!=6:  
      total+=nums[i]
      i+=1
  return total

def sum67（nums）：
总数=0
i=0
而我public int sum67（int[]nums）{
整数和=0；
对于（int i=0；i，以下是我的解决方案，供您参考：

def sum67(nums):
flag=False
sum=0

for num in nums:
    if(num==6):                  #Turn the flag on if the number is 6
        flag=True
        continue
    if(num==7 and flag is True): #Turn the flag Off when 7 is seen after 6
        flag=False
        continue
    if(flag is False):           #Keep on adding the nums otherwise
       sum+=num
return sum

我的解决方案：

def sum67(nums):
    result = 0
    flag = True
    for num in nums:
        if num == 6:
            flag = False
        if flag:
            result += num
        if num == 7:
            flag = True
    return result

def sum67(arr):
    sum = 0
    tmp = 0
    for n in arr:
        if n == 6:
            tmp = 6
            continue
        if tmp == 6:
            if n == 7:
                tmp = 0
                continue
            elif arr[-1] == 7:
                break
            else:
                continue
        sum += n
    return sum

我知道这不是最好的解决方案，但我想与大家分享：
def检测67（nums）：
计数=nums。计数（6）
pos6=0
pos7=0
sum1=[]
对于范围内的i（len（nums））：
sum1.append（nums[i]）
#如果我只使用sum1=nums，它们使用相同的内存位置。
#打印（“Count=”，Count）
对于范围内的i（计数）：
pos6=sum1.索引（6）
pos7=sum1.索引（7）
如果pos7这是我对@TheNeophyte代码的编辑。我喜欢这个解决方案，因为这就是我解决问题的方法。唯一的编辑实际上是去掉

if i<len(nums) and nums[i]!=6:

如果我这是我的6行回答。希望这有帮助

def summer_67(arr):
    s = 0
    for x in arr:
        if x not in range(6,7+1):
            s = s + x
    return s


嗯，你可以使用嵌套循环

def sum67(nums):
    s=0
    flag=1
    for n in nums:
        while flag:
            if n!=6:
                s+=n
                break
            else:
                flag=0
        while not flag:
            if n!=9:
                break
            else:
                flag=1
    return s          

只需补充一点，如果最后一个元素是7，则不需要遍历每个元素。问题说明“忽略以6开头并延伸到下一个7的数字部分（每6后面至少有一个7）”。找到6后，您只需检查最后一个元素是否为7，如果是，则只需将其分解并返回总和；否则，您可以继续检查其余元素。这在处理数组中大量元素时非常有用。
例[1,2,2,6,99,99,2,99,99,2,99,99,2,99,99,2,99,99,7]

我的解决方案：

def sum67(nums):
    result = 0
    flag = True
    for num in nums:
        if num == 6:
            flag = False
        if flag:
            result += num
        if num == 7:
            flag = True
    return result

def sum67(arr):
    sum = 0
    tmp = 0
    for n in arr:
        if n == 6:
            tmp = 6
            continue
        if tmp == 6:
            if n == 7:
                tmp = 0
                continue
            elif arr[-1] == 7:
                break
            else:
                continue
        sum += n
    return sum

我的解决方案我知道这是非常可读的，但不是最好的代码：

def sum67(nums):
  offcount = False
  sum = 0 
  for i in range(len(nums)):
    if offcount == False:
      if nums[i] == 6:
        offcount = True
      else:
        sum = sum + nums[i]
    else:
      if nums[i] == 7 :
        offcount = False
  return sum

我希望这有帮助：）

def sum67（nums）：
当nums.count（6）>=1时：
列表=（nums[0:nums.index（6）]）+（nums[nums.index（7）+1:len（nums）]）
nums=列表
回报总额（nums）
没有while和for循环的简化代码：

    def summer_69(arr):
        pos6 = 0;
        pos9 = 0;
        newArr = [];
        if 6 in arr:
            pos6 = arr.index(6);
        if 9 in arr: 
            pos9 = arr.index(9);
        if 6 in arr and 9 in arr : 
            newArr =  arr[0:pos6] + arr[pos9+1:len(arr)];
        else:
            newArr = arr;
    return sum(newArr);
    pass

也许是一种更为Pythonian的方法

def sum67(arr):
    if (6 in arr):
        i1 = arr.index(6)
        i2 = arr[i1:].index(7)
        res = sum(arr[0:i1]+arr[i1+i2+1:])
    else:
        res = sum(arr)
    return res

这是我的13行答案，它使用列表索引位置排除每个[6..7]对所包含的值

技术：减去排除元素的（和）后返回数组元素的和

def sum67（nums）：
idx_列表=[]
对于范围内的i（len（nums））：
如果nums[i]==6：
c#u 6=指数位置为6
j=c_6+1#计数器，用于查找7的索引位置
而nums[j]！=7:#在列表中发现7时停止搜索
j+=1
c_7=j#指数位置为7
idx_list+=列表（范围（c_6，c_7+1））#要排除的元素的索引位置列表
idx_main=list（set（idx_list））#set（）删除循环时捕获的重复索引位置
del_val=[nums[i]表示idx_main中的i]
返回和（nums）-和（del_val）
def sum67（nums）：
总和=0
sum6=0
对于n（单位：nums）：
总和+=n
如果nums.count（6）>=1：
a=单位索引（6）
b=单位指数（7）+1
nums67=nums[a:b]
对于nums67中的i：
sum6+=i
返回和-sum6
这可能不是最好的解决方案，但它很简单，在所有情况下都给出了正确的输出

def sum67(nums):
  sum = 0
  i = 0
  while( i < len(nums)):
    if nums[i] == 6:
       while(nums[i] != 7):
         i += 1
    else:
      sum += nums[i]
    i += 1
  return sum

def sum67（nums）：
总和=0
i=0
而(i
使用迭代器，只需一个短而有效的（O（n）时间，O（1）空间）替代方案：

def sum67(nums):
    it = iter(nums)
    return sum(x for x in it if x != 6 or 7 not in it)

这主要是对值求和。但每当遇到6时，不在其中的
7将消耗所有值，直到下一个7为止（这是错误的，因此从该6到该7的所有值都不会计入和）。
这可能会帮助您：

def sum_67(arr):
    while 6 in arr:
        del arr[arr.index(6):arr.index(7)+1]
    return sum(arr)

我的方法是建立一个新的列表，该列表只包含有效的部分，即不以6开头，以7结尾的部分，对应的6。然后我简单地计算了新列表的元素总和。在codingbat练习平台中工作得非常好

def sum67（nums）：
lst=[]#在丢弃无效段后保留结果
在nums中为6时：#继续，直到在nums段中找不到更多的6
#找到前6个
idx6=nums.索引（6）
#生成列表，最多但不包括前6个
lst+=nums[：idx6]
#找到下一个7
idx7=nums[idx6:]索引（7）#这将与nums[idx6:]相关
#切片
idx=idx6+idx7#7 w.r.t nums的绝对位置
nums=nums[idx+1:]#从7的位置切到末端
lst+=nums#负责处理过去7天之后的任何剩菜
返回和（lst）

可以压缩为更少的代码行，但我想保持代码的可读性。我想知道是否有一种递归的方法来解决这个问题。正在努力

感谢大家提供了出色的备选解决方案
您是否知道“我在范围内”（len（nums））
“我完全知道这不是最好的解决方案”--批评他的风格没有什么意义。除了不是很“pythonic”之外，没有什么可以批评的
def sum67(arr):
    for n in range (0, len(arr)):
        if arr[n] == 6:
            Sum1 = sum(arr[0:n])
            print ("Before 6 Sum Numbers:", Sum1)
    for k in range (0, len(arr)):
        if arr[k] ==7:
            Sum2 = sum(arr[(k)+1:])
            print ("After 7 Sum Numbers:", Sum2)
    if 6 and 7 in arr:
        print("Last Result")
        return (Sum1+Sum2)
    else:
        print("Last Result")
        return sum(arr)

    def summer_69(arr):
        pos6 = 0;
        pos9 = 0;
        newArr = [];
        if 6 in arr:
            pos6 = arr.index(6);
        if 9 in arr: 
            pos9 = arr.index(9);
        if 6 in arr and 9 in arr : 
            newArr =  arr[0:pos6] + arr[pos9+1:len(arr)];
        else:
            newArr = arr;
    return sum(newArr);
    pass

def sum67(arr):
    if (6 in arr):
        i1 = arr.index(6)
        i2 = arr[i1:].index(7)
        res = sum(arr[0:i1]+arr[i1+i2+1:])
    else:
        res = sum(arr)
    return res

def sum67(nums):
  sum = 0
  i = 0
  while( i < len(nums)):
    if nums[i] == 6:
       while(nums[i] != 7):
         i += 1
    else:
      sum += nums[i]
    i += 1
  return sum

def sum67(nums):
    it = iter(nums)
    return sum(x for x in it if x != 6 or 7 not in it)

def sum67(nums):
    c=0
    state=True
    for i in nums:
        if state:
            if i==6:
                state=False
            else:
                c+=i

        else:
            if i==7:
                state=True
    return c

def sum_69(arr):
    x=arr.index(6)
    y=arr.index(9)
    if 6  not in arr:
        return sum(arr)
    else:
        sum1=arr[:x]
        sum2=arr[y+1:]
        sum3=sum1+sum2
        return sum(sum3)

def sum_67(arr):
    while 6 in arr:
        del arr[arr.index(6):arr.index(7)+1]
    return sum(arr)

def sum67(nums):
  
  cnt = 0
  ignore = False
  for num in nums:
    if not ignore and num == 6:
      ignore = True
    
    if not ignore:
      cnt = cnt + num

    if ignore and num == 7:
      ignore = False
  
  return cnt