Дмитрий Беляев

Потому что enum в typescript может мержиться:
Валидный код:

enum Membership {
  Simple,
  Standart,
  Premium
}

enum Membership {
  SimpleX = 99
}

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

парень. Всё равно ты будешь использовать ту терминологию, которую используют на работе. Если там под замыканием подразумевается замыкание с инкапсуляцией, то после того как тебе сказали что "твой код - говно", было два варианта: 1)поговорить о терминах либо со ссылкой на официальную документацию, либо вместо с собеседником вывести определение исходя из смысла понятия, не прибегая к авторитетам вообще. 2) Сказать о том, что прочитал такое определение у %авторитет%, и сказать, что готов использовать то, которым пользуетесь вы на работе.

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

Есть второй вариант: собеседник тебе говорит: "Ахтунг! Замыкание используется не просто для того, чтобы спасти переменную от удаления! Это ещё и способ сокрытия данных: замыканием можно использовать локальную глобальную переменную, вместо того чтобы использовать просто глобальную переменную, или же городить отдельный класс."
В этом случае всё твое определение идёт в пешее эротическое, и ты соглашаешься, что для этого придётся обернуть функцию в функцию, чтобы у тебя была функция с локальными переменными, которые будут глобальными для этой функции в функции.

Какой-то идиот задачу составлял.
Во-первых, для N<60 ответ помещается в 64-битный целочисленный тип, который есть сейчас практически во всех языках программирования. Тут не надо ничего придумывать для избегания переполнения.
Во-вторых, чтобы избежать переполнения, в таких задачах обычно просят выдать ответ по какому-то большому модулю. И последнее, как ответ может получиться нецелым - это просто загадка. Пример решения явно неверен.

А так, динамическое программирование тут простое: Пусть F(N,K) - сколько существует невзрывоопасных стопок длины N, таких что в конце есть ровно K опасных контейнеров (очевидно, 0 <= K < 4). Это не совсем прям то, что вам нужно в задаче, но количество опасных стопок - это количество всех стопок (2^N) минус количество невзрывоопасных, поэтому это ДП нам подходит.

Пересчет очень прост:

F(N,K>0) = F(N-K,0)
F(N,0) = F(N-1,0)+F(N-1,1)+F(N-1,2)+F(N-1,3)

Если на конце K плохих контейнеров, то до этого точно должен быть хороший контейнер. Если на конце стоит хороший контейнер - то до него может быть 0..3 плохих контейнера.

База: F(0,0) = 1, F(0, K>0) = 0

Ответ: 2^N - F(N,0)-F(N,1)-F(N,2)-F(N,3)

Непонятно, в чём проблема.
При активации подписки в БД заносим время завершения подписки, например `subscriptionEndTime` = NOW() + INTERVAL 30 DAY.
При проверке просто сравниваем текущее время и сохранённое,

`subscriptionEndTime` > NOW() AS `isSubscriptionActive`

.
А попытка переложить проверку на клиента заведомо неправильная. Никто не мешает пользователю слегка поправить код и просто игнорировать проверку.

RTFM.
https://nominatim.org/release-docs/develop/api/Reverse/

Language of results
accept-language=<browser language string>
Preferred language order for showing search results, overrides the value specified in the "Accept-Language" HTTP header. Either use a standard RFC2616 accept-language string or a simple comma-separated list of language codes.

Лучший клиент git

Лучший клиент git - это консольный.

Лучший клиент git - это дело вкуса каждого. Нравится вам TortoiseGit, так используйте его. Не нравится - ищите что-то лучшее.

А что имеете в виду

но есть что-нибудь лучше?

Однозначно Delphi! Без вариантов!

Главная идея принципа инверсии зависимостей "детали зависят от абстракций, но не абстракции от деталей".
В приведенном вами примере класс Main зависит от всего: от интерфейса INumberOperation и от обоих классов NumberOperation1, NumberOperation2. То есть тут принцип инверсии зависимостей вообще не работает. Никак.

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

interface NumberInput {
  int read();
}
interface NumberProcessor {
  int process(int a);
}
interface NumberOutput {
  void write(int a);
}
class Processor {
  private final NumberInput input;  
  private final NumberProcessor processor;
  private final NumberOutput output;

  public Processor(NumberInput input, NumberProcessor processor, NumberOutput output) {
    this.input = input;
    this.processor = processor;
    this.output = output;
  }

  void process() {
    output.write(processor.process(input.read()));
  }
}

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

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

Этот принцип очень хорошо объяснен в книге Р.Мартина "Чистая архитектура", по крайней мере у меня все встало на свои места именно после прочтения этой книги.

let op = [];
for(let i = 0; i < 10; i++){
  op[i] = "blabla";
}

alert(op[2]);

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

Нет, обобщенные типы можно использовать не только в функциях

type SomeData<Data = any> = {
    data: Data[];
}
const a: SomeData<number> = {data: [1,2,3]};

Есть хорошая статья: https://habr.com/ru/post/274485/

У строковых литералов тип &'static str. Тоесть это заимствованная ссылка на объект с неограниченным временем жизни.
А to_string возвращает уже owned строку типа std::string::String

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

Если ты хочешь получить именно String из строкового литерала, то есть сразу несколько вариантов, включая показанный:

let a: String = String::from("a");
let b: String = "b".to_string();
let c: String = "c".into(); // или "c".into::<String>(), если не указывать тип явно.
let d: String = "d".to_owned();