Mrrl

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

В первую очередь - это формальное определение алгоритма. Задача считается алгоритмически разрешимой тогда и только тогда, когда её решение можно запрограммировать на машине Тьюринга (или каким-нибудь другим эквивалентным способом). Это определение даёт, например, возможность предъявить алгоритмически неразрешимые задачи. Позволяет ввести понятие "Тьюринг-полного" языка - если на языке можно реализовать машину Тьюринга, то на нём можно написать любой алгоритм (язык С таким не является, а C# - является).
В общем, МТ - способ определить некоторый класс алгоритмов:
- некоторые задачи можно решить конечным автоматом;
- для некоторых потребуется конечный автомат со стековой памятью;
- для других достаточно машины Тьюринга;
- для остальных требуется божественное откровение или другие неалгоритмизируемые методы.

Предположим, что числа нужны целые неотрицательные. Если числа могут быть нулевыми, делаете так:
n1=irand(501); // от 0 до 500
n2=irand(501); // от 0 до 500
n3=irand(501); // от 0 до 500
sort(n1,n2,n3); // сортируете по возрастанию любым подходящим способом
x0=n1; x1=n2-n1; x3=n3-n2; x4=500-n3;

Если числа могут быть только положительными, то поступаете аналогично:
n1=irand(497); // от 0 до 496
n2=irand(497); // от 0 до 496
n3=irand(497); // от 0 до 496
sort(n1,n2,n3); // сортируете по возрастанию любым подходящим способом
x0=n1+1; x1=n2-n1+1; x3=n3-n2+1; x4=496-n3+1;

Распределение будет слегка неравномерным (наборы, содержащие нули в первом случае и единицы - во втором, будут встречаться чуть реже), но и это можно исправить, слегка усложнив программу.

Зависит от статистики обращений.
Если проверки идут намного чаще, чем изменения массива - то переменная. Причём при "удалении" цифры придётся не просто очищать ячейку, а пройтись по всему массиву - нет ли там ещё одной такой цифры.
Если проверки и изменения идут сериями (много изменений - много проверок), то две переменных. В одной - индекс, в другой признак того, не испортился ли он. Тогда при проверке с "испортившимся" индексом придётся пройтись по массиву и посмотреть, где теперь цифра. Хотя можно просто проверить, что лежит сейчас в ячейке с индексом. Если не нужная цифра - новый проход по массиву. Но здесь уже надо смотреть, какая ячейка портится чаще - та, в которой цифра появилась раньше всего, или та, где она появилась позже всего.
Если проверки идут достаточно редко, то цикл.
В сложных случаях - когда в массиве не 10, а 1000 ячеек, цифр может быть много, меняются они часто, и нужно часто проверять, есть ли цифра, и где именно - надо будет хранить индексы ячеек с этими цифрами в какой-нибудь структуре. Например, в двусвязном списке, построенном на двух массивах, параллельных рабочему. Тогда все изменения и проверки будут работать за O(1).
В общем, всё зависит от ситуации.

В первом случае варианты не эквивалентны. При a=3, b=4 в первом варианте CallMe() вызовется дважды, а во втором - только один раз.
Первый вариант написан оптимально. Чтобы заставить его вести себя, как второй вариант (с одним вызовом CallMe()), достаточно вставить else:

if(a == 3)    CallMe();
else if(b == 4) {
    CallMe();
    Giveme();
}

Это будет оптимально по времени. Если же вместо CallMe() стоит более сложный вызов или длинный блок, и вас волнует длина кода (например, на микроконтроллере), то берите второй вариант. Если при этом и общее условие сложнее, чем b==4, то придётся его запомнить:

bool cond1=(sin(x)>=sin(y));
if(cond1 || cos(x)<cos(y)) Draw(tan(x),tan(y));
if(cond1) CloseLine();

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

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

Если a и b глобальные, то лучше сделать одну глобальную функцию, которая на них будет смотреть:

int CmpAB(int same,int diff){ return a==b ? same : diff; }

и положить её рядом с переменными. Потом туда же перетаскивать и другие обращения к ним. Глядишь, и соберётся класс с какими-нибудь осмысленными свойствами.
return - вещь хорошая, но если возвращать значение, то в нём должен быть смысл. Ради сокращения пары скобок придумывать тип возврата не стоит. Так что

if(a == b){
   print("test");
   return;
}
// код, если a != b

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

Не очень понятно, зачем здесь Z. Если 1000 структур помещается в памяти, и мы их можем отсортировать, то казалось бы - читаем из файла 10 раз по 1000 структур (по порядку, за один проход), каждый раз структуры сортируем и в отсортированном порядке помещаем в новый файл. Всего получается 10 файлов. Дальше - обычный merge. Кстати, слить можно сразу все 10 файлов, если их можно открыть одновременно. Если нет - сливаем два самых маленьких файла, пока не останется один (выгодно, чтобы сливаемые файлы были примерно одинакового размера - как группы символов в коде Хаффмана).
Возможно, Z придумали, чтобы файлы были не совсем одинаковыми, чтобы алгоритм не закладывался на одинаковость размера. Но тогда лучше было бы, например, "случайное число от 500 до 1000". В любом случае, если брать не максимум, то алгоритму только хуже.

А вам нужно удалить всех людей, или одного оставить?
Во втором случае накапливаете множество имён, и если у очередного человека имя принадлежит множеству, его удаляете. Если не принадлежит - добавляете в множество имён.
Если надо удалить всех Иванов:
- заводите два множества: имена, которые встретились, и имена, которые встретились более одного раза.
- в цикле по таблице: если очередного имени в первом множестве нет, добавляете его туда, а если есть - добавляете во второе множество.
- удаляете из таблицы всех людей, имена которых есть во втором множестве.

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

UPD. Можно вспомнить одно место, где комбинаторика требуется в обычных задачах. Это когда у нас есть множество каких-нибудь подмножеств, перестановок, слов над алфавитом, или ещё чего-нибудь, что обычно считает комбинаторика. И мы хотим по элементу этого множества найти его индекс. И наоборот.
Задача возникает не часто, но если возникла, то без комбинаторных формул не обойтись никак.

Потому что значения int на всём промежутке идут равномерно, с шагом 1, то у float шаг между соседними значениями меняется: в окрестности единицы он примерно 10^(-7), а в окрестности миллиарда - около 100. Приблизительно можно сказать, что равномерно идёт логарифм float. За счёт этого (выигрыш в точности на малых числах, но заметный проигрыш на больших) они и расширили диапазон.
Играясь с соотношением числа бит на мантиссу и порядок, можно менять диапазон на точность, и наоборот.

Я бы сделал так:

while (условие) {
    do {
        код код код код
        код код код код
    }while (условие);

    код код код код
    код код код код
}

Но это если "перезапустить текущую итерацию" не требует дополнительного кода. Если требует - поставить вместо do...while бесконечный цикл for(;;) с break незадолго до конца.

Задумайте число X от 103 до 997, в котором первая и последняя цифра отличаются больше, чем на 1. Запишите его в обратном порядке (получится Y), и вычтите из большего из чисел X,Y меньшее. Получится Z. Теперь найдите сумму числа Z, записанного в обратном порядке, и самого Z. Получится 1089. Это магия следующего порядка.