Таблица products

🔥 Сокращаем память в 8 раз в Python

По сравнению с другими языками программирования - писать на Python легко и удобно, он универсален. Однако скорость выполнения скрипта или занимаемая память - те вещи, за которые всем нам еще предстоит побороться. Редко бывает, что первый пришедший в голову вариант - самый оптимальный. Поэтому сегодня предлагаем попробовать себя в роли оптимизатора.

🔹 Вот, что мы имеем: скрипт генерирует случайную машину (её марку и цвет) и записывает в список. На выходе мы получаем список из одного миллиона машин.

car_names = ['Toyota', 'Honda', 'Renault', 'Audi', 'Nissan', 'Suzuki']

colors = ['Black', 'Blue', 'Red', 'Yellow', 'White']

def car_list(cnt_cars):
   all_cars = []
   for i in range(cnt_cars):
       car = {
           'id': i,
           'name': random.choice(car_names),
           'color': random.choice(colors)
       }
       all_cars.append(car)
   return all_cars

cars = car_list(1000000)

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

Вернемся к нашему скрипту. Он выполняется за 1,5 секунды в среднем, но это не самое страшное в нем. До генерации списка он использует 8 MB памяти, а после - 334 MB. Конечно, чего мы ожидали от списка в миллион элементов. Но если мы просто сгенерируем его и запишем в переменную - это никуда не годится. Столько используемой памяти может быть непростительной ошибкой, тем более, что мы знаем как это исправить!

car_names = ['Toyota', 'Honda', 'Renault', 'Audi', 'Nissan', 'Suzuki']

colors = ['Black', 'Blue', 'Red', 'Yellow', 'White']

def car_list_gen(cnt_cars):
    for i in range(cnt_cars):
        car = {
            'id':i,
            'name':random.choice(car_names),
            'color':random.choice(colors)
        }
        yield car

for car in car_list_gen(1000000):
    pass

И, внимание! Немного изменив тело функции, мы сократили время работы до 1,37 секунды, но это не самое интересное. Мы сократили используемую память: с 334 MB до 40 MB. А что мы сделали? Вместо return в функции, использовали yield.

🔸 Справка: yield в Python используется для создания генераторов. Генератор - тип коллекции, которая генерирует элементы на ходу и может быть итерирована только один раз.

Конечно, эта уловка сработает, если вам не нужен доступ ко всем элементам списка сразу.

А вообще, генераторы - хороший способ повысить производительность. Главное - понимать когда и где их использовать.

⁉️ Кстати, сделать отдельный пост о том, как работает yield и в каких задачах его лучше использовать?

#python

🔥 Красивое сравнение нескольких столбцов

У нас имеется таблица students, она содержит информацию о студентах (очевидно). В столбце level указан академический уровень учащегося (Senior, Junior, Freshman и т.д.), subject - предмет, который студент изучает (Math, Physics и другие), а grade - текущая оценка студента по этому предмету (A, B, C и т.д.).

Нам нужно достать всех студентов, которые соответствуют следующим критериям:

- Уровень - 'Senior'
- Изучают 'Math'
- Имеют оценку 'А'

Но подождите, это еще не все! Мы хотим написать как можно более короткий и читаемый запрос. Попробуем? 💡

SELECT level, subject, grade
FROM students
WHERE level = 'Senior'
  AND subject = 'Math'
  AND grade = 'A';

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

SELECT level, subject, grade
FROM students
WHERE (level, subject, grade) = ('Senior', 'Math', 'A');

Мы нечасто видим этот метод в запросах, но согласитесь, выглядит лучше.

Есть пример посложнее! Что если нам понадобятся seniorы, которые лучшие либо в математике, либо в физике?

SELECT level, subject, grade
FROM students
WHERE level = 'Senior'
AND (
    (subject = 'Math' AND 
     grade = 'A')
 OR
    (subject = 'Physics' AND 
     grade = 'A'));

Такой громоздкий запрос может быть сведен к более короткому:

SELECT level, subject, grade
FROM students
WHERE level = 'Senior' 
  AND (subject, grade) 
   IN (('Math', 'A'), 
       ('Physics', 'A'));

✅ Вот как мы аккуратно и компактно решили все задачи! На этом нужно акцентировать внимание, ведь подход «лишь бы работало» - непрофессиональный! Независимо от того, являетесь ли вы опытным аналитиком или только начинаете знакомиться с базами данных, уделяйте время изучению Best Practices, это облегчит вашу работу в будущем!

💫 На наших Симуляторах мы особое внимание уделяем читаемости кода и использованию синтаксического сахара, который делает код удобнее!

#sql

🔥 Необычная «связка» функций для поиска похожих слов в SQL

Один из основных функционалов SQL, которому учат на любых курсах - поиск по шаблону, например, операторы LIKE или SIMILAR TO.

🟢 В PostgreSQL есть необычная функция, которая также относится к поиску в тексте, но может найти не просто заданное слово, а похожие слова или фразы, или даже учесть различные варианты написания. О ней мы сегодня и поговорим!

Если бы мы захотели решить такую задачку самостоятельно, то нам пришлось бы изрядно потрудиться. К счастью, у нас есть функция SIMILARITY и расширение trigram. Это расширение использует триграммы - группы из трех букв. Например, набор триграмм в строке «cat» - « c», « ca», «cat» и «at».

Давайте сразу посмотрим эту связку в деле. Табличка documents содержит совершенно разные строки (см. табличку 1).

Включим расширение trigram в PostgreSQL:

CREATE EXTENSION pg_trgm;

И попробуем с помощью функции SIMILARITY найти слово ellefant. Взгляните на таблицу еще раз и убедитесь, что такого слова нет. Но есть множество других очень и очень похожих слов, и trigram может идентифицировать их как совпадающие.

SELECT title, 
       similarity('ellefant', title) AS similarity_score
FROM documents

В столбце similarity_score (см. табличку 2) мы видим числа, описывающие насколько близки два аргумента. Диапазон - от нуля (это значит, что две строки полностью различны) до единицы (две строки идентичны). Что же произошло и как это понимать?

🔵 Наше искомое слово было поделено на триграммы - « e», « el», «ell», «lle», «lef», «efa» и тд, строки в столбце title также поделили на триграммы. И теперь, функция SIMILARITY искала самые похожие триграммы слова ellefant среди триграмм строки title, учитывая порядок. А когда нашла, разделила количество совпадающих триграмм на общее количество триграмм в строке title.

Очень любопытная функция, согласитесь? Расширение trigram, в умелых руках, может повысить точность результатов поиска и упростить поиск нужной информации. Обязательно попробуйте использовать эту в вашем следующем проекте!

😏 А вы знали про такие возможности SQL?!

#sql

🔥 Знакомимся с «большим О» еще ближе

В одном из прошлых постов мы познакомились с важным понятием при работе с кодом - O-нотация. Надеемся вы еще не забыли что это за зверь? На всякий случай:

BIG O - это способ измерить эффективность алгоритмов и то, как они работают с увеличением объема обрабатываемых ими данных.

💡 Разработчик Python Нед Батчелдер описывает BIG O как анализ того, «как код замедляется по мере роста данных».

Существует множество «классов» сложности, самые популярные из них представлены на картинке под постом. Кажется, ничего лучше нее еще не придумали - все очень наглядно.

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

Допустим, у вас есть книжная полка с n книгами.

🟢 Например, проверить пуста ли книжная полка - операция постоянного времени O(1). Потому что не имеет значения, сколько книг стоит на полке, вам достаточно найти одну книгу, и на этом проверка закончится. То есть в такой задаче количество книг (n) может варьироваться, но время выполнения останется неизменным. Это константная сложность операции - O(1).

🔵 Следующая сложность - логарифмическая O(log n)

- Справка: Логарифмы это обратная от возведения в степень операция: 2^3, или 2 × 2 × 2, равно 8, таким образом логарифм log2(8) равен 3.

Поиск определенной книги на полке в алфавитном порядке - алгоритм логарифмической сложности. Можно воспользоваться бинарным поиском: проверяем, находится ли нужная книга в середине полки. Если да - задача уже выполнена. Если нет, вы можете определить где вам искать дальше - до или после этой средней книги. Таким образом, вы вдвое сокращаете количество книг, среди которых ведется поиск. И этот процесс будет повторяться до тех пор, пока вы не найдёте ту самую.

Если на полке 16 книг, то понадобится не более четырех шагов, чтобы найти подходящую. А если бы на книжной полке было 4,2 миллиарда книг в алфавитном порядке, потребовалось бы всего 32 шага, чтобы найти конкретную книгу.

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

🔴 O(n) - линейная сложность

Прочесть все книги на полке - это линейная по времени операция. Если книги примерно одинаковой длины, и вы удваиваете количество книг на полке, чтение всех книг займет примерно вдвое больше времени. То есть, время выполнения увеличивается пропорционально количеству книг n.

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

🤩 А если вам уже не терпится узнать все о сложности алгоритмов, забирайте шпаргалку Сложность алгоритмов за 5 минут

#сложность_алгоритмов

🔥Какое оно - эстетическое удовольствие аналитика?

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

🔹Как часто вы оказывались в ситуации, где вы запустили цикл и ждете, и ждете, и ждете, а он все еще выполняется? Такое может быть если код не очень оптимизирован или вы просто обрабатываете много данных. Иного предсказать сколько времени займет выполнение кода - сложно. И эта неопределенность постоянно щекотит наши нервы.

🪄Что, если мы покажем вам волшебную палочку, которая спасет вас от неизвестности и ожидания! Это волшебство называется TQDM!

С помощью этого модуля вы сможете отследить ход выполнения вашего цикла, да еще и сделать это красиво. Все, что вам понадобится сделать, это импортировать TQDM, и обернуть в него итерируемый объект. Вуаля!

from tqdm import tqdm
from time import sleep
# оборачиваем итератор range(100) классом tqdm()
for i in tqdm(range(100)):
    sleep(0.1)

У вас появится автоматически обновляемая строка прогресса:

>> 13%|█▎        | 13/100 [00:01<00:08,  9.82it/s]

А если вы работаете в ноутбуке, можете импортировать tqdm.notebook и тогда эта строка прогресса будет отображаться в html, что делает её еще более интересной (см. гифку под постом).

from tqdm.notebook import tqdm 
from time import sleep

for i in tqdm(range(100)):
    sleep(0.1)

Теперь, вам не придется, например, добавлять print в цикл, чтобы понимать на какой стадии вы находитесь. С TQDM вы можете расслабиться и просто наблюдать!

🤩 Очень советуем опробовать этот модуль, потому что это - настоящее эстетическое удовольствие аналитика!

#python

🔥 Бесплатный мастер-класс по SQL

Приветствую!

На связи Андрон, основатель IT Resume & Simulative. Хочу пригласить вас на свой мастер-класс по SQL: «Расчет продуктовых метрик и активности пользователей» 🔥

Мастер-класс пройдет 22 февраля, в 20:10 по Мск. Нам предстоит проанализировать активность пользователей платформы IT Resume на основании посещений платформы и решения задач юзерами.

С помощью SQL-запросов мы посчитаем:

- MAU/WAU/DAU
- sticky factor
- когортный анализ lifetime методом нахождения интеграла от n-day retention

🔗 Чтобы не пропустить трансляцию и получить конспект, переходите по ссылке 👉🏻 https://t.iss.one/simulative_master_class_bot?start=c1669653664751-ds

Кстати, все участники мастер-класса получат в подарок конспект с разбором метрик, шаблонами SQL-запросов и полезными советами 🎁

До встречи на мастер-классе! 🙂

🔥 Задача с собеседования по SQL

Сегодня любимая рубрика - разбор задачи с собеседования!

Есть две таблицы: items_available и colors. Наша задача - извлечь доступные цвета в текстовом формате.

Звучит просто, не так ли? Но как всегда, дьявол кроется в деталях.

items_available

| item_id | colors_available |
|---------|------------------|
| 1       | 1, 2             |
| 2       | 3, 4             |
| 3       | 5, 4             |
| 4       | 3, 4             |
| 5       | 6, 2             |

colors

| color_id | color_name |
|----------|------------|
| 1        | Black      |
| 2        | White      |
| 3        | Silver     |
| 4        | Gold       |
| 5        | Pink       |
| 6        | Green      |

Результат

| item_id | colors       |
|---------|--------------|
| 1       | Black, White |
| 2       | Silver, Gold |
| 3       | Pink, Gold   |
| 4       | Silver, Gold |
| 5       | Green, White |

1️⃣ Начнем с первого предложенного варианта решения (карточка 1).

В этом решении столбец colors_available делят на два разных столбца. Это достигается с помощью функций LEFT и POSITION. В POSITION передается запятая и она возвращает нам индекс вхождения этой запятой в строку, а при помощи LEFT мы обрезаем строку до позиции запятой минус единица. Примерно все то же самое происходит для второго числа, только теперь используется SUBSTRING. Дальше все это объединяется c табличкой colors, и с помощью CONCAT - выводят цвета через запятую.

🛑 Этот запрос решает задачу, но не кажется ли вам, что можно сделать запрос короче? Да и в целом, получается какое-то нагромождение.

2️⃣ Итак, версия второго кандидата (карточка 2).

Здесь, мы не используем ни POSITION, ни LEFT, ни SUBSTRING, их всех заменяет SPLIT_PART. В SPLIT_PART можно передать строку, которую мы хотим разделить, потом разделитель (в нашем случае запятая), а затем указать какую часть из получившихся сплитов взять. И мы сразу джойним таблички по этому условию.

Существенно короче и приятнее стал выглядеть запрос, согласитесь?

3️⃣ Но подождите, это еще не все! Третье решение - самое элегантное из всех. Есть только одно НО. Этот запрос сработает, только при условии, что столбец colors_available - не текстовый, а является массивом чисел. (карточка 3)

🟢 В этом случае, нам даже не пришлось придумывать какими пользоваться функциями, нас спас простой ANY. С его помощью мы сопоставляем любой элемент в массиве colors_available с соответствующим id цвета в таблице colors.

У вас есть идеи как еще решить эту задачу? 😏

#sql #interview_problems

🔥 [Ласт-колл] На бесплатный мастер-класс по SQL

Это Андрон, основатель IT Resume & Simulative. Просто хочу напомнить, что сегодня в 20:10 по Мск я провожу мастер-класс по SQL: «Расчет продуктовых метрик и активности пользователей» 🔥

Будем считать MAU/WAU/DAU, sticky factor и делать когортный анализ lifetime. В конце всех ждут подробные конспекты с шаблонами кода и полезными советами 🎁

🔗 Чтобы не пропустить трансляцию и получить конспект, переходите по ссылке 👉🏻 https://t.iss.one/simulative_master_class_bot?start=c1669653664751-ds

До встречи на мастер-классе 🙂

🔥 Генератор yield в Python

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

Из примера в прошлом посте видно, что yield можно использовать в функции вместо return. И тогда получается генератор, который вычисляет не всё сразу, а генерирует элемент на ходу.

Итак, как же он работает? 🧐

Допустим, мы хотим получить квадраты чисел от 1 до 10. Мы могли бы создать список и с помощью append добавлять в него элементы, но мы заменим эту привычную конструкцию на yield:

def squares(x=0):
    while x < 10:
        x = x + 1
        yield x*x

for i in squares():
    print(i)

Получим:

1
4
9
16
25
36
49
64
81
100

🟢 Что произошло?

Мы задали функцию-генератор squares(), а затем с помощью цикла for вывели элементы, вычисленные функцией.

У генераторов еще есть метод next(). Например, мы бы вызывали next(squares()), чтобы получить следующее значение. Но нам бы пришлось написать это 10 раз, так что лучше воспользуемся циклом.

Итак, при каждой итерации, Python запускал код до тех пор, пока не сталкивался с оператором yield. Затем он выдавал вычисленное значение, а функция, как бы “замораживалась” в этом состоянии, готовясь возобновить выполнение с этого же места.

Когда функция вызывается в следующий раз, выполнение продолжается с этого “замороженного” момента. И так продолжается до тех пор, пока генератор не будет исчерпан. Если после того, как генератор выдал все значения, вызвать его снова - получим ошибку StopIteration. Мы можем переопределить генератор, и тогда все начнётся заново.

🔵 Где пригодится yield?

→ При генерации больших последовательностей - с помощью yield мы сохраним внушительный объем памяти.
→ При чтении больших файлов. Yield позволит пройтись по одной строке за раз, а не считывать весь файла целиком в память.
→ При создании пайплайнов обработки. Вы можете постепенно проходить все этапы для каждого элемента, а не обрабатывать все элементы сразу. Например:

def read_csv(filename):
    # читаем строки из файла и обязательно указываем yield
            yield line

def filter_columns(rows, indices):
    # что-то фильтруем
        yield [row[i] for i in indices]

def convert_to_float(rows):
    # производим какие-то преобразования
        yield [float(cell) for cell in row]

def compute_average(rows):
    # производим вычисления
    yield total / count

# Создаем пайплайн
pipeline = compute_average(
convert_to_float(filter_columns(
read_csv("data.csv"), [1, 2, 3])))

average = next(pipeline)
print(f"Average: {average:.2f}")

🟡 Таким образом, yield - мощный инструмент, который позволяет создавать генераторы, и получать значения на ходу. Порой, это делает его незаменимым при работе с объемными данными и файлами. Потренируйтесь использовать yield и убедитесь, как он может упростить ваш код и сохранить память!

#python

🔥 В чем разница между IN и ANY в SQL?

С завидной регулярностью наши студенты задают вопрос: в чем разница между конструкциями IN и ANY в SQL? Если вы сталкивались с ними хоть раз, то, вероятно, замечали, что делают они примерно одно и то же. Но в чем же различия?! Давайте устраним возможную путаницу и разберем пусть небольшие, но важные различия между этими конструкциями!

Мы используем IN в двух случаях:

- выражение IN (подзапрос)
- выражение IN (значение [, ...])

Аналогично, два варианта использования конструкции ANY:

- выражение оператор ANY (подзапрос)
- выражение оператор ANY (массив)

🟢 IN и ANY с подзапросами

Давайте сначала посмотрим на случаи с подзапросами. Мы привыкли использовать IN с ними, не так ли? Но написать IN это то же, что написать = ANY. Это прямо указано в документации: IN is equivalent to = ANY.

И если мы посмотрим на планы выполнения - увидим, что планы выглядят аналогично ( т.к. IN заменяется на = ANY). Убедитесь в этом, прогнав два запроса:

Первый: explain select * from foo1 where id in (select id from foo2);
Второй: explain select * from foo1 where id = any (select id from foo2);

Итак, можно ли сказать, что ANY гораздо более универсален, поскольку его можно комбинировать со многими операторами, а не только с =, как это предполагает IN? Может быть. Но давайте проверим использование не с подзапросами.

🔵 IN и ANY с простыми значениями

Во втором случае использования IN принимает список значений, разделенных запятыми. Он возвращает true, если значение совпадает с любым из значений в списке.

SELECT * FROM students
WHERE grade IN ('A', 'B', 'C');

Этот запрос вернет всех учащихся, с оценками A, B или C.

В то время как ANY принимает массив. Он также возвращает true, если значение совпадает с любым из значений в массиве.

SELECT * FROM products
WHERE price > ANY (ARRAY[10, 20, 30]);

Получим все товары, цена которых превышает 10, 20 или 30.

🟣 Таким образом, несмотря на то, что конструкции IN и ANY могут показаться похожими, они остаются разными. Более того, существует мнение, что конструкция ANY покрывает большее количество запросов и оттого лучше, чем IN. Но не будем выбирать любимчика, ведь наша задача - понимать механику работы каждой конструкции и правильно их использовать!

#sql

🔥Продолжаем говорить про О-нотацию

Из предыдущих постов мы уже знаем, как работает O(1), O(log n), O(n), если хотите освежить память, можете вернуться к посту.

А сегодня поговорим про логарифмическую сложность, квадратичную, экспоненциальную и другие типы.

🟢 Сложность O(n log n)

Фактически, все эффективные алгоритмы сортировки представляют собой O(n log n) сложность: сортировка слиянием (merge), пирамидальная сортировка (heap), быстрая сортировка, а еще Timsort (изобретенный Тимом Питерсом алгоритм, который используется методом sort() в Python).

Например, отсортировать n книг в алфавитном порядке, как раз, представляет O(n log n) сложность.

🔵 Сложность O(n^2)

Если требуется найти повторяющиеся книги на несортированной полке, это уже квадратичная сложность. Например, на полке стоят 100 несортированных книг, мы берем одну и ищем дубли среди остальных 99, потом берём другую и снова проверяем оставшиеся. Очень затратно: проверка 100 книг займёт 100 × 100, или 10 000 шагов, причем проверка 200 займёт уже 40 000 шагов - в четыре раза больше.

В реальном мире, именно для этого нам необходимо знание BIG O. Чтобы не писать алгоритм O(n^2), когда можно было написать O(n log n) или O(n).

Итак, остались те, чьи имена нельзя произносить: экспоненциальная O(2^n) и факториальная сложность O(n!).

🟣 Сложность O(2^n)

Допустим, на полке 2 книги, и мы будем собирать все возможные комбинации книг: первая комбинация - пустая полка, вторая - книга A, третья - книга B и последняя - обе книги на полке. Для 3 книг получим уже 8 комбинаций. Так вот, это - экспоненциальный алгоритм. Причем, обратите внимание, нас интересуют не перестановки, а только комбинации.

🔴 Сложность O(n!)

Перестановки, как раз, будут отвечать за факториальную сложность: если у нас на полке 3 книги, все варианты перестановок - 3!.

И оба этих алгоритма крайне плохо масштабируются: даже для малых n они быстро становятся невыполнимыми за разумное время.

💡 Наконец переходим от теории к практике!

Что из себя представляет каждый из алгоритмов мы рассмотрели, практически, под лупой. Мы также понимаем, как увеличение входных данных (количества книг) повлияет на каждый из них. Давайте скорее посмотрим как это применить к настоящему коду, а не книгам.

Грубо говоря, существует несколько «контрольных» точек, которые могут нам помочь определить большую О. Учитывая, что n - это размер входных данных, можно сказать:

1. Если код не оперирует входными данными, это O(1).

2. Если код итерируется по данным, это O(n).

3. Два вложенных цикла, каждый из которых проходит по входным данным, дают сложность O(n^2).

4. Простой вызов функции не считается отдельным шагом, считаем только шаги внутри функции.

5. Если в коде есть конструкция «разделяй и властвуй», это O(log n).

6. Если «разделяй и властвуй» выполняется для каждого элемента во входных данных, это O(n log n).

7. Если код проходит по каждой возможной комбинации значений в n данных, это O(2^n) или другая экспоненциальная сложность (3^n, 4^n…).

8. Если рассматриваются все возможные перестановки значений в данных, это O(n!).

9. Если код предполагает сортировку данных, это будет как минимум O(n log n).

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

❓Уже зная некоторые флаги, как вы думаете, какая сложность у этих методов python?

- .append()
- .insert()
- .remove()
- .sort()
- цикл for

#сложность_алгоритмов

🔥 Почему to_char в SQL дал неправильный результат?

Лучшие генераторы для постов - наши студены! Недавно потупил вопрос, которым однозначно стоит поделиться с вами. Один студент работал над задачей, которая предполагает извлечение процента в заданном формате. Звучит легко, но все стало сильно сложнее, когда жажда знаний привела его к двум способам решения.

Получилось два варианта:

- Первый - concat - '+' || ROUND (price * 1.0, 2) || '%') orders_increase
- Второй - to_char - to_char((price * 1.0),'S9990D00%’) orders_increase2

❗️Они, конечно, немного изменены, чтобы не спойлерить решение, но отражают саму проблему.

Результат получился вроде бы одинаковым (см. под постом). Но при этом первое решение принималось, а второе - нет.

🤔 Есть идеи в чем дело?

Давайте разберемся вместе.

В первом методе сомнений нет, простой конкатенацией формат приводится к необходимому. А вот со вторым уже интереснее! Нужный шаблон заполнения 'S9990D00%' в to_char передали, а все равно решение не принимается.

Секрет здесь в том, что to_char дополняет строку пустыми заполнениями (пробелами) так, чтобы результат имел фиксированную ширину. Вы же заметили, что решения, по сути, различает только выравнивание? Это и есть то самое заполнение пробелами. Отсюда и несоответствие эталонному решению.

Так что же, смириться и не использовать to_char? Ну уж нет, так просто мы не сдадимся!

⁉️ Как исправить код, чтобы он заработал верно?

У to_char есть такая деталь, как модификаторы шаблонов, почитать можно тут. Они применяются, чтобы изменить поведение кода. И среди этих модификаторов нашлась такая приставка - FM, которая подавляет пустые заполнения, она передается прямо в шаблон - 'FMS9990D00%' И буквально двумя буквами мы сделали так, что код был принят!

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

Думаем, урок здесь ясен: даже небольшие технические детали могут сильно влиять на ваши вычисления. Так что, будьте любознательны и не бойтесь обращаться к документации. И если у вас когда-нибудь возникнет подобный вопрос, не стесняйтесь задавать нам в чат - мы любим головоломки!

#sql