检查列表中的相邻元素

Question

def remove_adjacent(nums):
  list1 = []
  le = len(nums) # get length of input array (le-1 is the last index)
  for idx in range(len(nums)): # iterate through nums using the indices
      if idx < le-1: # if before the last element
          if nums[idx] != nums[idx +1]: # and if current element is not the same as the next element
              list1.append(nums[idx]) # append the current element. Otherwise (elem reoccurs), do not append!
      else: # if at last elem of nums
          list1.append(nums[idx]) # just append

  return list1

I am learning Python (currently doing the Google course). The task was:

D. Given a list of numbers, return a list where all adjacent == elements have been reduced to a single element, so [1, 2, 2, 3] returns [1, 2, 3]. You may create a new list or modify the passed in list.

Now I think I managed to solve the task, but it looks complicated. Furthermore, I want to learn to code in the most basic way first, without using tons of module imports. How could this be solved in a more elegant way using the basic set of methods? Also, I would love advice and tips on good coding style, habits, form etc.

Answer 1

You can make a set with your list. Sets can only have single instances of an element.

my_list = [1,2,2,3]
my_set = set(my_list)

print(s)
>>> {1,2,3}

edit: Make the set into a list.

my_list = list(my_set)

Answer 2

I tried to put it in the most simple way.

l = [1,2,2,2,2,3,3]
def removeAdj(num):
   prevelem = num[0] -1 ##Assigning prev value one less than first element so that it will not be same as first element
   updatedList = []  ## New list
   for elem in num:
      if elem !=prevelem:
          updatedList.append(elem) ## If element not same as previous element append
      prevelem = elem ## Assign previous value the current value
   return updatedList ## Return updated list
print(removeAdj(l))

Answer 3

Your function seems to work correctly but it could be more "pythonic" by iterating through the elements directly instead of using indices.

Without using any "fancy" standard library functions:

def filter_adjacent_dupes(lst):
     # make sure to check if `lst` is empty
     if not lst:
         return lst

     # construct a new list that doesn't contain adjacent duplicates
     filtered = [lst[0]]
     for elem in lst[1:]:
         if elem != filtered[-1]:
             filtered.append(elem)
     return filtered

You might also consider turning the above function into a generator:

def filter_adjacent_dupes(lst):
     # make sure to check if `lst` is empty
     if not lst:
         return

     # yield each valid candidate, skipping duplicates
     yield lst[0]
     prev_value = lst[0]
     for elem in lst[1:]:
         if elem != prev_value:
             yield elem
         prev_value = elem