Попытка №1. Путь в лоб: Классы и интерфейсы

Самый очевидный способ - создать родительский класс с переменными, а языки сделать его наследниками. Но это просто… фиаско. Даже если не писать from/toJson, процесс выглядит так:

1. Объявил переменную в родителе.
2. Прописал её в конструкторе.
3. Повторил то же самое для всех дочерних классов (всех языков).

Если бы я работал на аутсорсе в Индии и мне платили за количество строк кода - это был бы идеальный вариант. Но я хотел, чтобы одной строки при объявлении было достаточно.

Попытка №2. Стандарт (ARB/JSON)

Я поплевался, но решил попробовать - «стандарт» всё-таки. Мало ли, может чего поменялось за годы. Вроде всё завелось, но сам процесс… это боль. Бегать по разным файлам, чтобы добавить одну строчку - так себе удовольствие.

Почему я от него окончательно отказался? Когда данных становится реально много (десятки языков, тысячи строк), ты попадаешь в ловушку: тебе нужно эту махину либо целиком держать в памяти, либо постоянно подгружать и парсить. Ради смены одного слова на кнопке заставлять девайс ворочать тяжелые JSON-ы в рантайме - так себе затея для производительности.

Попытка №3. Таблицы и костыли

Подумал: «Окей, почему бы не подтянуть старый добрый CSV или вообще закинуть всё в табличку?». И тут официальный пакет локализации сказал: «Извини, мужик, тут наши полномочия всё».

Ну, я тоже не пальцем деланный. Решил припахать нейросеть, чтобы она написала мне собственный генератор. Флоу получился такой:

1. Добавляю строку в таблицу.
2. Запускаю генератор.
3. Он лепит «родительский» файл.
4. После Freezed генерит toJson, fromJson…

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

Красный флаг для программиста

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

Что происходит на практике? Когда ты пишешь код и тебе нужно добавить одну несчастную строку, тебе лень (читать: нехочется выходить из потока творения) запускать весь этот цикл с генерацией. Ты просто её хардкодишь в надежде «потом скопом всё добавлю одним махом». А «потом» наступает тогда, когда уже весь проект завален хардкодом, и вычищать его - то еще удовольствие. Даже нейросетки с такими запросами помогают не с первого раза, и с сомнительной эффективностью.

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

Эволюция лени: почему Enum победил интерфейсы

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

Моя философия проста: строку захардкодить - моментально. Добавление даже одной строки в другом файле требует доп. действий. НО, если действий минимум, то кодер поймет, что выигрыш во времени сейчас мизерный против больших потерь в будущем, и исправно добавит строку в правильное место. Этого не произойдет, если для добавления строки нужно «отчитаться» в десяти местах.

Попытка №4. Рекорды (Records)

Присматривался к рекордам. С ними удобно: не нужно писать конструкторы. Но есть подвох: как только ты добавил переменную в один язык, компилятор тут же сходит с ума и требует добавить её во все остальные прямо сейчас. Никакой гибкости и возможности оставить «на потом».

Идеальный костыль: Enum

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

Знаете, мне моё решение так понравилось, что я пошел к нейросетям и проверил его со всех сторон. Все модели остались в полном восторге. Под это дело я даже подготовил монументальную «нейро-статью» на полтора часа внимательного чтения, со всеми графиками, бенчмарками и анализом производительности.

Но потом я заглянул в правила Хабра, прислушался к голосу разума и понял: никто не хочет читать полтора часа сухой статистики. Лучше я просто расскажу вам свою историю «от первого лица», как я докатился до такой жизни. Ну, а если вы совсем уж фанаты цифр - просто скормите этот текст любой нейронке, она вам перескажет всё в лучших академических тонах с графиками на любой вкус.

А здесь мы будем говорить по делу.

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

Реализация

Принцип разделения:

• enum Strings → типизированный контракт (что существует).
• translator → источник данных (откуда берётся текст).

Структура файлов - минимальная. Никаких внешних зависимостей:

Ядро - strings.dart

Весь контракт локализации в одном enum. Два режима - хардкод switch и серверный кеш - за одним и тем же

. Даже сообщения об ошибках локализации — сами локализованы:

Список языков - languages_enum.dart

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

Хотите грузить с сервера? Одна строка + loader. И

- тоже одна строка, потому что

уже является registry:

Переводчик - i18n/russian.dart

Как это выглядит в жизни (и почему я перестал хардкодить) Я намеренно не привожу здесь код оберток виджетов или конкретных стейт-менеджеров. Всё это - чистая «вкусовщина». Для работы системы нужен лишь элементарный вещатель событий (Notifier), повешенный на метод смены языка.

Но главное - это мой ежедневный флоу. Сейчас, чтобы добавить строку в UI, я просто вызываю нужный мне ключ: Strings.someKey(). Без контекста, везде.

А если ключа еще нет? Я тупо иду в Strings и добавляю одну строчку в Enum. Всё.

Благодаря дефолтному конструктору, приложению абсолютно плевать, что у меня там еще 100 языков не переведены. Оно компилируется и работает здесь и сейчас. А дальше в дело вступают гит-хуки: при комите нейросетка сама подхватывает изменения и заполняет недостающие поля в переводчиках.

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

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

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

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

В этой статье мы рассказываем о типах массивов в PHP и об операциях, которые можно совершить над ними.

1. Типы массивов в PHP
2. Как создавать массивы в PHP
3. Как получить элемент массива в PHP по индексу
4. Как добавить элемент в конец массива PHP
5. Как удалить последний элемент массива PHP
6. Получение длины массива в PHP
7. Как проверить наличие элемента массива в PHP
8. Как выполнить обход массива в PHP и вывести его элементы
9. Как выполнить слияние массивов в PHP
10. Как сортировать массив в PHP

Типы массивов в PHP

1. Индексированные массивы

Это самый обычный тип массива в PHP, где элементы нумеруются целыми числами, начиная с 0, и последовательно увеличиваются.

2. Ассоциативные массивы

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

3. Многомерные массивы

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

4. Вложенные массивы

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

Как создавать массивы в PHP

1. Создание пустого массива

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

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

или

2. Создание индексированного массива

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

Использование числовых индексов позволяет эффективно обращаться к элементам массива по их позиции.

или

3. Создание ассоциативного массива

Ассоциативные массивы в PHP полезны, когда нужно хранить данные в виде пар “ключ” => “значение”.

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

Использование ключей позволяет быстро извлекать и обновлять значения в массиве по имени.

или

4. Создание многомерного массива

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

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

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

или

Как получить элемент массива в PHP по индексу

1. Оператор квадратных скобок []

Этот способ наиболее распространен и прост в использовании. Можно использовать оператор квадратных скобок [] и указать индекс элемента внутри них.

2. Функция array_values()

Данная функция возвращает все значения массива в виде нового массива, с индексами, начиная с 0. Затем можно получить элемент массива по новому индексу.

3. Функции current() и next()

Эти функции позволяют перемещаться по массиву и получать текущий элемент. Функция current() возвращает текущий элемент массива, а функция next() сдвигает указатель на следующий элемент.

Как добавить элемент в конец массива PHP

1. Использование оператора []

Самым простым способом является использование оператора квадратных скобок [] с пустым индексом, чтобы добавить элемент в конец массива.

2. Использование функции array_push()

Функция array_push() позволяет добавить один или более элементов в конец массива. Синтаксис функции следующий: array_push($array, $element1, $element2, ...).

3. Использование оператора +=

Еще одним способом является использование оператора +=, который объединяет два массива. Если левым операндом является пустой массив, то элементы будут добавлены в конец массива

Как удалить последний элемент массива PHP

1. Функция array_pop()

В результате выполнения этого кода последний элемент (“5”) будет удален из массива, а значение этого элемента будет сохранено в переменной `$lastElement`

2. Функция unset()

При использовании функции unset() вы указываете индекс последнего элемента массива, который нужно удалить, используя count($myArray) - 1. Это вычисляет индекс последнего элемента массива.

3. Оператор array_slice()

Оператор array_slice() возвращает часть массива, начиная с индекса 0 и заканчивая индексом -1 (или индексом последнего элемента минус единица). В результате получается массив без последнего элемента.

4. Функция array_splice()

Функция array_splice() изменяет исходный массив, удаляя элементы, начиная с указанного индекса. В данном случае мы указываем индекс -1, чтобы удалить последний элемент массива.

Получение длины массива в PHP

1. Функция count()

Функция count() возвращает количество элементов в массиве. В результате выполнения этого кода переменная $length будет содержать длину массива, то есть значение “5”.

2. Оператор sizeof()

Оператор sizeof() работает аналогично функции count() и также возвращает количество элементов в массиве.

3. Функция arraycountvalues()

Функция array_count_values() возвращает ассоциативный массив, где ключами являются уникальные значения из исходного массива, а значениями – количество вхождений каждого значения.

В данном случае мы используем count() для получения длины ассоциативного массива, чтобы узнать количество уникальных значений в исходном массиве.

4. Цикл foreach

Мы итерируемся по каждому элементу массива с помощью цикла foreach и увеличиваем переменную $length на 1 для каждого элемента. В результате выполнения этого кода длина массива будет сохранена в переменной $length.

Как проверить наличие элемента массива в PHP

1. Оператор in_array()

Оператор in_array() проверяет, содержится ли указанный элемент в массиве. В этом примере переменная $exists будет содержать значение true, так как элемент `3` содержится в массиве $myArray.

2. Функция array_search()

Функция array_search() возвращает индекс элемента в массиве, если он найден. Если элемент не найден, функция возвращает false.

В данном случае мы проверяем, не равен ли индекс false, чтобы определить, содержится ли элемент в массиве.

3. Функция array_key_exists()

Функция array_key_exists() проверяет, содержится ли указанный ключ в массиве. В этом примере переменная $exists будет содержать значение true, так как ключ 'key2' существует в массиве $myArray.

4. Оператор isset()

Оператор isset() проверяет, определен ли указанный элемент или ключ в массиве. В данном случае переменная $exists будет содержать значение true, так как элемент с ключом 'key2' определен в массиве $myArray.

Как выполнить обход массива в PHP и вывести его элементы

1. Цикл for

В этом примере мы используем цикл for, чтобы пройти через каждый индекс массива и вывести его элементы. Код echo $myArray[$i] . ", "; выводит каждый элемент массива, за исключением последнего, и добавляет запятую после каждого элемента.

2. Цикл foreach

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

3. Цикл while с использованием функций current() и next()

С помощью функции reset() мы устанавливаем указатель текущего элемента массива в начало. Затем, с помощью цикла while, мы получаем текущий элемент с помощью функции current(), выводим его и перемещаем указатель на следующий элемент с помощью функции next(). Цикл продолжается до тех пор, пока есть элементы в массиве.

Как выполнить слияние массивов в PHP

1. Оператор "+"

Оператор + объединяет элементы обоих массивов, и дубликаты удаляются, чтобы сохранить только уникальные значения.

Вывод:

2. Функция arraymerge()

Функция arraymerge() объединяет элементы обоих массивов в новый массив, сохраняя исходные ключи. Если есть одинаковые ключи, то значение из второго массива заменит значение из первого массива.

Вывод:

3. Оператор "…" в PHP 7.4 и более поздних версиях

С помощью оператора ... (spread operator) мы можем распаковать элементы массивов и объединить их в новый массив.

Вывод:

4. Функция arraymergerecursive()

Функция arraymergerecursive() объединяет элементы обоих массивов в новый массив, сохраняя все значения в виде массивов, если ключи совпадают.

Вывод:

Как сортировать массив в PHP

1. Функция sort()

Функция sort() сортирует массив в порядке возрастания, переиндексируя элементы массива.

Вывод:

2. Функция rsort()

Функция rsort() сортирует массив в порядке убывания, переиндексируя элементы массива.

Вывод:

3. Функция asort()

Функция asort() сортирует массив в порядке возрастания, сохраняя связь ключей и значений.

Вывод:

4. Функция arsort()

Функция arsort() сортирует массив в порядке убывания, сохраняя связь ключей и значений.

Вывод:

5. Функция ksort()

Функция ksort() сортирует массив по ключам в порядке возрастания, сохраняя связь ключей и значений.

Вывод:

6. Функция krsort()

Функция krsort() сортирует массив по ключам в порядке убывания, сохраняя связь ключей и значений.

Вывод:

Заключение

Массивы в PHP играют ключевую роль в хранении и управлении данными.

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

Надеемся, шпаргалка оказалась полезной вам, и вы узнали много нового.

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

ECMAScript ежегодно дополняется сообществом разработчиков JavaScript и соответствует стандартам ECMA International. Самые последние обновления ECMAScript включают в себя новые функции и методы, которые помогают разработчикам писать более гибкий и мощный код.

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

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

Вот, какие функции были добавлены в ECMAScript в 2023 году.

UPD: Рассказали, что планируется внедрить в ECMAScript в 2024 году.

1. Поиск элемента в массиве

Эта функция позволяет найти последний элемент массива, соответствующий заданному условию.

2. Грамматика Hashbang

Эта функция позволит нам использовать Hashbang/Shebang в некоторых CLI.

Shebang представлен #! и представляет собой специальную строку в начале скрипта, которая сообщает операционной системе, какой интерпретатор использовать при выполнении скрипта.

Строка #!/usr/bin/env node вызывает исходный файл Node.js напрямую как исполняемый файл.

Нам не понадобится строка #!/usr/bin/env node для явного вызова файла через интерпретатор узла, например, node ./file.

3. Символы-ключи в WeakMap

Теперь можно использовать уникальные символы в качестве ключей.

До этого обновления WeakMaps можно было использовать в качестве ключей только объекты. Объекты используются в качестве ключей для WeakMaps, потому что они имеют один и тот же аспект идентичности.

Symbol — это единственный примитивный тип в ECMAScript, который позволяет использовать для него уникальные значения. Использовать Symbol теперь можно и в качестве ключа вместо создания нового объекта с помощью WeakMap.

Здесь указаны другие варианты использования, связанные с ShadowRealms и Record & Tuples и с использованием символов в качестве WeakMaps.

4. Изменить массив через копирование

Обновление предоставляет дополнительные методы в Array.prototype для внесения изменений в массив, возвращая его новую копию с изменением вместо обновления исходного массива.

Новые введенные функции Array.prototype:

1. Array.prototype.toReversed()
2. Array.prototype.toSorted(compareFn)
3. Array.prototype.toSpliced (start, deleteCount, … items)
4. Array.prototype.with(index, value)

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

Удачного кодинга!

Разнообразие и сложность

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

Но во многом именно благодаря этому Unicode поддерживает все или почти все системы письменности, которые существуют в мире: на сегодня этот стандарт поддерживает более чем 1100 языков. Но его задача не только в том, чтобы вместить все возможные языки, но и в том, чтобы позволить им сосуществовать в одном тексте — это делает задачу ещё сложнее.

Тем не менее, разбираться в особенностях Unicode всё-таки следует любому программисту: подумайте о миллионах людей, которые смогут использовать ваше ПО на своем родном языке.

Кодовое пространство

Начнем с основ. Базовые элементы — это символы, хотя правильнее будет всё же использовать термин «кодовые точки». Кодовые точки определяются по шестнадцатеричному номеру и префиксу «U+». Например, U+0041 это латинская буква «A», а U+03B8 — греческая «θ». Каждая кодовая точка также имеет собственное название и ещё несколько характеристик, указанных в базе данных символов Unicode.

Множество всех возможных кодовых точек называется кодовым пространством. Кодовое пространство Unicode состоит из 1 114 112 кодовых точек. Но лишь 128 237 (12%) из них на самом деле являются занятыми: более чем достаточно места для роста. Юникод также резервирует 138 468 кодовых точек для «приватного использования», то есть для внутренних нужд различных приложений.

Распределение кодового пространства

Лучший способ что-то понять — использовать визуализацию. (Кстати, если вы хотите понять суть каких-нибудь алгоритмов, у нас есть для вас подборка сервисов с визуализацией алгоритмов.) Ниже представлена карта всего кодового пространства, каждый пиксель соответствует одной кодовой точке. Для удобства карта поделена на поля (маленькие квадраты) размером 16×16 = 256 кодовых точек. Каждое большое поле содержит 65 536 кодовых точек. Всего существует 17 больших полей.

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

Первое большое поле называется «Базовое мультиязычное поле». Оно содержит почти все символы, которые используются в современных текстах, включая латинские буквы, кириллицу, греческий, китайский, японский, корейский и так далее. В своей первой версии Unicode состоял только из этого поля и был расширен лишь в 1996 году.

Второе поле содержит исторические и специальные символы, например, сумерийскую клинопись, египетские иероглифы и эмодзи. Третье поле содержит небольшое количество менее известных китайских символов. Остальные поля остаются пустыми, не считая небольшого количества редко используемых символов форматирования в 15 поле. Поля 16-17 целиком в приватном использовании.

Языки, поддерживаемые Unicode

Давайте сосредоточимся на первых трех полях, именно там происходит всё самое интересное:

Эта цветная карта обозначает 135 различных языков юникода. Китайский (бирюзовый) и корейский (коричневый) занимают основную часть базового поля (левый большой квадрат). Для сравнения, все европейские, средневосточные и южноазиатские языки вместились в первую строку базового поля.

По частоте использования в реальном мире лидирует первое поле, исключением являются эмодзи — они завоевали наши сердца, находясь во втором поле.

Кодировки

Как вы узнали раньше, кодовые точки задаются номерами с U+0000 по U+10FFFF. Но как эти номера хранятся в реальной памяти компьютера? Использование первого, что приходит в голову — обычного 32-битного целочисленного типа — было бы очень ресурсоемким и не оправданным. Нам понадобилось бы по 4 байта на каждую кодовую точку. Поэтому тут на помощь нам приходят стандарты кодирования UTF — Unicode Transformation Format.

Некоторые программисты считают, что Unicode и UTF — это разные вещи, но на самом деле UTF-8, UTF-16 и UTF-32 являются лишь стандартами преобразования UTF, которые позволяют значительно сэкономить память и повысить скорость обработки.

Например, в UTF-8 символы с кодами меньше 128 представляются всего одним байтом, а так как в Юникоде они повторяют ASCII, то текст, написанный только этими символами, будет являться текстом в ASCII — это позволяет избежать лишних конвертаций. Символы же с кодами от 128 до 65536 кодируются 2-мя байтами, аналогично существуют 3-байтные и 4-байтные коды.

Смысл UTF-16 и UTF-32 в том, чтобы представить ещё большую часть Unicode как обычную таблицу, подобную ASCII. Например, UTF-32 — это и есть большая таблица ASCII для всего юникода, но в 99% случаев хватает и UTF-8.

Комбинации знаков

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

Например, букву под ударением (Á) можно описать таким образом: U+0041 (A) + U+0301 (`).

Видели в интернете м̵͉̪̫̳̖͌͋͗͌̑̎а̬̜ͣͤг̘͎̹̜͕̤͊̊̽и͕̽͌ͮͬ͡ю͉͑̏ ̛̹̬̜̪̳̹̙̿̄͋̏т̹̫͚̱̩ͅи̼̬̤̓͒ͨ̅́́̚̚п̗̔̒ͧ̇ͩ̐̔а̺̄͆ͭ ̢̜͉̮̭͚ͬ͒͐̈̚т̛̦̖͎̪̭͇̓а̛͙̳̼̺̲̜̂ͮͦ̈́̃̈́ͣк̳̘̝̔́о͉̜̆̈́й͉͍̜͛͆́̀? Она создается именно с помощью комбинации знаков.

И это только начало

Эта статья содержит более 5 000 символов, но на самом деле является лишь верхушкой айсберга. Юникод полон других сложных вещей: чего стоят одни только применения (mapping), сопоставления (collation) и двунаправленный текст. Но и это далеко не всё.

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

Если хотите узнать больше, то можете прочитать следующие материалы:

• Стандарт;
• Манифест «UTF-8 везде»;
• Темная сторона юникода;
• Google Noto Fonts — шрифты, покрывающие весь спектр Unicode.

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

Спасибо, юникод.

Дополнительно:
Как изменится решение, если известно, что таких индексов в массиве несколько?

Решение

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

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

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

При бинарном поиске мы берем элемент k и сравниваем его с элементом из середины массива, x, чтобы определить, по какую сторону от x находится искомого k — слева или справа. Давайте попробуем определить, где может находиться «волшебный» элемент на примере. Взгляните на массив (нижняя строка — индексы элементов):

Если взять элемент из середины массива, A[5] = 3, то становится ясно, что «волшебный» элемент должен находиться правее, так как A[mid] < mid. Почему в этой ситуации элемент не может быть слева? Индекс элемента в данном случае уже больше значения (5 > 3). Значит, все значения элементов с индексами 0-4 будут меньше самих индексов.

При движении в направлении от i к i-1 значение элемента будет уменьшаться не менее чем на 1 (так как массив отсортирован и не содержит одинаковых элементов). Если средний элемент меньше искомого, то при движении влево, смещаясь на k индексов и (как минимум) на k значений, мы будем попадать на еще более маленькие значения.

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

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

Дополнительно: как изменится решение, если таких индексов окажется несколько?

Если элементы массива повторяются, то наш алгоритм не будет работать. Давайте рассмотрим следующий массив:

Если A[mid] < mid, сказать заранее, где будут находиться «волшебные» элементы, становится сложнее.

Могут ли в этом массиве они находиться слева? Нет. Так как A[5] = 3, мы знаем, что A[4] никак не может быть «волшебным» элементом. A[4] должен быть равен 4, но в то же время мы знаем, что A[4] не может быть больше, чем A[5], из-за условия отсортированности.

Фактически, если мы видим, что A[5] = 3, нам достаточно проанализировать только правую сторону, как это и делалось раньше. Но чтобы найти элемент в левой части, можно пропустить группу элементов и произвести поиск только среди A[0] ‒ A[3], где A[3] — это первый элемент, который может быть «волшебным».

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

• Левая сторона: поиск среди элементов от start до Math.min(midIndex - 1, midValue).
• Правая сторона: поиск среди элементов от Math.Max(midIndex + 1, midValue) до end.

Если же переданы ошибочные параметры, пусть код возвращает -1.

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

Этот код работает в том числе и для случая без дополнительного условия.

Как вы, наверное, знаете один из принципов в Python: “Должен быть один и только один способ сделать что-либо”. Можете убедиться в этом, выполнив в в интерпретаторе import this (вы увидите Дзен Python). Несмотря на это, иногда вам всё равно приходится выбирать между несколькими способами сделать что-то, и не всегда очевидно, какой способ лучше. Недавно один студент спросил меня, какой способ конкатенации строк в Python самый эффективный. Я решил поделиться результатом своего маленького исследования и с вами.

Для начала вспомним, какие способы объединения строк предоставляет нам Python. Во-первых, это оператор +:

Также мы можем использовать оператор %, который, конечно, может использоваться не только для соединения строк, но и для этого тоже:

Есть и ещё более современная замена % — это str.format:

Так же, как и %, этот метод гораздо мощнее, чем обычный +, но тем не менее строки соединяют и с его помощью.

Как же мы будем замерять время? В Jupyter (так же известном, как IPython) мы можем использовать магическую команду timeit для запуска кода. Для запуска я подготовил четыре функции, каждая из которых складывает строки разным образом. Исходные строки хранятся в глобальных переменных (x и y), а локальная (для каждой функции) переменная z содержит результат сложения. Затем функция возвращает результат.

Конечно concat3() и concat4() фактически одинаковы, но я решил проверить и то, влияет указание порядка строк на скорость или нет. Затем я определил наши глобальные переменные:

И запустил наши функции:

Результат оказался следующим:

• concat1: 153 наносекунды;
• concat2: 275 наносекунд;
• concat3: 398 наносекунд;
• concat4: 393 наносекунды.

Здесь мы можем видеть, что concat1(), который использует оператор +, выполняется гораздо быстрее остальных. Это немного расстроило меня, потому что мне очень нравится str.format, однако теперь в задачах, которые требуют огромного количества обработки строк, от него придётся отказаться.

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

Теперь мы получим следующие результаты:

• concat1: 2.64 микросекунды;
• concat2: 3.09 микросекунды;
• concat3: 3.33 микросекунды;
• concat4: 3.48 микросекунды;

Да, каждый из методов теперь работал гораздо дольше, однако общий результат не изменился — оператор + по прежнему лидирует. Заметим так же, что разница во времени между третьим и четвёртым методом, как и ожидалось, пренебрежимо мала.

После этого я попробовал не объявлять переменные глобальными, а задавать их в теле метода, но на результаты это всё равно не повлияло. Разумеется, можно проводить ещё много разных опытов (например, попробовать сложить больше, чем две строки), однако этого уже достаточно, чтобы иметь примерное представление о скоростях работы различных способов сложения строк в языке Python.