Mercury13

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

Числа P и Q высчитываем с точностью до остатка от деления на Z := 10⁹+ 7.

Авторы обещают, что Q mod Z ≠ 0. Z — простое. Тогда НОД(Q mod Z, Z) = 1. Так называемый расширенный алгоритм Евклида (гуглите!) позволяет подобрать такие числа, чтобы m(Q mod Z) + nZ = 1.

Ваша задача — вывести ((P mod Z) · m) mod Z. Специально указал дважды mod Z: первое у вас будет при работе с числом P, второе — при генерации вывода.

Почему так? Возьмём вместо здоровенного Z цифру поменьше, 17. Если у вас получился результат 100/400, при расчётах выйдет цифра 15/9, и 9·2+17·(−1) = 1, и ваша задача — вывести (15·2) mod 17 = 13.

Если же у вас получилось, например, 35/140, при расчётах получается 1/4, 1·(−4)+17·1 = 1, и вы должны вывести (1·(−4)) mod 17 = 13. То есть: независимо от того, насколько сократимая дробь у вас получилась, вы получите один и тот же результат. Тут надо уточнить: там, где возможен отрицательный числитель, нужен не обычный % из Си++, а (a % Z; если получилось отрицательное — добавь Z).

Ну а арифметических переполнений просто не допускайте, Z = 10⁹ + 7 позволяет умножать в типе long long и не уходить в переполнение.

UPD. То, что Z — простое, даёт несколько выгод. Часто результат бывает круглый, и простота требует честно считать остаток, а не угадывать. Ну и побочек меньше.

У вас тут переменная кадровая частота. Если за длинный кадр шарик ушёл далеко за стенку, короткий кадр его не сможет вытащить наружу и снова инвертирует скорость — шар застрял. (Я это с лёгкостью повторил функцией Windows 10 «Aero Shake»).

В простейшем случае — определять, за какую стенку шар выскочил, и давать ему скорость такую, чтобы он возвращался в площадку. А не просто vx=−vx, независимо от того, куда эта скорость смотрит.

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

Также надо давать float time = clock.restart().asMicroseconds(); Сейчас компы быстры и погрешность незначительна, но всё-таки.

feof возвращает true, когда мы попытались прочитать и не смогли, потому что каретка ударилась в конец файла. А не когда каретка аккуратно припарковалась в конце файла — и уж тем более не когда она отделена от конца пробелами.

Лучше прочитайте про scanf…

On success, the function returns the number of items of the argument list successfully filled. This count can match the expected number of items or be less (even zero) due to a matching failure, a reading error, or the reach of the end-of-file.

…и посмотрите, как можно переделать условие цикла.

Нет, разумеется. ООП подразумевает смену состояния объекта, а в константных выражениях смена состояния запрещена. Может, и можно какую-то собственную горбушку придумать, но не знаю, как (даже конструктор — смена состояния).

Если же задача — посчитать при компиляции хэш для константного элемента, и всё… вот это интересно, но тоже не знаю, как реализовать.

ОПРЕДЕЛЕНИЕ. Беспорядок — а) чёрный блин внизу; б) белый блин на чёрном, чёрный на белом.

ТЕОРЕМА. Переворот исправляет не более одного беспорядка.
ДОКАЗАТЕЛЬСТВО. Ни в переворачиваемой стопке, ни в оставшейся как был беспорядок, так и остаётся. У нас есть шанс исправить один беспорядок — тот, в который мы залезли лопатой.

СЛЕДСТВИЕ. Оценка снизу — количество беспорядков.

ТЕОРЕМА. Эта граница достижима.
БАЗА ИНДУКЦИИ. У нас 0 беспорядков. Все блины белые — реально нужно 0 ходов.
ШАГ ИНДУКЦИИ. Доказано, что граница достижима для 0…N−1 беспорядков. Пусть теперь беспорядков N.
Если количество беспорядков нечётно, вверху будет чёрный блин. Перевернём всю стопку, кроме нижних белых блинов. Теряем одним ходом один беспорядок, а для N−1 граница достижима.
Если количество беспорядков чётно, вверху белый блин. Поскольку беспорядков не 0, белые блины лежат на чёрных. Перевернём белую группу (теряем один беспорядок) и получаем вверху чёрный блин. Теряем одним ходом один беспорядок, а для N−1 граница достижима.

АЛГОРИТМ. Подсчитать количество беспорядков в стопке, вывести его. O(N).

Название, конечно, не по прогерскому фэншую, и вспоминается знаменитый стих столетней давности:
«We slog, slog, slog, slogging over Africa,
Boots, boots, boots, boots moving up and down again».

ПЕРВОЕ. Главный тормоз — дополнение строк нулями, которое квадратичное по скорости.

for i:=length(s1)+1 to m do
         s1:='0'+s1;
      for i:=length(s)+1 to m do
         s:='0'+s;

Как решить?

function add1(const large,small:string):string;

function add(const x, y : string) : string;
begin
  if length(x) > length(y)
    then add := add1(x, y)
    else add := add1(y, x);
end;

Ну и разумеется, сделать, чтобы add1 работала с числами разной длины.

ВТОРОЕ. У вас, по-видимому, ошибка — 99+1 = 100 не создаст третьего разряда.

ТРЕТЬЕ. Я не знаю, какой у вас Паскаль, но, вероятно, передача строк по const/var также повысила бы скорость.

ОФТОП. Если ваша задача не «ввести два числа, сложить и всё», я бы отделил длинное число от его строкового представления, примерно так.

TLongNum = record
  length : integer;
  data : array [1..1000] of byte;
end;