Если кратко:

Создаются n шариков (в коде ниже — 20), поле, по которому они будут перемещаться и, по желанию, препятствие внутри поля, от которого шарики будут также отталкиваться.

Можно менять размеры и положение поля, препятствия, размер, цвет и количество самих шариков. Начнём.

Описание кода

Я буду писать на C++, поэтому для начала подключаем библиотеки:

#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <ddraw.h>
using namespace std;

const int ballsCount = 20;

Создаём структуры Шар, Поле и Препятствие:

struct Ball {
    float x, y; // координаты шарика
    float dx, dy; // изменение координат по х и у
    float R, G, B; // доли красного, зелёного и синего цветов
    float r; // радиус шарика
};
struct Field {
    float x, y;
    float width, height;
};
struct Obstacle {
    float x, y;
    float width, height;
};

Функция, убирающая курсор:

void ShowConsoleCursor(bool showFlag)
{
    HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO cursorInfo;
    
    GetConsoleCursorInfo(out, &cursorInfo);
    cursorInfo.bVisible = showFlag;
    SetConsoleCursorInfo(out, &cursorInfo);
}

Главная функция:

Создаём наши поле и препятствие и задаём их параметры (можете изменить их на любые другие положительные числа.

Obstacle obstacle;
obstacle.x = 200;
obstacle.y = 90;
obstacle.width = 20;
obstacle.height = 90;

Field board;
board.x = 1;
board.y = 1;
board.width = 350;
board.height = 250;

Создаём массив из 20 шариков и прописываем их параметры:

Ball balls[ballsCount];
for (int i = 0; i < ballsCount; i++) {
    balls[i].r = 10 + rand() % 10; // радиус от 10 до 19
    balls[i].x = 0 + rand() % (int)board.width;
    balls[i].y = 0 + rand() % (int)board.height;
    balls[i].dx = 5;
    balls[i].dy = 5;
    balls[i].R = rand() % 256; // интенсивность цветов от 0 до 255
    balls[i].G = rand() % 256;
    balls[i].B = rand() % 256;
}

Это всё отвечает за рисование в консоли. Можете не обращать внимания:

RECT rect;
HWND window = GetConsoleWindow();
HDC handler = GetDC(window);
GetClientRect(window, &rect);
HPEN fieldPen = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
HBRUSH fieldBrush = CreateSolidBrush(RGB(0, 0, 0));
HPEN ballPen = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
HBRUSH ballBrush = CreateSolidBrush(RGB(0, 0, 0));
// фикс морганий
HDC memDC = CreateCompatibleDC(handler);
HBITMAP hBitmap = CreateCompatibleBitmap(handler, rect.right, rect.bottom);
SelectObject(memDC, hBitmap);
PatBlt(memDC, 0, 0, rect.right, rect.left, BLACKNESS);
// удаляем _ из консоли
ShowConsoleCursor(false);
int fps = 70;

Далее в вечном цикле while(true) последует ещё немного графики:

SelectObject(memDC, fieldPen);
SelectObject(memDC, fieldBrush);
Rectangle(memDC, board.x, board.y, board.x + board.width, board.y + board.height);
// Obstacle
Rectangle(memDC, obstacle.x, obstacle.y, obstacle.x + obstacle.width, obstacle.y + obstacle.height);

Сдвинем каждый шарик и оттолкнём от стенки, если он до неё долетел:

for (int i = 0; i < ballsCount; i++) {
       balls[i].x += balls[i].dx;
       balls[i].y += balls[i].dy;
       if (balls[i].x + balls[i].r > board.width) // правая стенка
       {
            balls[i].x -= balls[i].x - board.width + balls[i].r;
            balls[i].dx = -balls[i].dx;
       }
       if (balls[i].y + balls[i].r > board.height) // верхняя стенка
       {
            balls[i].y -= balls[i].y - board.height + balls[i].r;
            balls[i].dy = -balls[i].dy;
            balls[i].dy += rand() % 1;
        }
        if (balls[i].x - balls[i].r < 0) // левая стенка
        {
            balls[i].x = balls[i].r;
            balls[i].dx = -balls[i].dx;
            balls[i].dx += rand() % 1;
        }
        if (balls[i].y - balls[i].r < 0) // нижняя стенка
        {
            balls[i].y = balls[i].r;
            balls[i].dy = -balls[i].dy;
            balls[i].dy += rand() % 1;
        }
        if ((balls[i].x + balls[i].r > obstacle.x) && (balls[i].x + balls[i].r < obstacle.x + obstacle.width) 
            && (balls[i].y >= obstacle.y) && (balls[i].y <= obstacle.y + obstacle.height)) // левая стенка препятствия
        {
            balls[i].x = balls[i].x - (balls[i].x - obstacle.x) - balls[i].r;
            balls[i].dx = -balls[i].dx;
        }
        if ((balls[i].x >= obstacle.x) && (balls[i].x <= obstacle.x + obstacle.width) && (balls[i].y + balls[i].r > obstacle.y) 
            && (balls[i].y + balls[i].r < obstacle.y + obstacle.height)) // верхняя
        {
            balls[i].y = balls[i].y - (balls[i].y - obstacle.y) - balls[i].r;
            balls[i].dy = -balls[i].dy;
            balls[i].dy += rand() % 1;
        }
        if ((balls[i].x - balls[i].r > obstacle.x) && (balls[i].x - balls[i].r < obstacle.x + obstacle.width) && (balls[i].y >= obstacle.y) 
            && (balls[i].y <= obstacle.y + obstacle.height)) // правая
        {
            balls[i].x = balls[i].x + (obstacle.x + obstacle.width - balls[i].x) + balls[i].r;
            balls[i].dx = -balls[i].dx;
        }
        if ((balls[i].x >= obstacle.x) && (balls[i].x <= obstacle.x + obstacle.width) && (balls[i].y - balls[i].r > obstacle.y) 
            && (balls[i].y - balls[i].r < obstacle.y + obstacle.height)) // нижняя
        {
            balls[i].y = balls[i].y + (obstacle.y + obstacle.height - balls[i].y) + balls[i].r;
            balls[i].dy = -balls[i].dy;
            balls[i].dy += rand() % 1;
       }

Ещё немного графики в том же цикле for:

ballPen = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
ballBrush = CreateSolidBrush(RGB(balls[i].R, balls[i].G, balls[i].B));
SelectObject(memDC, ballPen);
SelectObject(memDC, ballBrush);
Ellipse(memDC, balls[i].x - balls[i].r, balls[i].y - balls[i].r, balls[i].x + balls[i].r, balls[i].y + balls[i].r);
DeleteObject(ballPen);
DeleteObject(ballBrush);

Оставшийся код тоже посвящён графике, не буду его разбирать, приведу ниже

код целиком:

#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <ddraw.h>
using namespace std;
const int ballsCount = 20;
struct Ball {
    float x, y; // координаты шарика
    float dx, dy; // изменение координат по х и у
    float R, G, B; // доли красного, зелёного и синего цветов
    float r; // радиус шарика
};
struct Field {
    float x, y;
    float width, height;
};
struct Obstacle {
    float x, y;
    float width, height;
};
void ShowConsoleCursor(bool showFlag)
{
    HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO cursorInfo;
    GetConsoleCursorInfo(out, &cursorInfo);
    cursorInfo.bVisible = showFlag;
    SetConsoleCursorInfo(out, &cursorInfo);
}
int main()
{
    Obstacle obstacle;
    obstacle.x = 200;
    obstacle.y = 90;
    obstacle.width = 20;
    obstacle.height = 90;
    Field board;
    board.x = 1;
    board.y = 1;
    board.width = 350;
    board.height = 250;
    Ball balls[ballsCount];
    for (int i = 0; i < ballsCount; i++) {
        balls[i].r = 10 + rand() % 10;
        balls[i].x = 0 + rand() % (int)board.width;
        balls[i].y = 0 + rand() % (int)board.height;
        balls[i].dx = 5;
        balls[i].dy = 5;
        balls[i].R = rand() % 256;
        balls[i].G = rand() % 256;
        balls[i].B = rand() % 256;
    }
    RECT rect;
    HWND window = GetConsoleWindow();
    HDC handler = GetDC(window);
    GetClientRect(window, &rect);
    HPEN fieldPen = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
    HBRUSH fieldBrush = CreateSolidBrush(RGB(0, 0, 0));
    HPEN ballPen = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
    HBRUSH ballBrush = CreateSolidBrush(RGB(0, 0, 0));
    // фикс морганий
    HDC memDC = CreateCompatibleDC(handler);
    HBITMAP hBitmap = CreateCompatibleBitmap(handler, rect.right, rect.bottom);
    SelectObject(memDC, hBitmap);
    PatBlt(memDC, 0, 0, rect.right, rect.left, BLACKNESS);
    // удаляем _ из консоли
    ShowConsoleCursor(false);
    int fps = 70;
    while (true) {
        SelectObject(memDC, fieldPen);
        SelectObject(memDC, fieldBrush);
        Rectangle(memDC, board.x, board.y, board.x + board.width, board.y + board.height);
        // Obstacle
        Rectangle(memDC, obstacle.x, obstacle.y, obstacle.x + obstacle.width, obstacle.y + obstacle.height);
        for (int i = 0; i < ballsCount; i++) {
            balls[i].x += balls[i].dx;
            balls[i].y += balls[i].dy;
            if (balls[i].x + balls[i].r > board.width) // правая стенка
            {
                balls[i].x -= balls[i].x - board.width + balls[i].r;
                balls[i].dx = -balls[i].dx;
            }
            if (balls[i].y + balls[i].r > board.height) // верхняя стенка
            {
                balls[i].y -= balls[i].y - board.height + balls[i].r;
                balls[i].dy = -balls[i].dy;
                balls[i].dy += rand() % 1;
            }
            if (balls[i].x - balls[i].r < 0) // левая стенка
            {
                balls[i].x = balls[i].r;
                balls[i].dx = -balls[i].dx;
                balls[i].dx += rand() % 1;
            }
            if (balls[i].y - balls[i].r < 0) // нижняя стенка
            {
                balls[i].y = balls[i].r;
                balls[i].dy = -balls[i].dy;
                balls[i].dy += rand() % 1;
            }
            if ((balls[i].x + balls[i].r > obstacle.x) && (balls[i].x + balls[i].r < obstacle.x + obstacle.width) 
                && (balls[i].y >= obstacle.y) && (balls[i].y <= obstacle.y + obstacle.height)) // левая стенка препятствия
            {
                balls[i].x = balls[i].x - (balls[i].x - obstacle.x) - balls[i].r;
                balls[i].dx = -balls[i].dx;
            }
            if ((balls[i].x >= obstacle.x) && (balls[i].x <= obstacle.x + obstacle.width) && (balls[i].y + balls[i].r > obstacle.y) 
                && (balls[i].y + balls[i].r < obstacle.y + obstacle.height)) // верхняя
            {
                balls[i].y = balls[i].y - (balls[i].y - obstacle.y) - balls[i].r;
                balls[i].dy = -balls[i].dy;
                balls[i].dy += rand() % 1;
            }
            if ((balls[i].x - balls[i].r > obstacle.x) && (balls[i].x - balls[i].r < obstacle.x + obstacle.width) && (balls[i].y >= obstacle.y) 
                && (balls[i].y <= obstacle.y + obstacle.height)) // правая
            {
                balls[i].x = balls[i].x + (obstacle.x + obstacle.width - balls[i].x) + balls[i].r;
                balls[i].dx = -balls[i].dx;
            }
            if ((balls[i].x >= obstacle.x) && (balls[i].x <= obstacle.x + obstacle.width) && (balls[i].y - balls[i].r > obstacle.y) 
                && (balls[i].y - balls[i].r < obstacle.y + obstacle.height)) // нижняя
            {
                balls[i].y = balls[i].y + (obstacle.y + obstacle.height - balls[i].y) + balls[i].r;
                balls[i].dy = -balls[i].dy;
                balls[i].dy += rand() % 1;
            }
            ballPen = CreatePen(PS_SOLID, 2, RGB(255, 255, 255));
            ballBrush = CreateSolidBrush(RGB(balls[i].R, balls[i].G, balls[i].B));
            SelectObject(memDC, ballPen);
            SelectObject(memDC, ballBrush);
            Ellipse(memDC, balls[i].x - balls[i].r, balls[i].y - balls[i].r, balls[i].x + balls[i].r, balls[i].y + balls[i].r);
            DeleteObject(ballPen);
            DeleteObject(ballBrush);
        }
        BitBlt(handler, 0, 0, rect.right, rect.bottom, memDC, 0, 0, SRCCOPY);
        Sleep(2000 / fps);
    }
    ReleaseDC(window, handler);
    DeleteObject(memDC);
}

Бонус)

Если вставить этот код в начале цикла for, шарики будут переливаться разными цветами:

if (balls[i].R >= 255)
    balls[i].R = 0;
if (balls[i].G >= 255)
    balls[i].G = 0;
if (balls[i].B >= 255)
    balls[i].B = 0;
balls[i].R += 1 + rand() % 10;
balls[i].G += 1 + rand() % 5;
balls[i].B += 1 + rand() % 4;

https://tlgg.ru/Selfinstallation

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

Новый тип данных Fraction будет иметь два поля — числитель (numerator) и знаменатель (denominator). Знак будет храниться в числителе.

class Fraction {
public:
    int numer, denom;
    Fraction(int n = 0, int d = 1) { //конструктор, на вход подаются два числа n и d
        numer = n;
        denom = d;
    }
}

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

Арифметические операции для дробей будем реализовывать с помощью перегрузки соответствующих операторов:

Fraction operator + (Fraction& other) {
        return
            Fraction(
                numer * other.denom + denom * other.numer,
                denom * other.denom
                );
}

Вычитание выполняется как сложение с отрицательным числом:)

Fraction operator - (Fraction& other) {
        return Fraction(numer, denom) + Fraction(-other.numer, other.denom);
}

Умножение и деление (умножение на "перевёрнутую дробь")

Fraction operator * (Fraction& other) {
        return
            Fraction(
                numer * other.numer, denom * other.denom
                ).reduce();
 }
 Fraction operator / (Fraction& other) {
        return Fraction(numer, denom) * Fraction(other.denom, other.numer);
 }

Почти готово. Осталось прописать ввод/вывод дроби, и, самое интересное — сокращение дроби до несократимой. Для этого напишем функции input, show и reduce.

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

int fract_nod(int a, int b) {
    if (b == 0) return a;
    return fract_nod(b, a % b);
}

Здесь важно, чтобы a было больше или равно b, а также чтобы числа были положительны, но это мы учтём в самой функции reduce.

Fraction reduce() {
        int a = max(abs(numer), abs(denom)), b = min(abs(numer), abs(denom));
        int sgn; //знак нашей дроби
        if (numer * denom >= 0) sgn = 1;
        else sgn = -1;
        int nod = fract_nod(a, b);
        return Fraction(sgn * (abs(numer) / nod), abs(denom) / nod);
}

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

Fraction operator + (Fraction& other) {
        return
            Fraction(
                numer * other.denom + denom * other.numer,
                denom * other.denom
                ).reduce(); //новое
}

Fraction operator * (Fraction& other) {
        return
            Fraction(
                numer * other.numer, denom * other.denom
                ).reduce(); //новое
}

Напишем функцию вывода:

void show() {
        cout << "\t" << numer;
        if (denom != 1) cout << "/" << denom;
}

Логично вводить дроби в том же формате, что и выводить, т.е. в виде m/n, где m — целое число, а n — натуральное. Поскольку мы пишем класс на плюсах, придётся повозиться со считыванием строки и преобразованием её в два числа (возможно, с отрицательным знаком).

Fraction input(string& s) {
    int n = 0, d = 0, deg = 0;
    int slash_pos = s.find('/'); //ищем разделитель
    if (slash_pos != s.npos) { //если он есть (число введено как дробь)
        int i = slash_pos - 1;
        //записываем в n число перед "/"
        while (i > -1) {
            if (s[i] != '-')
                n += (s[i] - 48) * pow(10, deg++); //сдвиг на 48, т.к. код "0" в ASCII = 48
            else
                n = -n;
            i -= 1;
        }
        deg = 0;
        i = s.size() - 1;
        //записываем в d число после "/"
        while (i > slash_pos) {
            if (s[i] != '-')
                d += (s[i] - 48) * pow(10, deg++);
            else
                d = -d;
            i -= 1;
        }
    } else { //если число введено как целое
        d = 1;
        int i = s.size() - 1;
        while (i > -1) {
            if (s[i] != '-')
                n += (s[i] - 48) * pow(10, deg++);
            else
                n = -n;
            i -= 1;
        }
    }
    //создаём дробь с введёнными числами и сокращаем
    Fraction f;
    if (d) f = Fraction(n, d).reduce();
    else f = Fraction(n);
    return f;
}

Готово!

Код целиком

#include <algorithm>
#include <string>
using namespace std;
int fract_nod(int a, int b) {
    if (b == 0) return a;
    return fract_nod(b, a % b);
}
class Fraction {
public:
    int numer, denom;
    Fraction(int n = 0, int d = 1) {
        numer = n;
        denom = d;
    }
    Fraction reduce() {
        int a = max(abs(numer), abs(denom)), b = min(abs(numer), abs(denom));
        int sgn;
        if (numer * denom >= 0) sgn = 1;
        else sgn = -1;
        int nod = fract_nod(a, b);
        return Fraction(sgn * (abs(numer) / nod), abs(denom) / nod);
    }
    void show() {
        cout << "\t" << numer;
        if (denom != 1) cout << "/" << denom;
    }
    Fraction operator + (Fraction& other) {
        return
            Fraction(
                numer * other.denom + denom * other.numer,
                denom * other.denom
                ).reduce();
    }
    Fraction operator - (Fraction& other) {
        return Fraction(numer, denom) + Fraction(-other.numer, other.denom);
    }
    Fraction operator * (Fraction& other) {
        return
            Fraction(
                numer * other.numer, denom * other.denom
                ).reduce();
    }
    Fraction operator / (Fraction& other) {
        return Fraction(numer, denom) * Fraction(other.denom, other.numer);
    }
};
Fraction input(string& s) {
    int n = 0, d = 0, deg = 0;
    int slash_pos = s.find('/');
    if (slash_pos != s.npos) {
        int i = slash_pos - 1;
        while (i > -1) {
            if (s[i] != '-')
                n += (s[i] - 48) * pow(10, deg++);
            else
                n = -n;
            i--;
        }
        deg = 0;
        i = s.size() - 1;
        while (i > slash_pos) {
            if (s[i] != '-')
                d += (s[i] - 48) * pow(10, deg++);
            else
                d = -d;
            i--;
        }
    } else {
        d = 1;
        int i = s.size() - 1;
        while (i > -1) {
            if (s[i] != '-')
                n += (s[i] - 48) * pow(10, deg++);
            else
                n = -n;
            i--;
        }
    }
    Fraction f;
    if (d) f = Fraction(n, d).reduce();
    else f = Fraction(n);
    return f;
}

https://tlgg.ru/Selfinstallation

Сам код:

per nextum in unam tum XI conscribementis fac sic
    vestibulo perlegementum da varo.
    morde varo.
    seqis cumula varum.
cis

per nextum in unam tum XI conscribementis fac sic
    seqis decumulamenta da varo.
    varum privamentum fodementum da aresulto.
    varum tum III elevamentum tum V multiplicamentum da bresulto.
    aresultum tum bresultum addementum da resulto.
    
    si CD tum resultum non praestantiam fac sic
        dictum sic f(%d) = %.2f cis tum varum tum resultum egresso describe.
        novumversum egresso scribe.    
    cis  
    si CD tum resultum praestantiam fac sic        
        dictum sic f(%d) = MAGNA NIMIS! cis tum varum egresso describe.        
        novumversum egresso scribe.            
    cis
 cis

Кроме ограничений на переменные и набора входных/выходных данных для одного теста ничего не дано, так что сперва надо поработать с самим кодом.

Возможно, кто-то умеет гуглить и сразу мог понять, что эта программа написана на Lingua::Romana::Perligata, модуле Perl, позволяющем писать программы на латыни, и просто перевести код, но я вместо этого эксперементировал с Google переводчиком и использовал свои познания в лингвистике.

Поскольку разбор задачи на самой платформе CodeForces не был подробным, я решил его дополнить. Ниже приведены версии кода на Python и C++, а также на естественном языке с переводом конкретных слов (указаны в скобках).

Python

v = []
for i in range(11):
    v.append(int(input()))

for i in range(11):
    var = v.pop()
    a = abs(var) ** 0.5
    b = (var ** 3) * 5
    result = a + b
    if 400 > result:
        print("f(", var, ') = ', '%.2f' % result, sep='')
    else:
        print("f(", var, ") = MAGNA NIMIS!", sep='')

C++

using namespace std;
#include <iostream>
#include <iomanip>
#include <vector>
#include <cmath>

using namespace std;
int main() {
    int var;
    float a, b, result;
    vector <int> v;
    for (sizet i = 0; i < 11; ++i) {
        cin >> var;
        v.pushback(var);
    }
    for (size_tt i = 0; i < 11; ++i) {
        var = v.back();
        v.pop_back();
        a = sqrt(abs(var));
        b = pow(var, 3) * 5;
        result = a + b;
        if (400 > result) {
            cout << "f(" << var << ") = " << fixed << setprecision(2) << result << "\n";
        } else {
            cout << "f(" << var << ") = MAGNA NIMIS!\n";
        }
    }
    return 0;
}

Естественный язык

Перебирая для некоторой скалярной переменной(per nextum) i значения от 1 до 11 (in unam tum XI) :
{
    Стандартный ввод(vestibulo) до конца строки(perlegementum) в(da) новую переменную(varo) var;
    Обрезать символы перевода строки(morde);
    “Сложить” в массив(seqis cumula) переменную var;
}
Перебирая для некоторой скалярной переменной(per nextum) i значения от 1 до 11 (in unam tum XI) :
{
    “Вынуть” из массива(seqis decumulamenta) переменную var;
    В новую переменную a(da aresulto) записать квадратный корень(fodementum) модуля(privamentum)  var;
    В новую переменную b(da bresulto) записать произведение 5 (tum V multiplicamentum) и куба var(tum III elevamentum);
    В новую переменную result(da resulto) записать сумму(addementum) a и b(aresultum tum bresultum);
    Если(si) 400 не меньше(non praestantiam), чем result,
    {
        Вывести(dictum) “f(var) = result” с точностью до 2 знаков после запятой(%.2f), стандартный вывод(egresso describe);
    Перевод на новую строку(novumversum), стандартный вывод(egresso describe).
    }
        Если(si) 400 меньше(praestantiam), чем result,
        {
            Вывести “f(var) = MAGNA NIMIS!”(TOO MUCH!), стандартный вывод(egresso describe);
    Перевод на новую строку(novumversum), стандартный вывод(egresso describe).
        }
}

В этой программе кто-то мог узнать TPK алгоритм, помогающий отслеживать эволюцию языков программирования, и да, это он и есть.

Про него и про сам Lingua::Romana::Perligata я могу рассказать подробнее в следующих статьях, если это будет кому-то интересно.

https://tlgg.ru/Selfinstallation