交替 1 和 0 的最小数量

Question

I want to find the minimum number of flips required to get an alternating of [0, 1, 0, 1] for example given [1, 1, 0, 1]. so in this case, it is one flip.

def solution(A):
    count = 0
    myDict = {}
    myDict[1] = True
    myDict[0] = False

    next = None
    # first element value
    val = myDict[A[0]]
    if val == True:
        next = False
    else:
        next = True

    for element in A[1:]:
        if next != myDict[element]:
            count += 1
            # do something to update element
            myDict[element] = next
        if myDict[element] == True:
            next = False
        else:
            next = True

    return count

My solution does not work for the input [1, 1, 0, 1, 1]. Because it gives back 3 when the answer it should give back is 2(change the first index and last index elements to 0). How can i solve this?

Answer 1

You could just count the differences for each kind of pattern and take the min

def minFlip(a):
    return min(
        sum(n == i % 2 for i, n in enumerate(a)),
        sum(n == (i + 1) % 2 for i, n in enumerate(a))
    )

minFlip([1, 1, 0, 1, 1])
#2
minFlip([0, 1, 0, 1, 0])
#0
minFlip([1, 1, 1, 1, 1])
#2
minFlip([0, 0, 0, 0, 0])
#2

Answer 2

You could count the values for which the least significant bit is different from that of the index. Then take that count or the "opposite" (len-count):

def minFlip(a):
    flips = sum((n ^ i) & 1 for i, n in enumerate(a))
    return min(flips, len(a)-flips)

Alternatively, you could sum up 1 and -1 depending on that bit, and then derive the solution from that:

def minFlip(a):
    return (len(a)-abs(sum(-1 if (n^i)&1 else 1 for i,n in enumerate(a)))) // 2

Answer 3

(The number of flips to achieve an alternating pattern starting with 0) + (the number of flips to achieve an alternating pattern starting with 1) = (n: the number of elements in your list)

So:

1. Find out how many flips it would take to achieve an alternating pattern starting with 0. Call this patt0 .
2. patt1 = n - patt0
3. ans = min(patt0, patt1)

So in your case, you found it took 3 flips for a list of 5, so ans = min(3, 5-3) which is 2 .

Answer 4

solution:

• pattern in the form of 0,1; this can be set in the pattern
• loop input_values
• if is 1,3,5.. (odd element)
  • if value is not false then add 1 to flips
• if is 2,4,6 (even element)
  • if value is not true then add 1 to flips
• return flips

def getFlips(input_value):
  pattern = [False, True]
  flips = 0
  for i in range(len(input_value)):
    if i % 2 == 1:
      flips += (1 if input_value[i] != pattern[0] else 0)
    elif i % 2 == 0:
      flips += (1 if input_value[i] != pattern[1] else 0)
  return flips

example:

print(getFlips([True, True, True, False])) == 1

Answer 5

For completeness, here's an O(1) space basic dynamic programming, not much different than other proposed solutions, but can be seen here to start outrunning the ones that use list comprehensions.

def f(A):
  a, b = 0, 0
  for i in xrange(len(A)):
    m = i & 1 ^ A[i]
    a, b = m + a, (not m) + b
  return min(a, b)