🤔 Что случилось?

4-го января 2022-го года разработчик популярной NPM-библиотеки с открытым исходным кодом Faker.js внезапно удалил исходный код с GitHub и NPM. Версия пакета обновилась до 6.6.6, а в README было написано: “Что на самом деле случилось с Аароном Шварцем?”

Недельное количество установок Faker.JS (более 2.5 миллионов) превышает количество установок Vue.JS (более 2.3 миллионов)

7-го января разработчик Faker.JS сообщил в Twitter-е, что NPM без его ведома восстановила все предыдущие версии Faker.JS, а GitHub и вовсе заблокировал его аккаунт. Он потерял доступ к более 100 приватным репозиториям.

😓 Кто такой Аарон Шварц?

Аарон Шварц — легендарный программист, создавший RSS, Markdown, авторское право Creative Commons, а также платформу, позже взятую за основу социальной сети Reddit.

«Информация — это власть. Но, как случается со всякой властью, есть те, кто хочет, чтобы она была только у них. Горстка частных корпораций все активнее оцифровывает мировое научное и культурное наследие, на протяжении веков публиковавшееся в книгах и журналах, чтобы его спрятать ото всех, — писал Шварц. — Они говорят о воровстве, пиратстве, как будто обмен знаниями может быть моральным эквивалентом ограбленного судна с убитым экипажем. Делиться не аморально — напротив, это моральный императив (…). Берите информацию, где бы она ни хранилась, копируйте и распространяйте. Берите документы без авторских прав и добавляйте в архивы. Покупайте секретные базы и публикуйте в интернете. Скачивайте научные журналы и публикуйте их на файлообменниках»

Последние полтора года Аарон Шварц находился в тюрьме за нелегальное скачивание более 4 млн документов из базы данных JSTOR — архива академических журналов и научных работ. Хотя JSTOR — некоммерческая цифровая библиотека, и документы доступны бесплатно в онлайне, но некоторые клиенты платят по 10 центов за документ, если пользуются специальным интерфейсом.

JSTOR отказалась от претензий к Шварцу, но прокуратура приняла решение продолжить дело. В сентябре 2012-го ему грозило 50 лет тюремного заключения, но в январе 2013-го года он совершил самоубийство.

Что же на самом деле случилось с Аароном — отдельная тема для обсуждений. Основатель опубликовал в своём Twitter фрагмент из обсуждения этой темы в Reddit.

🤕 Темная сторона Open Source

Автор Faker.JS, удалив одну из самых востребованных JavaScript-библиотек, напомнил миру о проблеме разработчиков открытого исходного кода, где крупные коммерческие корпорации (например, практически все из списка Fortune500) используют Open Source труд, не возвращая ничего взамен. И в результате получается, что многие разработчики работают за спасибо или под грузом ответственности за свой более ранний труд.

Каждый будет делать свои выводы из этой истории, которая ещё не закончилась. Поделитесь этой новостью, чтобы больше людей знало тёмную сторону Open Source.

К примеру, у вас есть массив list_of_ints, содержащий числа {-10, -10, 1, 3, 2}. Функция, которая обрабатывает этот массив, должна вернуть 300, так как (-10) * (-10) * 3 = 300. Задание нужно выполнить максимально эффективно, не забывая про отрицательные числа.

Алгоритм решения

Методов решения много, но не так просто добиться O(n) времени выполнения и O(1) затрат памяти. Для эффективного решения задачи мы создадим и будем наблюдать за состоянием следующих переменных:

• highest_product_of_three
• highest_product_of_2
• highest
• lowest_product_of_2
• lowest

Когда мы пройдемся по массиву до конца, в highest_product_of_three будет содержаться наш ответ, а остальные переменные мы используем как временный буфер. highest_product_of_2 и lowest_product_of_2 будут содержать наибольшее произведение из двух и наименьшее произведение из двух соответственно, а проходя по массиву, мы будем проверять произведение текущего числа current с этими переменными (отрицательный current с lowest_product_of_2 и положительный с highest_product_of_2). highest и lowest нам нужны для запоминания минимального и максимального чисел в массиве.

Реализация

Специально для вас, реализация описанных выше действий на Python:

def highest_product_of_3(list_of_ints):
    # Проверим, чтобы в массиве было 3 и больше чисел.
    if len(list_of_ints) < 3:
        raise Exception('Less than 3 items!')

    # Мы начнем с 3-его элемента массива (с индекса 2),
    # так как первые 2 элемента уже сразу пойдут
    # в highest_product_of_2 и lowest_product_of_2.
    highest = max(list_of_ints[0], list_of_ints[1])
    lowest =  min(list_of_ints[0], list_of_ints[1])
    highest_product_of_2 = list_of_ints[0] * list_of_ints[1]
    lowest_product_of_2  = list_of_ints[0] * list_of_ints[1]

    # Также вычислим highest_product_of_three из первых 3-х элементов.
    highest_product_of_three = list_of_ints[0] * list_of_ints[1] * list_of_ints[2]

    # Начинаем проход по массиву с индекса 2.
    for current in list_of_ints[2:]:

        # проверяем возможность увеличить highest_product_of_three
        # или оставляем его как есть.
        highest_product_of_three = max(
            highest_product_of_three,
            current * highest_product_of_2,
            current * lowest_product_of_2)

        # То же самое проверим и на максимальном произведении из двух.
        highest_product_of_2 = max(
            highest_product_of_2,
            current * highest,
            current * lowest)

        # И на минимальном произведении из двух.
        lowest_product_of_2 = min(
            lowest_product_of_2,
            current * highest,
            current * lowest)

        # Появилось ли новое максимальное число?
        highest = max(highest, current)

        # Появилось ли новое минимальное число?
        lowest = min(lowest, current)

    return highest_product_of_three

Сложность алгоритма

Производительность

Сложность алгоритма — O(n) по времени выполнения и O(1) по памяти.

Спасибо за внимание!

Источник: InterviewCake

фотка не моя :)

Мини-история этой статьи

Готовился я к финалу Республиканской Олимпиады по информатике (среди школьников): повторял ужасно много тем, такие как графы, динамическое программирование (ДП), теория чисел…

Решал все задачи, которые только попадались мне, не обращая внимания на уровень сложности: и простые, и сложные. Натыкался и на задачи формата: “Даны числа A и B. Напишите программу, которая выводит на экран НОД(A,B)”.

Задача простая, решил её тогда одной строчкой.

В один такой прекрасный день участник одной телеграм-группы по программированию попросил меня найти ему какие-нибудь простенькие задачки утверждает, что “начал он заниматься кодингом совсем недавно”. Я отправил ему 10-15 задач среднего уровня, одной из которых была та самая: задача про наибольший общий делитель.

Проходит время, он мне пишет, что задачи и вправду интересные, вот только не может решить он почему-то лишь одну задачу. “Я отправляю решение, но только из 30 тестов проходит только 25. На остальные тесты идет превышение по времени.”

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

#include <iostream>
using namespace std;
int main() {
    long long a, b;
    cin >> a >> b;
    for (long long i = a; i >= 1; i--) {
        if (a % i == 0 && b % i == 0) {
            cout << i << endl;
            return 0;
        }
    }
    cout << 1 << endl;
    return 0;
}

Что ж, неудивительно, что последние пять тестов не проходит. Ведь там же большие числа, а узнать их НОД линейным путём, как написано в коде выше, не совсем уж и рационально.

И тут я подумал, а сколько всего существует такого рода способов? Решил погрузиться в эту тему и остановиться на 8-ми случаях: от самых “наивных” до быстрых и интересных.

Прежде, чем начать…

1. Будем писать код НОД в виде функции.
2. Не будет использовать int. Будем использовать long long, ибо использовать в таком случае 10^9, когда есть 10^18 немного…

Функции будем называть long long gcd_variant_[номер_нашего_способа](long long a, long long b). Имя функции gcd от англ. Greatest Common Divisor — НОД.

Прочитав некоторые статьи про НОД, понял, что в коде я не стоит использовать библиотечные функции, чтобы максимальный объём кода был контролируемым. Хотя я был бы не против использовать min() и max(), но так как мы будем измерить время работы алгоритмов, лучше будем писать их вручную.

Вариант 1. Перебираем от произвольного числа

long long gcd_variant_1(long long a, long long b) {
    for (long long i = a; i >= 1; i--) {
        if (a % i == 0 && b % i == 0) {
            return i;
        }
    }
    return 1;
}

Идея вышепоказанного алгоритма очень проста: гоним переменную цикла от первого числа до 1. Если оба числа делятся на переменную цикла без остатка, значит переменная цикла и равна НОД, а это означает, цикл можно завершить досрочно. Если цикл прошёл до конца, значит для этих чисел НОД равен 1.

На первый взгляд недостатков у этого кода нет. Однако, как нам известно, НОД двух чисел всегда бывает меньше этих самых чисел. Что будет если я сначала введу большее число, а затем - меньшее? Правильно, мы будем терять драгоценное для нас время! Поэтому начинать цикл от большего числа не имеет смысла.

Вариант 2. Перебираем от минимального числа

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

long long min_function(long long a, long long b) {
    if (a > b) return b;
    return a;
}

long long gcd_variant_2(long long a, long long b) {
    for (long long i = min_function(a, b); i >= 1; i--) {
        if (a % i == 0 && b % i == 0) {
            return i;
        }
    }
    return 1;
}

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

Вариант 3. Пишем алгоритм с разложением на делители

1-ый и 2-ой варианты мы писали перебором. Неужели мы не способны на большее?

В школе нам говорят, что НОД можно найти, разложив числа на простые множители:

a = p₁^α₁ × p₂^α₂ × p₃^α₃ × ... где pᵢ - простые числа

А НОД будет равен произведению простых множителей, общих для обоих чисел. К примеру:

A = 2³ × 3² × 5¹
B = 2² × 3¹ × 7¹

следовательно, НОД(A,B) = 2² × 3¹ = 12

Можем ли мы всё это реализовать в коде? Конечно!

long long gcd_variant_3(long long a, long long b) {
    long long result = 1;

    for (long long i = 2; i <= min_function(a, b); i++) {
        while (a % i == 0 && b % i == 0) {
            result *= i;
            a /= i;
            b /= i;
        }
    }

    return result;
}

Ну неплохо! Но кажется, что со скоростью этой программы хватает желать лучшего. Интересно, а что говорит на этот счёт Google? (О, а есть Википедия!)

Мм, там описано нахождение НОД через каноническое разложение на простые множители, которое мы уже реализовали. Так стоп! Мы нашли ещё один способ.

Вариант 4. Пишем Алгоритм Евклида (рекурсивный)

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

Ну что ж, давайте напишем пока рекурсивный метод:

long long gcd_variant_4(long long a, long long b) {
    if (b == 0) return a;
    return gcd_variant_4(b, a % b);
}

Считается, что такого рода алгоритмы (рекурсивные) менее эффективны, чем итерационные, за счёт накладных расходов на вызов функции. Для проверки делаем и итерационный вариант:

Вариант 5. Пишем Алгоритм Евклида (итерационный)

long long gcd_variant_5(long long a, long long b) {
    while (b != 0) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

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

Вариант 6. Пишем Бинарный алгоритм (рекурсивный)

Нашел я также в просторах Интернета (вернее, опять в Википедии) такое понятие, как Бинарный алгоритм Евклида.

Правила:

• НОД(0, n) = n; НОД(m, 0) = m; НОД(m, n) = НОД(n, m)
• НОД(1, n) = 1
• если m и n чётные то НОД(m, n) = 2×НОД(m/2, n/2)
• если m чётное n нечётное то НОД(m, n) = НОД(m/2, n)
• если m нечётное n чётное то НОД(m, n) = НОД(m, n/2)
• если m и n нечётные и m > n то НОД(m, n) = НОД((m-n)/2, n)
• если m и n нечётные и m < n то НОД(m, n) = НОД(m, (n-m)/2)

Напишем в первую очередь рекурсивную версию:

long long gcd_variant_6(long long a, long long b) {
    if (a == 0) return b;
    if (b == 0) return a;
    if (a == 1 || b == 1) return 1;

    if (a % 2 == 0 && b % 2 == 0) {
        return 2 * gcd_variant_6(a/2, b/2);
    }

    if (a % 2 == 0 && b % 2 == 1) {
        return gcd_variant_6(a/2, b);
    }

    if (a % 2 == 1 && b % 2 == 0) {
        return gcd_variant_6(a, b/2);
    }

    if (a > b) {
        return gcd_variant_6((a-b)/2, b);
    } else {
        return gcd_variant_6(a, (b-a)/2);
    }
}

Но рекурсивные функции менее эффективны, чем итерационные…

Вариант 7. Пишем Бинарный алгоритм (итерационный)

Итерационная версия:

long long gcd_variant_7(long long a, long long b) {
    long long shift = 0;

    if (a == 0) return b;
    if (b == 0) return a;

    while (((a | b) & 1) == 0) {
        shift++;
        a >>= 1;
        b >>= 1;
    }

    while ((a & 1) == 0) a >>= 1;

    do {
        while ((b & 1) == 0) b >>= 1;

        if (a > b) {
            long long temp = a;
            a = b;
            b = temp;
        }
        b = b - a;
    } while (b != 0);

    return a << shift;
}

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

Вариант 8. Пишем Бинарный алгоритм (итерационный), но используя битовые операции

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

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

long long gcd_variant_8(long long a, long long b) {
    long long shift = 0;

    if (a == 0) return b;
    if (b == 0) return a;

    while (((a | b) & 1) == 0) {
        shift++;
        a >>= 1;
        b >>= 1;
    }

    while ((a & 1) == 0) a >>= 1;

    do {
        while ((b & 1) == 0) b >>= 1;

        if (a > b) {
            long long temp = a;
            a = b;
            b = temp;
        }
        b = b - a;
    } while (b != 0);

    return a << shift;
}

Ну… А что насчёт скорости?

Компилировал на CodeBlocks под 64 битной Windows.

Среднее время для 500 пар случайных чисел:

1. перебор от произвольного числа: 0.4835 сек
2. перебор от минимального числа: 0.486 сек
3. с разложением на делители: 0.0062 сек
4. алгоритм Евклида рекурсивный: 0.0007 сек
5. алгоритм Евклида итерационный: 0.0009 сек
6. бинарный алгоритм рекурсивный: 0.0006 сек
7. бинарный алгоритм итерационный: 0.0003 сек
8. бинарный алгоритм итерац. со сдвигом: 0.0002 сек

Как и ожидалось первый алгоритм (который писал мой товарищ) катастрофически неэффективен и неудивительно, что тогда последние 5 тестов не прошли.

Выводы

• Первый пришедший на ум алгоритм решения какой-то задачи часто не будет оптимален. Хотя и может правильно и достаточно приемлемо работать в определённых условиях.
• Учите математику! Обещаю, Вы не пожалеете.
• Всегда надо попробовать подумать над улучшением алгоритма (или над альтернативным вариантом).
• Не придумывайте велосипед! Посмотрите что сделали люди до вас.
• Оптимизируйте код!

Ах да, спортивное программирование…

Внимательные сейчас спросят: “А вот выше ты писал, что решил задачу одной строчкой?”

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

А использую я обычную функцию STL __gcd. А вот и моё решение:

#include <bits/stdc++.h>
using namespace std;

int main() {
    long long a, b;
    cin >> a >> b;
    cout << __gcd(a, b) << endl;
    return 0;
}

Спасибо огромное за то, что уделили время прочтению этой статьи. До новых встреч!