Question

如何确定列表中是否包含3个偶数或3个奇数值？

示例列表（真，假，真）：

[2, 1, 3, 5]
[2, 1, 2, 5]
[2, 4, 2, 5]

最近的代码：

evenOdd = []

while True: 
    try:
        n = int(input())
        evenOdd.append(n)
    except:
        break

for x in evenOdd:
   if x % 2 == 0:
       print("True")

Answer 1

这是一些代码。与迭代索引相比，这被认为是“ pythonic”的，它使用zip函数遍历对三元组。如果列表中的项目少于三个，则会出现错误-您可以添加该错误检查。当其中一个可迭代项的值用完时，zip函数将停止，这正是我们在这里想要的。

def three_evens_or_odds(alist):
    for a, b, c in zip(alist, alist[1:], alist[2:]):
        if (((a & 1) and (b & 1) and (c & 1)) or
            ((a & 1 == 0) and (b & 1 == 0) and (c & 1 == 0))):
            return True
    return False

print(three_evens_or_odds([2, 1, 3, 5]))
print(three_evens_or_odds([2, 1, 2, 5]))
print(three_evens_or_odds([2, 4, 2, 5]))

或者，甚至更短（从@jdehesa借来一个我自己想到的想法，因此像我一样赞扬他的回答），

def three_evens_or_odds(alist):
    for a, b, c in zip(alist, alist[1:], alist[2:]):
        if a & 1 == b & 1 == c & 1:
            return True
    return False

print(three_evens_or_odds([2, 1, 3, 5]))
print(three_evens_or_odds([2, 1, 2, 5]))
print(three_evens_or_odds([2, 4, 2, 5]))

打印出来的是

True
False
True

Answer 2

您可以使用itertools.groupby()：

from itertools import groupby

def check_list(lst):
    for k, g in groupby(lst, key=lambda x: x % 2):
        if len(list(g)) == 3:
            return True
    return False    

print(check_list([2, 1, 3, 5]))  # True
print(check_list([2, 1, 2, 5]))  # False
print(check_list([2, 4, 2, 5]))  # True

可以很容易地将其调整为任何团体人数。

Answer 3

您可以以三个为单位遍历数字列表：

def hasThreeContiguousEvenOrOdd(numbers):
    for i in range(len(numbers) - 2):
        a, b, c = numbers[i:i + 3]
        if a % 2 == 0 and b % 2 == 0 and c % 2 == 0:
            return True
        elif a % 2 == 1 and b % 2 == 1 and c % 2 == 1:
            return True
    return False

numbers1 = [2, 1, 3, 5]
numbers2 = [2, 1, 2, 5]
numbers3 = [2, 4, 2, 5]

print(numbers1, hasThreeContiguousEvenOrOdd(numbers1))
print(numbers2, hasThreeContiguousEvenOrOdd(numbers2))
print(numbers3, hasThreeContiguousEvenOrOdd(numbers3))

输出：

[2, 1, 3, 5] True
[2, 1, 2, 5] False
[2, 4, 2, 5] True

如果您想成为惯用语言或“ pythonic”，则可以改进代码，例如执行以下操作：

def hasThreeContiguousEvenOrOdd(numbers):
    for a, b, c in zip(numbers, numbers[1:], numbers[2:]):
        if a % 2 == b % 2 == c % 2:
            return True
    return False

Answer 4

另一个简短而通用的解决方案：

def consecutive_evenodd(lst, n=3):
    n_uplets = ( lst[i:i+n] for i in range(len(lst)-n+1) )
    return any( sum(el % 2 for el in n_uplet) % n == 0 for n_uplet in n_uplets )

# test
inputs = [[2, 1, 3, 5],                                                
          [2, 1, 2, 5],                                                
          [2, 4, 2, 5]] 

for lst in inputs:
    print(lst, consecutive_evenodd(lst))

输出：

[2, 1, 3, 5] True
[2, 1, 2, 5] False
[2, 4, 2, 5] True

一些解释：sum(...)部分给出每个n-uplet中的奇数个数。当所有数字均为奇数或偶数时，此总和等于n或零。对于其他情况，总和的结果介于两者之间。因此，仅当所有n个小数均为奇数或偶数时，sum(...) % n才等于0。

Answer 5

如果您要在4个元素的列表中查找精确的3个奇数或偶数：

def ex(l):
    return sum([1 if item%2 ==0 else -1 for item in l]) in [2, -2]


ex([2, 1, 3, 5]) # True
ex([2, 1, 2, 5]) # False
ex([2, 4, 2, 5]) # True

如果列表长度和奇数或偶数个元素是参数，则可以将2和-2更改为参数。

Answer 6

使用zip创建n个元素元组（本例中为3个），使用all(map(lambda x: x%2, sl)查找元组中的所有3个元素是否都是奇数，然后使用any检查如果至少有一场比赛。

使用any和all将保证所需的奇数或偶数支票数量最少

>>> n =3
>>> three_odds_or_even = lambda lst: any(all(map(lambda x: x%2, sl)) or all(map(lambda x: not x%2, sl)) for sl in zip(*(lst[i:] for i in range(n))))
>>> three_odds_or_even([2, 1, 3, 5])
True
>>> three_odds_or_even([2, 1, 2, 5])
False
>>> three_odds_or_even([2, 4, 2, 5])
True
>>>

Answer 7

带有两个int计数器的一种方式：

Time:  O(n)
space: O(1)

功能：

def chk(alist):
    odd=even=0
    for n in alist:
        if n % 2:
            odd += 1
            even = 0
        else:
            even += 1
            odd = 0
        if odd>2 or even>2:
            return True
    return False

您的示例输出True False True中的

3个列表。（经过python2测试）

Answer 8

尝试了一种简单的方法。保持两个标志为偶数和奇数。如果找到偶数，则增加偶数标志并重置奇数标志，反之亦然。一旦一个标志的值变为3，就知道您已经连续发现了三个。

role=""

Answer 9

这是使用简单的for循环的解决方案。

这个想法是要维护一个列表，其值取决于输入列表中的元素是偶数还是奇数。如果您没有连续的奇/偶，请清除列表。

如果在跟踪器列表中有3个项目，函数将返回True。

L1 = [2, 1, 3, 5]
L2 = [2, 1, 2, 5]
L3 = [2, 4, 2, 5]

def even_odd_consec(x, k=3):
    lst = []
    for item in x:
        is_odd = item % 2
        if not (lst and (lst[-1] == is_odd)):
            lst.clear()
        lst.append(is_odd)
        if len(lst) == k:
            return True
    return False

even_odd_consec(L1, 3)  # True
even_odd_consec(L2, 3)  # False
even_odd_consec(L3, 3)  # True

Answer 10

只需检查奇数/偶数保持与请求的最小序列长度一样长，在这种情况下为3。

def determine(list_, in_a_row=3):
    prv, cntr = None, 1
    for v in list_:
        cur = bool(v % 2)

        if prv is cur:
            cntr += 1
        else:
            cntr = 1
        prv = cur

        if cntr >= in_a_row:
            return True   

    return False

dataexp = [
    ([2, 1, 3, 5],True),
    ([2, 1, 2, 5],False),
    ([2, 4, 2, 5],True),
    #hmmm, you're able to handle lists smaller than 3, right?
    ([],False),
    ]

for li, exp in dataexp:
    got = determine(li)
    msg = "exp:%s:%s:got for %s" % (exp, got, li)
    if exp == got:
        print("good! %s" % msg)
    else:
        print("bad ! %s" % msg)

输出

good! exp:True:True:got for [2, 1, 3, 5]
good! exp:False:False:got for [2, 1, 2, 5]
good! exp:True:True:got for [2, 4, 2, 5]
good! exp:False:False:got for []

Answer 11

evenOdd=[]

while True:
    try:
        n=int(input())
        evenOdd.append(n)
    except:
        break

for x[0] in evenOdd:
   if x % 2 == 0:
       print("True")
for x[1] in evenOdd:
   if x % 2 == 0:
       print("True")
for x[2] in evenOdd:
   if x % 2 == 0:
       print("True")

使用列表索引，您只能测试列表中的特定项目。例如，x[3]将测试列表中的第4个项目（x[0]是列表中的第一项，x[1]是第二个，依此类推）。因此，我们使用此方法分别测试第一，第二和第三项。

如何确定一个列表是否包含彼此相邻的3个偶数或3个奇数？

11 个答案: