Главная » Хабрахабр » 1000+1 способ определения того, являются ли все элементы в списке одинаковыми

1000+1 способ определения того, являются ли все элементы в списке одинаковыми

В жизни у нас всегда есть выбор, знаем мы о нем или нет. То же самое происходит и в кодировании. Существует множество способов, с помощью которых мы можем подойти к какой-то конкретной задаче. Мы можем изначально не рассматривать эти способы или не иметь о них никакого понятия, но они существуют. Быть программистом — это не просто знать язык и процесс написания кода. Очень часто это значит быть самой креативной версией себя, рассматривая даже то, над чем Вы раньше не задумывались. И на этой ноте я хотел бы представить себя. Здравствуйте! Меня зовут Алекс, я основатель CheckiO, и я уже давно занимаюсь творческими аспектами этого проекта.

image

Наши пользователи имеют разные уровни знаний и опыта в области кодирования, поэтому я часто вижу стандартные и более очевидные подходы к решению задач. Но время от времени я сталкиваюсь с такими уникальными и необычными решениями, что они заставляют меня вновь изучать неведомые ранее тонкости языка.

Миссия требует от Вас написать функцию, которая будет определять, имеют ли все элементы массива одинаковое значение. В этой статье я хочу рассмотреть некоторые решения одной из очень простых задач, которые, на мой взгляд, являются самыми интересными.

Если эти значения равны, значит список состоит из одинаковых элементов. 1. Одно из первых решений, которое приходит в голову — сравнить длину списка исходных элементов с тем, сколько раз первый элемент входит в список. Также присутствует проверка того, является ли список пустым, так как в этом случае также необходимо вернуть True.

def all_the_same(elements): if len(elements) < 1: return True return len(elements) == elements.count(elements[0])

Либо более сокращенный вариант:

def all_the_same(elements): return len(elements) < 1 or len(elements) == elements.count(elements[0])

2. В этом решении использовалась полезная особенность Python — возможность сравнивать списки всего лишь с помощью оператора сравнения — ‘==’ (в отличии от некоторых других языков программирования, где это сделать не так просто). Рассмотрим, как это работает:

>>> [1, 1, 1] == [1, 1, 1] True
>>> [1, 1, 0] == [0, 1, 1] False

Другая особенность языка в том, что он предоставляет возможность умножать list на число и результатом этой операции будет list в котором все элементы скопированы указанное количество раз. Давайте я покажу вам несколько примеров:

>>> [1] * 3
[1, 1, 1] >>> [1] * 5
[1, 1, 1, 1, 1] >>> [1] * 0
[] >>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

Таким образом можно прийти к простому решению — если умножить массив из одного первого элемента из исходного массива на длину этого исходного массива, то должен опять получиться исходных массив, если все элементы этого массива одинаковые.

def all_the_same(elements): if not elements: return True return [elements[0]] * len(elements) == elements

Как и в предыдущем случае, можно укоротить это решение:

def all_the_same(elements): return not elements or [elements[0]] * len(elements) == elements

3. В этом решении использовалась стандартная функция set(). Эта функция преобразовывает объект в set в котором, по определению, все элементы должны быть уникальными. Это выглядит так:

>>> elements = [1, 2, 5, 1, 5, 3, 2] >>> set(elements)

Если в итоге полученный set будет состоять из 1 или 0 элементов — значит в исходном списке все элементы были одинаковы или же он был пуст. Решение может выглядеть так:

def all_the_same(elements): return len(set(elements)) in (0, 1)

или так:

def all_the_same(elements): return len(set(elements)) <= 1

Подобный подход можно использовать с помощью модуля NumPy, в котором есть функция unique(), работающая следующим образом:

>>> from numpy import unique
>>> a = [1, 2, 1, 2, 3, 1, 1, 1, 1] >>> unique(a)
[1 2 3]

Как видите, её работа весьма схожа с работой set(), только в этом случае не
меняется тип объекта — список остается списком. Решение с помощью этой функции выглядит так:

from numpy import unique def all_the_same(elements): return len(unique(elements)) <= 1

4. Вот пример весьма оригинального решения, в котором, к тому же, обыгрывается название данной задачи с помощью стандартной функции Python — all(). Функция all() вернет True, если все элементы переданного списка будут True. Например:

>>> all([1, 2, 0, True])
False
#(0 не true)
>>> all([1, 2, None, True])
False
#(None не true)
>>> all([1, 2, False, True])
False
>>> all([1, 2, 0.1, True])
True

Сперва переменной first присваивается значение первого элемента списка, а rest — список всех остальных элементов, кроме первого. Затем в кортеж the_same добавляются значения True or False в зависимости от того, равен ли очередной элемент списка rest первому элементу исходного списка. После этого функция all() вернет True, если the_same будет состоять только из элементов ‘True’, и False, если в кортеже будет хотя бы один элемент ‘False’.

def all_the_same(elements): try: first, *rest = elements except ValueError: return True the_same = (x == first for x in rest) return all(the_same)

Исключение ValueError будет вызвано только в том случае, если массив пуст. Но мы можем сделать более привычную нам проверку:

def all_the_same(elements): if not elements: return True first, *rest = elements the_same = (x == first for x in rest) return all(the_same)

5. Следующее решение очень похоже на предыдущее. В нем есть лишь небольшая поправка — первый и остальные элементы из исходного списка разделяются с помощью итератора. Функция iter() создает итератор из переданного списка, а функция next() берет из него следующий элемент (т.е. первый — при первом вызове). Если вывести с помощью print элементы, входящие в el и first, мы увидим следующее:

>>> el = iter([1, 2, 3])
>>> first = next(el, None)
>>> print(first)
1
>>> for i in el:
>>> print(i)
2
3

В остальном, это решение похоже на предыдущее, за исключением того, что у нас отпадает необходимость в проверке — является ли список пустым или нет.

def all_the_same(elements): el = iter(elements) first = next(el, None) return all(element == first for element in el)

6. Одним из креативных подходов к решению этой задачи является перестановка элементов. Мы меняем элементы местами и проверяем, что список из-за этого не изменился. Это говорит нам о том, что все элементы в списке — одинаковые. Вот пару примеров такого подхода:

def all_the_same(elements): return elements[1:] == elements[:-1]

и

def all_the_same(elements): return elements == elements[1:] + elements[:1]

Стоит также обратить внимание, что сравнивать массивы можно и поэлементно, используя функцию zip(). Рассмотрим это на примере следующих решений.

7. Функция zip() объединяет каждый i-ый элемент одного объекта с i-ым элементом остальных до тех пор, пока не закончится самый короткий объект.

>>> x = [1, 2, 3] >>> y = [10, 11] >>> list(zip(x, y))
[(1, 10), (2, 11)]

Как видите, несмотря на то, что x состоит из трех элементов, были использованы только два, так как самый короткий объект — в данном случае y — состоит всего из 2-х элементов.

Затем поочередно сравниваются элементы из этих двух списков и в результате каждого такого сравнения мы получаем True или False. Приведенное ниже решение работает следующим образом: сперва создается второй список (elements[1:]), который равен исходному списку, но без первого элемента. После чего функция all() возвращает результат обработки этого набора True и False.

def all_the_same(elements): return all(x == y for x, y in zip(elements, elements[1:]))

Предположим, наш исходный список elements = [2, 2, 2, 3]. Тогда с помощью zip(), мы объединим полный список ([2, 2, 2, 3]) и список без первого элемента ([2, 2, 3]) таким образом: [(2, 2), (2, 2), (2, 3)], сравнения элементов между собой передадут в функцию all() набор [True, True, False] и в результате мы получим False, что является правильным ответом, так как в исходном списке не все элементы одинаковы.

В нем использовался итератор groupby(), который работает таким образом — сравнивает каждый i-ый элемент с (i-1)-ым и если элементы равны — двигается дальше, а если не равны — оставляет в итоговом списке элемент (i-1) и продолжает сравнение со следующего элемента. 8. Весьма любопытным оказалось следующее решение. На практике это выглядит так:

>>> from itertools import groupby
>>> elements = [1, 1, 1, 2, 1, 1, 1, 2] >>> for key, group in groupby(elements):
>>> print(key)
1
2
1
2

Как видите, остались только те элементы, которые отличаются от элемента на следующей позиции (elements[0], elements[1], elements[4] и elements[5] были исключены).

Таким образом, если в исходном списке 0 элементов или все элементы равны, сумма (sum(1 for _ in groupby(elements))) будет равна 0 или 1 — то есть в любом случае меньше 2, что и указано в решении. В данном решении функция с помощью итератора groupby() добавляет в список единицу (1) каждый раз, когда следующий элемент исходного списка отличается от предыдущего.

from itertools import groupby def all_the_same(elements): return sum(1 for _ in groupby(elements)) < 2

9. Еще одно креативное решение, в котором используется один из стандартных модулей Python — collections. Counter создает словарь, куда заносит информацию о количестве каждого элемента в исходном списке. Давайте посмотрим, как это работает:

>>> from collections import Counter
>>> a = [1, 1, 1, 2, 2, 3] >>> Counter(a)
Counter({1: 3, 2: 2, 3: 1})

Соответственно, если длина этого словаря будет 2 и больше — в исходном списке как минимум 2 разных элемента и не все элементы одинаковы.

def all_the_same(elements): from collections import Counter return not len(list(Counter(elements))) > 1

10. Данное решение построено на такой же логике, как и решение №7, но используются функции eq() и starmap(). Разберемся, как они работают:

>>> from operator import eq
>>> eq(1, 2)
False

По сути, функция eq() делает то же, что и “==” — сравнивает два объекта и возвращает True, если они равны и False в ином случае (eq — сокращенно от equivalent). Однако, обратите внимание, что функция — это объект и она может быть, к примеру, передана в качестве аргумента для другой функции, что и было сделано в описанном далее решении.

Используется тогда, когда объекты уже сгруппированы в кортежи. Функция starmap() создает итератор, который применяет другую функцию к списку объектов. Например:

>>> import math
>>> from itertools import starmap
>>> list(starmap(math.pow, [(1, 2), (3, 4)]))
[1.0, 81.0]

Как вы видите, указанная один раз функция math.pow(), благодаря функции starmap() была применена дважды — к обоим наборам объектов (1**2 = 1.0, 3**4 = 81.0)

Упрощенно функцию starmap() для данного примера можно представить в виде цикла:

import math elements = [(1, 2), (3, 4)] result = [] for i in elements: result.append(math.pow(i[0], i[1]))

Решение с использованием описанных ранее функций выглядит так:

from operator import eq
from itertools import starmap def all_the_same(elements): return all(starmap(eq, zip(elements, elements[1:])))

Заключение

При всем желании, я даже понятия не имею, как начать описывать то количество уникальных подходов, которые применяют наши пользователи для решения других интересных и более сложных задач. Итак, мы рассмотрели некоторые смекалистые решения, которые относятся к одной из самых простых головоломок. Я с нетерпением жду Ваших отзывов. Надеюсь, Вы получили такое же удовольствие от прочтения этой статьи, что и я во время ее написания. Как бы Вы решили эту задачу? Было ли это полезно для Вас?

The Python”.
Перевод статьи “Determining if all Elements in a List are the Same in Python”, опубликованной на блоге “The Mouse Vs.


Оставить комментарий

Ваш email нигде не будет показан
Обязательные для заполнения поля помечены *

*

x

Ещё Hi-Tech Интересное!

[Перевод] Почему процессоры Skylake иногда работают в 2 раза медленнее

Мне сообщили, что на новых компьютерах некоторые регрессиионные тесты стали медленнее. Обычное дело, такое бывает. Неправильная конфигурация где-то в Windows или не самые оптимальные значения в BIOS. Но в этот раз нам никак не удавалось найти ту самую «сбитую» настройку. ...

«Защита авторских прав в ЕС»: новая реформа может повлиять не только на медиаплатформы

Новая директива о защите авторских прав, предложенная в Евросоюзе, которую мы недавно обсуждали в блоге, может существенно повлиять на устройство таких платформ, как YouTube, Facebook и Pinterest. Однако «под ударом» оказались не только они, но и библиотеки и агрегаторы научных ...