Remove adjacent duplicate elements from a list [duplicate]

Answer 1

Seeing the code written by Google is a humbling lol. This is what I came up with:

def remove_adjacent(nums):
   rmvelement = []
   checkedIndex = []
   for num in nums:
      if nums.index(num) not in checkedIndex:
         index = nums.index(num)
         checkedIndex.append(index)
         skip = False
      else:
         skip = True

   if skip == False:
      for x in nums[index+1:]:
         if x == num:
            rmvelement.append(x)
         else:
            break

   [nums.remove(_) for _ in rmvelement]
   return nums

Answer 2

This should work for a transparent (albeit roundabout) solution:

def remove_adjacent(nums):

    numstail = [i for i in range(0,len(nums))] 
    nums = nums + numstail

    for i in nums:
        if nums[i] == nums[i-1]:
            del nums[i]

    return nums[:-len(numstail)]

The logic is as follows:

• Create a tail-list equal to the length of the original list of numbers and append this to the end of the original list.
• Run a 'for-loop' that checks if a given element of nums is the same as the previous element. If so, delete it.
• Return the new nums list, with the necessary deletions, up to len(numtails) index positions from the end of the list.

(numstail is defined to avoid indices being out of range for any length list)

Answer 3

Just to show one more way here is another single liner version without indexes:

def remove_adjacent(nums):
     return [a for a,b in zip(nums, nums[1:]+[not nums[-1]]) if a != b]

The not part puts the last value to result as only a ends up to result.

Answer 4

You can use list comprehension. For example something like this should do the job:

def remove_adjacent(L):
  return [elem for i, elem in enumerate(L) if i == 0 or L[i-1] != elem]

or:

def remove_adjacent(L):
  return [L[i] for i in xrange(len(L)) if i == 0 or L[i-1] != L[i]]

Answer 5

itertools.groupby is superior, but there is also

reduce(lambda x, y: x + [y] if x[-1] != y else x, seq[1:], seq[0:1])

e.g.

>>> seq = [[1,1], [2,2], [3,3], [3,3], [2,2], [2,2], [1,1]]
>>> print reduce(lambda x, y: x + [y] if x[-1] != y else x, seq[1:], seq[0:1])
[[1, 1], [2, 2], [3, 3], [2, 2], [1, 1]]

When coming from functional languages where this sort of thing is done with a fold, then using reduce often feels natural.