Все равны как на подбор python задача

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-х элементов.

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

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

>>> 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] были исключены).

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

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()

Соответственно, если длина этого словаря будет 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:])))

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

Python: Срезы строк

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

Подстрока — это некоторая часть строки, которую нужно найти и извлечь.

Представим, что у нас есть дата в таком формате: 12-08-2034. Нам нужно извлечь из нее подстроку, в которую входит только год.

Если подумать логически, то нужно посчитать индекс символа, с которого начинается год, и затем извлечь четыре символа. Индексы в строке начинаются с нуля, значит, первый символ года доступен по индексу 6, а последний символ — по индексу 9. Проверим:

value = '12-08-2034' print(value[6]) # => 2 print(value[9]) # => 4 

Зная эти индексы, мы можем воспользоваться срезами и получить нужную подстроку:

value = '12-08-2034' year = value[6:10] print(year) # => 2034 

Срезы для строк в Python — это механизм, с помощью которого извлекается подстрока по указанным параметрам. В примере выше мы взяли подстроку с 6 индекса по 10 индекс, не включая, то есть с 6 по 9 включительно. Формула выглядит так:

str[начальный индекс:конечный индекс] # Пара примеров value = '01-12-9873' # Срез строки это всегда строка, # даже если внутри строки было число. value[1:2] # '1' value[3:5] # '12' 

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

value = 'Hexlet' value[3:] # 'let' value[:3] # 'Hex' 

Можно указать даже отрицательные индексы. В таком случае отсчет идет с обратной стороны:

value = 'Hexlet' # Правая граница отрицательная. Считаем -1 от конца строки value[3:-1] # 'le' # Левая граница отрицательная. Считаем -5 от конца строки value[-5:3] # 'ex' 

У срезов два обязательных параметра, но иногда используется и третий.

У срезов есть третий необязательный параметр — шаг извлечения. По умолчанию он равен единице, но мы можем его изменить:

value = 'Hexlet' value[1:5:2] # el # 1:5 это 'exle' # шаг 2 это каждый второй, то есть 'e' и 'l' 

Все это можно комбинировать с открытыми границами, то есть без указания начала или конца:

value = 'Hexlet' value[:5:2] # 'Hxe' value[1::2] # 'elt' 

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

value = 'Hexlet' # Пропускаем обе границы value[::-1] # 'telxeH' 

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

value = 'Hexlet' # Символ с индексом 1 не будет включен в подстроку value[4:1:-1] # 'elx' 

Срезы можно указывать не только через числа, но и с использованием переменных:

value = 'Hexlet' start = 1 end = 5 value[start:end] # 'exle' 

Соберем все вместе:

value = 'Hexlet' value[::] = 'Hexlet' # Вся строка value[:] = 'Hexlet' # Вся строка value[::2] = 'Hxe' # Четные по порядку символы value[1::2] = 'elt' # Нечетные по порядку символы value[::-1] = 'telxeH' # Вся строка в обратном порядке value[5:] = 't' # Строка, начиная с шестого символа value[:5] = 'Hexle' # Строка до шестого символа value[-2:1:-1] = 'elx' # Все символы с предпоследнего до третьего в обратном порядке. Во всех случаях выборки от большего индекса к меньшему нужно указывать шаг 

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

Задание

В переменной value лежит значение Hexlet . Извлеките из него и выведите на экран срез, который получит подстроку xle . Это задание можно сделать разными способами.

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

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

Мой код отличается от решения учителя ��

Это нормально ��, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи.

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

Прочитал урок — ничего не понятно ��

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

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

Полезное

Определения

• Срезы для строк — механизм, с помощью которого извлекается подстрока по указанным параметрам.