Category Archives: 1. Линейные вычисления

Программы простой линейной структуры, осуществляющие последовательные вычисления.

Линейные вычисления

Опубликовано: 10/10/2014

Это первая практическая тема при изучении программирования. Предварительно следует проработать как минимум главу 2 и 4 учебника С.Липпмана. Обратите внимание, что умница-переводчик и операции и операторы называет одинаково операторами. Т.е. каждый раз встречая в главе 4 слово «оператор» выполняйте замену на «операция». Или сразу читайте английский вариант, где operator = операция, а statement = оператор. … Continue reading →

нет комментариев

В классе и дома решаются следующие тренировочные задачи (1 балл):

Площадь прямоугольника — самая простая тренировочная задача.
A xor B — более простая чем предыдущая.
Спортсмен
Простая задача?
Спички
Скидки — используйте функции min() и max() из cmath
Бабочка-санитар
Анфиса и цветы
Новое блюдо Анфисе — 2
Номер квартиры
Квадрат и точки
Зоопарк
Белые кубики
Произведение цифр
Три грибника
Кольцо
Разложение трицифрового числа
Пирожки
Сколько до Нового Года?
Километровые столбы (Mileposts)
Нечетные разряды
Гринвіцький годинник
Крейсерская скорость
Стартовая скорость
Часы
Сломанные часы
Поездка на экскурсию

При решении задач этого раздела запрещается использовать какие-либо другие средства вроде ветвлений, циклов, тернарных операций и другие материалы последующих разделов курса. В этом запрете смысл головоломки некоторых задач. Попробуйте приложить все усилия, чтобы решить в этом стиле следующие задачи: 1, 8, 10, 51, 57, 63, 67, 126, 133, 146, 157, 248, 421, 472, 478, 519, 542, 906, 920, 924, 926, 932, 935, 939, 945, 949, 990, 1474, 1610, 2059, 2071, 2262, 2364, 2860, 3604, 3609, 4716, 4717, 5175, 5868, 6275, 7336, 7337, 7366, 7367, 7369, 7401, 7460, 7612, 7943, 7944. Возможно с какой-то из задач я ошибся и построить формулу её решения не получится. Но особенно на это рассчитывать не приходится — почти все задачи я перепроверил.

Опубликованные решения:

e-olymp 8701. Кузнечик-попрыгунчик

24/05/2019 by Богдан Павлов

Задача

Кузнечик-попрыгунчик долго сидел на отметке [latex]0[/latex] числовой прямой, так долго, что придумал инновационную методологию своего перемещения. Такую, что за каждую итерацию движения он выполняет ровно два прыжка, перемещаясь сначала на [latex]a[/latex], а затем на [latex]b[/latex] единичных отрезков по числовой прямой, причем, если число положительное, то он движется вправо, а если отрицательное, то влево. Продолжительность прыжка в секундах равна соответствующему количеству единичных отрезков, на которое переместится кузнечик.

Например, если [latex]a = 3[/latex], а [latex]b = — 2[/latex], то через [latex]3[/latex] сек. он будет на отметке [latex]3[/latex], а через [latex]5[/latex] сек. от начала движения попадет на отметку [latex]1[/latex]. Далее, на [latex]8[/latex] секунде переместится на отметку [latex]4[/latex], а на [latex]10[/latex] секунде вернется на [latex]2[/latex].

При заданных [latex]a[/latex] и [latex]b[/latex] найти сколько необходимо времени в секундах, чтобы допрыгать до отметки x числовой прямой или вывести [latex]-1[/latex], если это невозможно.

Входные данные

Целочисленные значения [latex]a[/latex], [latex]b[/latex], [latex]x[/latex] — в одной строке через пробел. Значение по модулю не превышают [latex]10^{9}[/latex].

Выходные данные

Ответ на задачу.

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	3 -2 1	5
2	100 200 0	0
3	-10 -20 -900	900
4	5 -6 3	27
5	1 3 10	-1

Код программы (с использованием условных операторов)

#include<iostream>
using namespace std;
#define MAX 1000000000000000000
int main()
{
    long long a, b, x;
    cin >> a >> b >> x; // ввод переменных
 
    if (!x) return (cout << 0 << endl, 0); // проверяем, не равен ли x 0(тогда не нужно совершать никаких прыжков)
 
    if(a+b==0) if(x==a) return(cout << a << endl,0); // так же проверяем не будет ли суммой дистанций прыжков 0,
    // если будет, то проверяем, можно ли за первый прыжок добраться до точки x
 
    long long possible_ans1 = MAX, possible_ans2 = MAX; // объявляем две переменные, соответветствующие двум способам добраться до точки x
 
    if (!((x - a) % (a + b)))// проверяем первый способ, если можно добраться за n(a+b) + a прыжков, где n - количество совершенных прыжков
        possible_ans1 = ((x - a) / (a + b)) * (abs(a) + abs(b)) + abs(a);
 
    if (!(x % (a + b))) // проверяем второй способ, если до x можно добраться n(a+b) прыжков
        possible_ans2 = x / (a + b) * (abs(a) + abs(b));
 
    // если невозможно добраться каким-либо из способов, то присваиваем соответствующей переменной значение MAX
    if (possible_ans1 < 0) 
        possible_ans1 = MAX;    
    if (possible_ans2 < 0) 
        possible_ans2 = MAX;
 
    if (possible_ans1 == MAX && possible_ans2 == MAX) // если невозможно добраться никаким из способов, то выводим -1, в отличном случае
        return (cout << -1 << endl, 0); // выводим минимум из возможных ответов
    cout << min(possible_ans1, possible_ans2) << endl;
    return 0;
}

#include<iostream>

using namespace std;

#define MAX 1000000000000000000

int main()

{

long long a, b, x;

cin >> a >> b >> x; // ввод переменных

if (!x) return (cout << 0 << endl, 0); // проверяем, не равен ли x 0(тогда не нужно совершать никаких прыжков)

if(a+b==0) if(x==a) return(cout << a << endl,0); // так же проверяем не будет ли суммой дистанций прыжков 0,

// если будет, то проверяем, можно ли за первый прыжок добраться до точки x

long long possible_ans1 = MAX, possible_ans2 = MAX; // объявляем две переменные, соответветствующие двум способам добраться до точки x

if (!((x - a) % (a + b)))// проверяем первый способ, если можно добраться за n(a+b) + a прыжков, где n - количество совершенных прыжков

possible_ans1 = ((x - a) / (a + b)) * (abs(a) + abs(b)) + abs(a);

if (!(x % (a + b))) // проверяем второй способ, если до x можно добраться n(a+b) прыжков

possible_ans2 = x / (a + b) * (abs(a) + abs(b));

// если невозможно добраться каким-либо из способов, то присваиваем соответствующей переменной значение MAX

if (possible_ans1 < 0)

possible_ans1 = MAX;

if (possible_ans2 < 0)

possible_ans2 = MAX;

if (possible_ans1 == MAX && possible_ans2 == MAX) // если невозможно добраться никаким из способов, то выводим -1, в отличном случае

return (cout << -1 << endl, 0); // выводим минимум из возможных ответов

cout << min(possible_ans1, possible_ans2) << endl;

return 0;

}

Решение задачи (с использованием условных операторов)

Для решения данной задачи сначала проверим не находимся ли мы уже в точке [latex]0[/latex], после проверим не равна ли сумма дистанций прыжков [latex]0[/latex], если равна, то также проверим можно ли добраться до точки x за один прыжок a. Если возможно выводим a. После проверяем возможность добраться до точки x двумя способами:

Сначала добравшись до точки x-a прыжками вида a+b, а после совершив один прыжок на дистанцию a
Добраться до точки x исключительно прыжками вида a+b

Если одним из способов невозможно добраться, то присваиваем переменной соответствующей потраченному времени MAX, а после выводим минимум из переменных possible_ans1, possible_ans2(в случае, если обеими способами невозможно добраться, т.е. обе переменные равны MAX выводим -1).

Код программы (без использования условных операторов)

#include <iostream>
#include <cmath>
using namespace std;
int main() {
    long long a,b,x,s,t,ans=-1;
    cin >> a >> b >> x;
    s=a+b;
    t=abs(a)+abs(b);
    (!x) && cout << 0 || 
    (x==a) && cout << abs(a) ||
    !((x - a) % (s)) && ((x - a) / (s)) * (t) + abs(a) >= 0 && cout << ((x - a) / (s)) * (t) + abs(a) ||
    !(x % (s)) && x / (s) * (t) >= 0 && cout << x / (s) * (t) || cout << -1;
    return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main() {

long long a,b,x,s,t,ans=-1;

cin >> a >> b >> x;

s=a+b;

t=abs(a)+abs(b);

(!x) && cout << 0 ||

(x==a) && cout << abs(a) ||

!((x - a) % (s)) && ((x - a) / (s)) * (t) + abs(a) >= 0 && cout << ((x - a) / (s)) * (t) + abs(a) ||

!(x % (s)) && x / (s) * (t) >= 0 && cout << x / (s) * (t) || cout << -1;

return 0;

}

Решение задачи (без использования условных операторов)

Заранее вычислим значения s(пройденное расстояние за один прыжок вида a+b) и t(время, потраченное на один прыжок вида a+b). После поочередно проверим выполнение всех условий, описанных ранее. При выполнении какого-либо из условий, выводим соответствующее время, если ни одно из условий не выполнилось то выводим [latex]-1[/latex].

Related Images:

e-olymp 944. Площадь пирамиды

05/01/2019 by Иван Дуков

Задача

Треугольная пирамида задана координатами своих вершин [latex] A(x_1; y_1; z_1), [/latex] [latex] B(x_2; y_2; z_2), [/latex] [latex] C(x_3; y_3; z_3), [/latex] [latex] S(x_4; y_4; z_4). [/latex] Определить площадь полной поверхности пирамиды.

Входные данные

В четырех строках заданы координаты [latex] x, y, z [/latex] вершин пирамиды. Все числа целые, не превышающие по модулю 100.

Выходные данные

Вывести полную поверхность пирамиды с точностью до десятых.

Тесты

№	Входные данные	Выходные данные
1	-3 0 0	69,8
	0 6 0
	3 0 0
	0 2 5
2	2 4 8	159,1
	2 -6 9
	5 -4 0
	1 3 0
3	5 0 1	107,3
	4 1 7
	-9 0 4
	6 2 8

Код программы

#include <iostream>   // std::cout, std::fixed
#include <iomanip>   // std::setprecision //данную библиотеку подключаем для того, чтобы установить количество знаков после запятой 
#include <cmath>    //данную библиотеку подключаем  для того, чтобы была возможность извлечь корень и возвести в квадрат 
using namespace std;

//функция рассчитывает расстояние между двумя точками с заданными координатами
double distance (double x1, double y1, double z1,
                 double x2, double y2, double z2)
{
    return sqrt( pow(x1-x2, 2) + pow(y1-y2, 2) + pow(z1-z2, 2)); 
}
//функция вычисляет площадь треугольника по формуле Герона
double Geron (double x1, double y1, double z1,
              double x2, double y2, double z2,
              double x3, double y3, double z3)
{
    double a,b,c,P;//стороны треугольника и полупериметр
    a = distance(x1,y1,z1, x2,y2,z2);
    b = distance(x2,y2,z2, x3,y3,z3);
    c = distance(x1,y1,z1, x3,y3,z3);
    P = (a+b+c)/2;
    return sqrt(P*(P-a)*(P-b)*(P-c)); 
}
//функция вычисляет площадь полной поверхности пирамиды
double square (double x1, double y1, double z1,
               double x2, double y2, double z2, 
               double x3, double y3, double z3,
               double x4, double y4, double z4)
{
    double S1,S2,S3,S4,S;//площади треугольников и площадь полной поверхности пирамиды
    S1 = Geron(x1,y1,z1,x2,y2,z2,x3,y3,z3);
    S2 = Geron(x1,y1,z1,x2,y2,z2,x4,y4,z4);
    S3 = Geron(x1,y1,z1,x3,y3,z3,x4,y4,z4);
    S4 = Geron(x2,y2,z2,x3,y3,z3,x4,y4,z4);
    S = S1+S2+S3+S4;
    return S;
}
int main() 
{
    double x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;//координаты вершин пирамиды
    cin >> x1 >> y1 >> z1 
        >> x2 >> y2 >> z2 
        >> x3 >> y3 >> z3 
        >> x4 >> y4 >> z4;
    double S = square (x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4);
    cout << fixed << setprecision(1) << S << endl; 
    return 0;
}

#include <iostream> // std::cout, std::fixed

#include <iomanip> // std::setprecision //данную библиотеку подключаем для того, чтобы установить количество знаков после запятой

#include <cmath> //данную библиотеку подключаем для того, чтобы была возможность извлечь корень и возвести в квадрат

using namespace std;

//функция рассчитывает расстояние между двумя точками с заданными координатами

double distance (double x1, double y1, double z1,

double x2, double y2, double z2)

{

return sqrt( pow(x1-x2, 2) + pow(y1-y2, 2) + pow(z1-z2, 2));

}

//функция вычисляет площадь треугольника по формуле Герона

double Geron (double x1, double y1, double z1,

double x2, double y2, double z2,

double x3, double y3, double z3)

{

double a,b,c,P;//стороны треугольника и полупериметр

a = distance(x1,y1,z1, x2,y2,z2);

b = distance(x2,y2,z2, x3,y3,z3);

c = distance(x1,y1,z1, x3,y3,z3);

P = (a+b+c)/2;

return sqrt(P*(P-a)*(P-b)*(P-c));

}

//функция вычисляет площадь полной поверхности пирамиды

double square (double x1, double y1, double z1,

double x2, double y2, double z2,

double x3, double y3, double z3,

double x4, double y4, double z4)

{

double S1,S2,S3,S4,S;//площади треугольников и площадь полной поверхности пирамиды

S1 = Geron(x1,y1,z1,x2,y2,z2,x3,y3,z3);

S2 = Geron(x1,y1,z1,x2,y2,z2,x4,y4,z4);

S3 = Geron(x1,y1,z1,x3,y3,z3,x4,y4,z4);

S4 = Geron(x2,y2,z2,x3,y3,z3,x4,y4,z4);

S = S1+S2+S3+S4;

return S;

}

int main()

{

double x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;//координаты вершин пирамиды

cin >> x1 >> y1 >> z1

>> x2 >> y2 >> z2

>> x3 >> y3 >> z3

>> x4 >> y4 >> z4;

double S = square (x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4);

cout << fixed << setprecision(1) << S << endl;

return 0;

}

Решение задачи

Для того, чтобы найти площадь полной поверхности пирамиды, необходимо найти площади треугольников, которые являются гранями пирамиды.
Для нахождения площади треугольника можно воспользоваться формулой Герона: [latex] S = \sqrt{p \cdot(p-a) \cdot(p-b) \cdot(p-c)} [/latex],где [latex] p [/latex]-полупериметр треугольника, [latex] a,b,c [/latex] — стороны треугольника. Чтобы воспользоваться формулой Герона, необходимо предварительно найти длины сторон треугольников, используя формулу нахождения длин отрезков по координатам концов отрезка: [latex] |AB|=\sqrt{(x_b-x_a)^2+(y_b-y_a)^2+(z_b-z_a)^2} [/latex], где [latex] А,В [/latex] — концы отрезка, [latex] x_a, y_a,z_a [/latex] — координаты [latex] А [/latex], [latex] x_b, y_b,z_b [/latex] — координаты [latex] В [/latex].
Найденные площади всех треугольников, из которых состоит пирамида, складываем и получаем искомую площадь полной поверхности пирамиды.

Ссылки

e-olymp
ideone

Related Images:

e-olymp 75. Пираты и монеты

24/12/2018 by Даниил Мозгунов

Задача

[latex]n[/latex] пиратам удалось справедливо разделить клад из [latex]m[/latex] золотых монет — каждый получил свою часть согласно своему пиратскому рангу и стажу. Самый молодой пират взял [latex]a[/latex] монет, а каждый следующий пират брал на одну монету больше, чем предыдущий его коллега. Последним был капитан, которому досталось вдвое больше от запланированного, очевидно, что после него монет больше не осталось.

Сколько было пиратов вместе с капитаном, если известны [latex]a[/latex] и [latex]m[/latex]. Так как капитан без команды просто пират, то [latex]n > 1[/latex].

Входные данные

Два натуральных числа [latex]a[/latex] и [latex]m[/latex] ([latex]1 \leq a \leq 100, m < 15150[/latex]). Входные данные корректны.

Выходные данные

Количество пиратов [latex]n[/latex].

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	5 25	3
2	3 24	4
3	4 38	5
4	5 55	6
5	6 75	7

Код программы

#include <iostream>
#include <cmath>
using namespace std;
 
int main() {
    double a, m, n, b, c, d;
    cin>>a>>m; 
    b = 2 * a + 1;
    c = 2 * a - 2 - 2 * m;
    d = b * b - 4 * c;
    n = ( -b + sqrt(d) ) / 2;
    cout<<n;
    return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main() {

double a, m, n, b, c, d;

cin>>a>>m;

b = 2 * a + 1;

c = 2 * a - 2 - 2 * m;

d = b * b - 4 * c;

n = ( -b + sqrt(d) ) / 2;

cout<<n;

return 0;

}

Решение задачи

Для решения задачи воспользуемся формулой арифметической прогрессии, которая в данном случае равна: [latex](2a + n — 1)\frac{n}{2} + a + n — 1[/latex]. Отсюда получаем квадратное уравнение : [latex]\frac{n^{2}}{2} + n(a + \frac{1}{2}) + a — 1 = m[/latex], упростим и получим: [latex]n^{2} + 2an + n + 2a — 2 = 2m[/latex]. В коде задаем чему равно [latex]b[/latex], [latex]c[/latex] и [latex]d[/latex]. Где [latex]b[/latex] и [latex]c[/latex] — коэффициенты квадратного уравнения, а [latex]d[/latex] — дискриминант квадратного уравнения, который вычисляем по формуле: [latex]b^{2} — 4c[/latex]. Они нужны для нахождения корня данного квадратного уравнения. При этом ответом на задачу будет только один корень квадратного уравнения, так как количество пиратов не может принимать отрицательное значение. Поэтому вычисляем корень квадратного уравнения по формуле: [latex]\frac{-b + \sqrt{b}}{2}[/latex], тем самым получаем ответ на нашу задачу.

Код программы (с циклом)

#include <iostream>
using namespace std;

int main() {
    unsigned int a, m, n = 0;
    cin>>a>>m;
    while (m - 2 * a != 0){
            m -= a;
            a ++;
            n ++;
    }
    cout<<n + 1;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

unsigned int a, m, n = 0;

cin>>a>>m;

while (m - 2 * a != 0){

m -= a;

a ++;

n ++;

}

cout<<n + 1;

return 0;

}

Решение задачи

В данном способе используем цикл. Как он работает: в условии цикла задаем проверку, когда наступит очередь капитана и будет выполнятся равенство вида [latex]m — 2a = 0[/latex] цикл прекратит свою работу. Пока это равенство не будет выполнятся цикл будет выполнять работу арифметической прогрессии, постоянно увеличивая количество монет [latex]a[/latex] на каждого пирата при этом, вычитая каждый раз из общего клада [latex]m[/latex], также, пока не выполняется данное равенство, считаем количество пиратов [latex]n[/latex], путем прибавления [latex]n + 1[/latex], пока работает цикл. И когда цикл прекращает свою работу, в конце учитываем капитана и к полученному количеству пиратов [latex]n[/latex] прибавляем [latex]n + 1[/latex]. И получаем ответ на нашу задачу.

Код программы (с условным оператором)

#include <iostream>
using namespace std;
 
int f(int a, int m, int n = 0) {
    if (m - 2*a == 0) {
        return n + 1;
    }
    else {
        return f(a + 1, m - a, n + 1);
    }
}
 
int main() {
    int a, m;
    cin >> a >> m;
    cout << f(a, m);
    return 0;
}

#include <iostream>

using namespace std;

int f(int a, int m, int n = 0) {

if (m - 2*a == 0) {

return n + 1;

}

else {

return f(a + 1, m - a, n + 1);

}

int main() {

int a, m;

cin >> a >> m;

cout << f(a, m);

return 0;

}

Решение задачи

В данном способе воспользуемся рекурсивной функцией и условными операторами. Как это работает: внутри рекурсивной функции расписываем условные операторы, которые определяют равенством [latex]m — 2a = 0[/latex] — когда наступила очередь капитана, а пока это условие не выполняется, функция будет вызывать сама себя пока это условие не удовлетворится, функция каждый раз вызывается с новыми параметрами соответственно. Где [latex]a[/latex] — количество монет даваемое пиратам, увеличивается по рангу каждого пирата, [latex]m[/latex] — клад, от него отнимаем текущее [latex]a[/latex], и [latex]n[/latex] — количество пиратов, считаем пиратов. И в конце выводит количество пиратов. Задача решена.

Ссылки

Related Images:

e-olymp 839. Пересечение отрезков

24/12/2018 by Анна Неделева

Задача

Два отрезка на плоскости заданы целочисленными координатами своих концов в декартовой системе координат.

Требуется определить, существует ли у них общая точка.

Входные данные

В первой строке содержатся координаты первого конца первого отрезка, во второй — второго конца первого отрезка, в третьей и четвёртой — координаты концов второго отрезка. Координаты целые и по модулю не превосходят $10000$.

Выходные данные

Вывести слово $Yes$, если общая точка есть, или слово $No$ в противном случае.

Тесты

№	Входные данные	Выходные данные
1	0 0 1 0 1 0 1 1	Yes
2	0 0 1 0 2 0 3 0	No
3	7 4 1 1 1 1 3 2	Yes
4	-9725 -8992 9812 9925 -9999 7011 8122 -9248	Yes
5	-9999 -1 10000 1 0 0 0 1	No

Код программы

С ветвлением:

#include <iostream>
#include <cmath>
#define E 1e-5
using namespace std;

double length(double x1, double y1, double x2, double y2){
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

bool is_include(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, double x, double y){
    return (
        abs(length(x1, y1, x, y) - length(x1, y1, x2, y2) + length(x, y, x2, y2)) <= E
    &&
        abs(length(x3, y3, x, y) - length(x3, y3, x4, y4) + length(x, y, x4, y4)) <= E
    );
}

bool is_overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
    return(
        abs(length(x1, y1, x3, y3) - length(x1, y1, x2, y2) + length(x3, y3, x2, y2)) <= E
    ||
        abs(length(x1, y1, x4, y4) - length(x1, y1, x2, y2) + length(x4, y4, x2, y2)) <= E
    ||
        abs(length(x3, y3, x1, y1) - length(x3, y3, x4, y4) + length(x1, y1, x4, y4)) <= E
    ||
        abs(length(x3, y3, x2, y2) - length(x3, y3, x4, y4) + length(x2, y2, x4, y4)) <= E
    );
}

int main() {
    long x1, y1, x2, y2, x3, y3, x4, y4;
    double x, y;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
    long long ky1, kx1, b1, ky2, kx2, b2;
    ky1 = y2 - y1;
    ky2 = y4 - y3;
    kx1 = x2 - x1;
    kx2 = x4 - x3;
    b1 = x1 * y2 - x2 * y1;
    b2 = x3 * y4 - x4 * y3;
    if (kx1 * ky2 == kx2 * ky1) {
        if (
            b1 * ky2 != b2 * ky1
        && 
            b1 * kx2 != b2 * kx1
        ) cout << "No";
        else if (is_overlap(x1, y1, x2, y2, x3, y3, x4, y4)) cout << "Yes";
        else cout << "No";
    } else {
        y = (double)(b2 * ky1 - b1 * ky2) / (double)(kx1 * ky2 - kx2 * ky1);
        x = (double)(b1 * kx2 - b2 * kx1) / (double)(ky1 * kx2 - ky2 * kx1);
        if (is_include(x1, y1, x2, y2, x3, y3, x4, y4, x, y)) cout << "Yes";
        else cout << "No";
    }
    return 0;
}

#include <iostream>

#include <cmath>

#define E 1e-5

using namespace std;

double length(double x1, double y1, double x2, double y2){

return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

}

bool is_include(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, double x, double y){

return (

abs(length(x1, y1, x, y) - length(x1, y1, x2, y2) + length(x, y, x2, y2)) <= E

abs(length(x3, y3, x, y) - length(x3, y3, x4, y4) + length(x, y, x4, y4)) <= E

);

}

bool is_overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {

return(

abs(length(x1, y1, x3, y3) - length(x1, y1, x2, y2) + length(x3, y3, x2, y2)) <= E

abs(length(x1, y1, x4, y4) - length(x1, y1, x2, y2) + length(x4, y4, x2, y2)) <= E

abs(length(x3, y3, x1, y1) - length(x3, y3, x4, y4) + length(x1, y1, x4, y4)) <= E

abs(length(x3, y3, x2, y2) - length(x3, y3, x4, y4) + length(x2, y2, x4, y4)) <= E

);

}

int main() {

long x1, y1, x2, y2, x3, y3, x4, y4;

double x, y;

cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;

long long ky1, kx1, b1, ky2, kx2, b2;

ky1 = y2 - y1;

ky2 = y4 - y3;

kx1 = x2 - x1;

kx2 = x4 - x3;

b1 = x1 * y2 - x2 * y1;

b2 = x3 * y4 - x4 * y3;

if (kx1 * ky2 == kx2 * ky1) {

if (

b1 * ky2 != b2 * ky1

b1 * kx2 != b2 * kx1

) cout << "No";

else if (is_overlap(x1, y1, x2, y2, x3, y3, x4, y4)) cout << "Yes";

else cout << "No";

} else {

y = (double)(b2 * ky1 - b1 * ky2) / (double)(kx1 * ky2 - kx2 * ky1);

x = (double)(b1 * kx2 - b2 * kx1) / (double)(ky1 * kx2 - ky2 * kx1);

if (is_include(x1, y1, x2, y2, x3, y3, x4, y4, x, y)) cout << "Yes";

else cout << "No";

}

return 0;

}

без ветвления:

#include <iostream>
#include <cmath>
#define E 1e-5
using namespace std;

double length(double x1, double y1, double x2, double y2){
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

bool is_include(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, double x, double y){
    return (
        abs(length(x1, y1, x, y) - length(x1, y1, x2, y2) + length(x, y, x2, y2)) <= E
    &&
        abs(length(x3, y3, x, y) - length(x3, y3, x4, y4) + length(x, y, x4, y4)) <= E
    );
}

bool is_overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
    return(
        abs(length(x1, y1, x3, y3) - length(x1, y1, x2, y2) + length(x3, y3, x2, y2)) <= E
    ||
        abs(length(x1, y1, x4, y4) - length(x1, y1, x2, y2) + length(x4, y4, x2, y2)) <= E
    ||
        abs(length(x3, y3, x1, y1) - length(x3, y3, x4, y4) + length(x1, y1, x4, y4)) <= E
    ||
        abs(length(x3, y3, x2, y2) - length(x3, y3, x4, y4) + length(x2, y2, x4, y4)) <= E
    );
}

int main() {
    long x1, y1, x2, y2, x3, y3, x4, y4;
    double x, y;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
    long long ky1, kx1, b1, ky2, kx2, b2;
    ky1 = y2 - y1;
    ky2 = y4 - y3;
    kx1 = x2 - x1;
    kx2 = x4 - x3;
    b1 = x1 * y2 - x2 * y1;
    b2 = x3 * y4 - x4 * y3;
    (kx1 * ky2 == kx2 * ky1) && (
        (
            b1 * ky2 != b2 * ky1
        && 
            b1 * kx2 != b2 * kx1
        ) && (cout << "No")
        || (is_overlap(x1, y1, x2, y2, x3, y3, x4, y4)) && (cout << "Yes") 
        || (cout << "No")
    ) || (
        y = (double)(b2 * ky1 - b1 * ky2) / (double)(kx1 * ky2 - kx2 * ky1),
        x = (double)(b1 * kx2 - b2 * kx1) / (double)(ky1 * kx2 - ky2 * kx1),
        (is_include(x1, y1, x2, y2, x3, y3, x4, y4, x, y)) && (cout << "Yes")
        || (cout << "No")
    );
    return 0;
}

#include <iostream>

#include <cmath>

#define E 1e-5

using namespace std;

double length(double x1, double y1, double x2, double y2){

return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

}

bool is_include(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, double x, double y){

return (

abs(length(x1, y1, x, y) - length(x1, y1, x2, y2) + length(x, y, x2, y2)) <= E

abs(length(x3, y3, x, y) - length(x3, y3, x4, y4) + length(x, y, x4, y4)) <= E

);

}

bool is_overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {

return(

abs(length(x1, y1, x3, y3) - length(x1, y1, x2, y2) + length(x3, y3, x2, y2)) <= E

abs(length(x1, y1, x4, y4) - length(x1, y1, x2, y2) + length(x4, y4, x2, y2)) <= E

abs(length(x3, y3, x1, y1) - length(x3, y3, x4, y4) + length(x1, y1, x4, y4)) <= E

abs(length(x3, y3, x2, y2) - length(x3, y3, x4, y4) + length(x2, y2, x4, y4)) <= E

);

}

int main() {

long x1, y1, x2, y2, x3, y3, x4, y4;

double x, y;

cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;

long long ky1, kx1, b1, ky2, kx2, b2;

ky1 = y2 - y1;

ky2 = y4 - y3;

kx1 = x2 - x1;

kx2 = x4 - x3;

b1 = x1 * y2 - x2 * y1;

b2 = x3 * y4 - x4 * y3;

(kx1 * ky2 == kx2 * ky1) && (

(

b1 * ky2 != b2 * ky1

b1 * kx2 != b2 * kx1

) && (cout << "No")

|| (is_overlap(x1, y1, x2, y2, x3, y3, x4, y4)) && (cout << "Yes")

|| (cout << "No")

) || (

y = (double)(b2 * ky1 - b1 * ky2) / (double)(kx1 * ky2 - kx2 * ky1),

x = (double)(b1 * kx2 - b2 * kx1) / (double)(ky1 * kx2 - ky2 * kx1),

(is_include(x1, y1, x2, y2, x3, y3, x4, y4, x, y)) && (cout << "Yes")

|| (cout << "No")

);

return 0;

}

Решение задачи

Чтобы проверить пересекаются ли заданные отрезки построим прямые, которым они принадлежат, затем найдём точку их пересечения и проверим принадлежит ли она каждому из отрезков.
Для построения прямых воспользуемся формулой прямой проходящей через две точки и немного её преобразуем:
$\frac{x — x_1}{x_2 — x_1} = \frac{y — y_1}{y_2 — y_1}$ ~ $(x — x_1) \cdot (y_2 — y_1) = (y — y_1) \cdot (x_2 — x_1)$ ~ $x \cdot (y_2 — y_1) — y_2 \cdot x_1 + y_1 \cdot x_1 = y \cdot (x_2 — x_1) — x_2 \cdot y_1 + x_1 \cdot y_1$ ~ $y \cdot (x_2 — x_1) = x \cdot (y_2 — y_1) + x_2 \cdot y_1 — x_1 \cdot y_2$.
Обозначим за $k_x$ множитель при $x$, за $k_y$ множитель при $y$, а всё остальное за $b$. Тогда имеем уравнение вида:
$y \cdot k_y = x \cdot k_x + b$, таких у нас будет 2:

$y \cdot k_{y_1} = x \cdot k_{x_1} + b_1$
$y \cdot k_{y_2} = x \cdot k_{x_2} + b_2$

Теперь рассмотрим несколько случаев:
1. Прямые параллельны, следовательно могут не иметь точки пересечения или совпадать.
Проверим совпадают ли $b_1$ и $b_2$. Так как уравнения не сокращены на НОД, то рассмотрим равенство отношений $b_1$ и $b_2$ на $k_{y_1}$, $k_{x_1}$ и $k_{y_2}$, $k_{x_2}$ соответственно. Если они равны, то прямые совпадают. Иначе не имеют точек пересечения, а следовательно и отрезки тоже не пересекаются.
Когда прямые совпадают, необходимо проверить, что отрезки на этой прямой имеют хоть какую-то общую точку. Каждый из концов каждого отрезка проверим на вхождение в другой. Если такое вхождение есть, то отрезки пересекаются, иначе нет.
2. Прямые не параллельны, а следовательно имеют точку пересечения.
Тогда, решив систему двух линейных уравнений в общем виде получим что:

$x = \frac{b_1 \cdot k_{x_2} — b_2 \cdot k_{x_1}}{k_{y_1} \cdot k_{x_2} — k_{x_1} \cdot k_{y_2}}$
$y = \frac{b_2 \cdot k_{y_1} — b_1 \cdot k_{y_2}}{k_{x_1} \cdot k_{y_2} — k_{y_1} \cdot k_{x_2}}$

Осталось проверить находится ли точка с координатами $(x, y)$ в каждом из отрезков. Для этого просуммируем расстояния от этой точки до границ каждого отрезка и сравним с длинами отрезков. Если суммы соответственно совпали с длинами, то отрезки пересекаются, иначе — нет.

Ссылки

Related Images:

e-olymp 8521. Условный оператор — 2

23/12/2018 by Даниил Кадзевич

Задача

Вычислите значение y в соответствии со следующим условием:

[latex]y=\begin{cases}x^{3} + 5x, x\geq 10\\\ x^{2} — 2x + 4 , x < 10\end{cases}[/latex]

Входные данные

Одно целое число [latex] x(-10000 ≤ x ≤ 10000)[/latex].

Выходные данные

Выведите значение y в соответствии с заданным условием.

Тесты

№	Ввод	Вывод
1	2	4
2	20	8100
3	100	1000500
3	-5	39

Программы с ветвлением

#include <iostream>

using namespace std;

long long int f(int x) {
    return (x >= 10) ? (x*x*x + x*5) : (x*x - 2*x + 4);
}

int main() {
    int x;
    cin >> x;
    cout << f(x) << endl;
    return 0;
}

#include <iostream>

using namespace std;

long long int f(int x) {

return (x >= 10) ? (x*x*x + x*5) : (x*x - 2*x + 4);

}

int main() {

int x;

cin >> x;

cout << f(x) << endl;

return 0;

}

Решение

Используем тернарный оператор для проверки [latex]x\geq 10[/latex].

Ссылки

Линейные вычисления

#include <iostream>

using namespace std;

int main() {
    long long int x;
    cin >> x;
    (x >= 10) && (cout << (x*x*x + x*5) << endl);
    (x < 10) && (cout << (x*x - 2*x + 4) << endl);
    return 0;
}

#include <iostream>

using namespace std;

int main() {

long long int x;

cin >> x;

(x >= 10) && (cout << (x*x*x + x*5) << endl);

(x < 10) && (cout << (x*x - 2*x + 4) << endl);

return 0;

}

Решение

Используем логический оператор && так как он не вычисляет второе условие, если первое ложно.

Ссылки

Related Images:

e-olymp 774. Торт

22/12/2018 by Виктор Иванов

Задача

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

Входные данные

Содержит три натуральных числа: радиус стола [latex]r \left(1\leqslant r\leqslant 1000 \right)[/latex], ширину [latex]w[/latex] и длину [latex]l[/latex] торта [latex] \left(1\leqslant w \leqslant l \leqslant 1000\right)[/latex].

Выходные данные

Вывести слово [latex]YES[/latex], если торт помещается на стол, и слово [latex]NO[/latex] в противном случае.

Тесты

№	Входные данные	Выходные данные
1	38 40 60	YES
2	35 20 70	NO
3	50 60 80	YES
4	30 60 90	NO

Код программы

с ветвлением:

#include <iostream>

using namespace std;
int main() {
    int r, w, l;
    cin >> r >> w >> l;
    cout << (w * w + l * l <= 4 * r * r ? "YES" : "NO");
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int r, w, l;

cin >> r >> w >> l;

cout << (w * w + l * l <= 4 * r * r ? "YES" : "NO");

return 0;

}

без ветвления:

#include <iostream>
using namespace std;

bool myBool(int x, int y, int z) {
    return(x * x + y * y <= 4 * z * z);
}

int main() {
    int r, w, l;
    cin >> r >> w >> l;
    myBool(w, l, r) && cout << "YES";
    !myBool(w, l, r) && cout << "NO";
    return 0;
}

#include <iostream>

using namespace std;

bool myBool(int x, int y, int z) {

return(x * x + y * y <= 4 * z * z);

}

int main() {

int r, w, l;

cin >> r >> w >> l;

myBool(w, l, r) && cout << "YES";

!myBool(w, l, r) && cout << "NO";

return 0;

}

Решение задачи

Вписанный в окружность прямоугольник

Для того, чтобы узнать, помещается торт на столе или нет, необходимо найти диагональ прямоугольного торта. Зная длину и ширину прямоугольника, находим диагональ по теореме Пифагора. Если она равна или меньше диаметра стола $AB^2$ + $AD^2$ <= 4$OD^2$, значит торт помещается, и пишем "YES". Если диагональ больше диаметра стола, пишем "NO".

Ссылки

Условие задачи на e-olymp
Код программы с ветвлением на ideone
Код программы без ветвления на ideone

Related Images:

e-olymp 8523. Окружность

22/12/2018 by Богдан Подгорный

Задача взята с сайта e-olymp

Условие

Задан радиус окружности [latex]r[/latex]. Найдите длину окружности и ее площадь.

Входные данные

Радиус окружности [latex]r (r >0)[/latex], являющийся действительным числом.

Выходные данные

Вывести в одной строке длину окружности и ее площадь с [latex]4[/latex] десятичными знаками.

Тесты

№	Inputs	Outputs
1	1.234	7.7535 4.7839
2	3.5	7.7535 4.7839
3	0	0.0000 0.0000
4	10	62.8319 314.1539
5	313	1966.6370 307778.6907

Код

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

int main() {
    double r;
    cin >> r;
    cout << fixed << setprecision(4) << 2*M_PI*r << " " << M_PI*r*r;
    return 0;
}

#include <iostream>

#include <iomanip>

#include <cmath>

using namespace std;

int main() {

double r;

cin >> r;

cout << fixed << setprecision(4) << 2*M_PI*r << " " << M_PI*r*r;

return 0;

}

Решение

По известным формулам длины окружности [latex]l = 2\pi r[/latex] и площади окружности [latex]S = \pi r^{2}[/latex] находим их. С помощью setprecison() выводим числа с нужной нам точностью.

Ссылки

Related Images:

e-olymp 7944. Площадь прямоугольника

22/12/2018 by Лиза Севастьянова

Задача

Найдите площадь прямоугольника.

Входные данные

Целочисленные стороны прямоугольника $a$ и $b$ ($1 \leq a$, $b \leq 1000$).

Выходные данные

Выведите площадь прямоугольника.

Тесты

№	Входные данные	Выходные данные
1	3 4	12
2	5 12	60
3	1 1	1
4	1000 1000	1000000

Решение

Для нахождение площади прямоугольника воспользуемся формулой $S = a \cdot b$, где $a$ и $b$ — стороны данного прямоугольника, а $S$ — площадь прямоугольника.

Код программы

#include <iostream>
using namespace std;

int main() {
    int  a;
    int b;
    cin >> a;
    cin >> b;
    cout << a*b;
}

#include <iostream>

using namespace std;

int main() {

int a;

int b;

cin >> a;

cin >> b;

cout << a*b;

}

Ссылки

Related Images:

e-olymp 8528. Система глобальнейшего позиционирования

17/12/2018 by Таисия Ткачева

Задача

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

Для этого во Флатландии было построено три радиовышки, не находящиеся на одной прямой. Объект, который хочет узнать свое местоположение, посылает вышкам сигнал. По силе сигнала, дошедшего до вышек, определяется расстояние между вышками и объектом.
Напишите программу, которая реализует последний компонент системы, который, получая координаты вышек и расстояния от объекта до каждой из них, находит координаты объекта.

Входные данные

В первой строке находятся три пары чисел $x_{1}$, $y_{1}$, $x_{2}$, $y_{2}$, $x_{3}$ и $y_{3}$ — координаты вышек. Во второй строке находятся три неотрицательных числа — расстояния до соответствующих вышек. Все входные числа целые и по модулю не превышают $50$.

Выходные данные

Если не существует такого местоположения объекта, что расстояния до вышек соответствовали бы данным, то выведите в единственное слово «Impossible». Иначе выведите два числа — координаты объекта с точностью до шести знаков после запятой.

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	0 4 2 6 5 0 2 2 5	2.000000 4.000000
2	2 2 0 1 1 1 2.828427 1 1.4142135	0.000000 0.000000
3	-5 3 -3 3 -2 4 3 1 1	-2.000000 3.000000
4	0 0 2 1 2 -2 0.841722586 2 2	0.677124 -0.500000
5	0 0 10 0 5 6 7 7 1	Impossible

Код программы (Линейные вычисления)

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

int main() {
    double eps = 1e-6;
    double x1, y1, x2, y2, x3, y3, r1, r2, r3, x, y;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> r1 >> r2 >> r3;
    x = ((y2 - y1) * (r2 * r2 - r3 * r3 - y2 * y2 + y3 * y3 - x2 * x2 + x3 * x3) - (y3 - y2) * (r1 * r1 - r2 * r2 - y1 * y1 + y2 * y2 - x1 * x1 + x2 * x2)) / (2 * ((y3 - y2) * (x1 - x2)  - (y2 - y1) * (x2 - x3)));
    y = ((x2 - x1) * (r2 * r2 - r3 * r3 - x2 * x2 + x3 * x3 - y2 * y2 + y3 * y3) - (x3 - x2) * (r1 * r1 - r2 * r2 - x1 * x1 + x2 * x2 - y1 * y1 + y2 * y2)) / (2 * ((x3 - x2) * (y1 - y2)  - (x2 - x1) * (y2 - y3)));
    ((abs((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) - r1 * r1) < eps) && (cout << fixed << setprecision (6) << x << " " << y << endl)) || ((abs((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) - r1 * r1) >= eps) && (cout << "Impossible" << endl)); 
    return 0;
}

#include <iostream>

#include <iomanip>

#include <cmath>

using namespace std;

int main() {

double eps = 1e-6;

double x1, y1, x2, y2, x3, y3, r1, r2, r3, x, y;

cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> r1 >> r2 >> r3;

x = ((y2 - y1) * (r2 * r2 - r3 * r3 - y2 * y2 + y3 * y3 - x2 * x2 + x3 * x3) - (y3 - y2) * (r1 * r1 - r2 * r2 - y1 * y1 + y2 * y2 - x1 * x1 + x2 * x2)) / (2 * ((y3 - y2) * (x1 - x2) - (y2 - y1) * (x2 - x3)));

y = ((x2 - x1) * (r2 * r2 - r3 * r3 - x2 * x2 + x3 * x3 - y2 * y2 + y3 * y3) - (x3 - x2) * (r1 * r1 - r2 * r2 - x1 * x1 + x2 * x2 - y1 * y1 + y2 * y2)) / (2 * ((x3 - x2) * (y1 - y2) - (x2 - x1) * (y2 - y3)));

((abs((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) - r1 * r1) < eps) && (cout << fixed << setprecision (6) << x << " " << y << endl)) || ((abs((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) - r1 * r1) >= eps) && (cout << "Impossible" << endl));

return 0;

}

Код программы (Ветвления)

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
 
int main() {
    double eps = 1e-6;
    double x1, y1, x2, y2, x3, y3, r1, r2, r3, x, y;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> r1 >> r2 >> r3;
    x = ((y2 - y1) * (r2 * r2 - r3 * r3 - y2 * y2 + y3 * y3 - x2 * x2 + x3 * x3) - (y3 - y2) * (r1 * r1 - r2 * r2 - y1 * y1 + y2 * y2 - x1 * x1 + x2 * x2)) / (2 * ((y3 - y2) * (x1 - x2)  - (y2 - y1) * (x2 - x3)));
    y = ((x2 - x1) * (r2 * r2 - r3 * r3 - x2 * x2 + x3 * x3 - y2 * y2 + y3 * y3) - (x3 - x2) * (r1 * r1 - r2 * r2 - x1 * x1 + x2 * x2 - y1 * y1 + y2 * y2)) / (2 * ((x3 - x2) * (y1 - y2)  - (x2 - x1) * (y2 - y3)));
    if (abs((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) - r1 * r1) < eps) cout << fixed << setprecision (6) << x << " " << y << endl;
    else cout << "Impossible" << endl; 
    return 0;
}

#include <iostream>

#include <iomanip>

#include <cmath>

using namespace std;

int main() {

double eps = 1e-6;

double x1, y1, x2, y2, x3, y3, r1, r2, r3, x, y;

cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> r1 >> r2 >> r3;

if (abs((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y) - r1 * r1) < eps) cout << fixed << setprecision (6) << x << " " << y << endl;

else cout << "Impossible" << endl;

return 0;

}

Решение задачи

Для решения данной задачи нужно найти точку пересечения трёх окружностей, следовательно получаем систему из трёх уравнений окружностей, а именно:

[latex]\begin{cases}(x_{1} — x)^{2} + (y_{1} — y)^{2} = r_{1}^{2},\\(x_{2} — x)^{2} + (y_{2} — y)^{2} = r_{2}^{2}, \\(x_{3} — x)^{2} + (y_{3} — y)^{2} = r_{3}^{2};\end{cases}[/latex]

где $x_{1}$, $y_{1}$, $x_{2}$, $y_{2}$, $x_{3}$ и $y_{3}$ — координаты вышек, $r_{1}$, $r_{2}$ и $r_{3}$ — расстояния до соответствующих вышек, $x$ и $y$ — координаты объекта.

После применения формул сокращённого умножения многочленов, получим систему вида:

[latex]\begin{cases}x_1^2-2x_{1}x+x^{2}+y_1^2-2y_{1}y+y^{2}=r_1^2, & (1)\\x_2^2-2x_{2}x+x^{2}+y_2^2-2y_{2}y+y^{2}=r_2^2, & (2)\\x_3^2-2x_{3}x+x^{2}+y_3^2-2y_{3}y+y^{2}=r_3^2; & (3)\end{cases}[/latex]

Отнимем от первого уравнения второе и от второго уравнения третье, получим:

[latex]\begin{cases}x_1^2-x_2^2-2x_{1}x+2x_{2}x+y_1^2-y_2^2-2y_{1}y+2y_{2}y=r_1^2-r_2^2, & (1)-(2)\\x_2^2-x_3^2-2x_{2}x+2x_{3}x+y_2^2-y_3^2-2y_{2}y+2y_{3}y=r_2^2-r_3^2; & (2)-(3)\end{cases}[/latex]

Далее выражаем $x$ и $y$:

[latex]\begin{cases}2y(y_{2}-y_{1})=r_1^2-r_2^2-x_1^2+x_2^2+2x_{1}x-2x_{2}x-y_1^2+y_2^2,\\2y(y_{3}-y_{2})=r_2^2-r_3^2-x_2^2+x_3^2+2x_{2}x-2x_{3}x-y_2^2+y_3^2;\end{cases}[/latex] [latex]\begin{cases}2x(x_{2}-x_{1})=r_1^2-r_2^2-y_1^2+y_2^2+2y_{1}y-2y_{2}y-x_1^2+x_2^2,\\2x(x_{3}-x_{2})=r_2^2-r_3^2-y_2^2+y_3^2+2y_{2}y-2y_{3}y-x_2^2+x_3^2;\end{cases}[/latex] [latex]\begin{cases}y=\frac{r_1^2-r_2^2-x_1^2+x_2^2+2x_{1}x-2x_{2}x-y_1^2+y_2^2}{2(y_{2}-y_{1})},\\y=\frac{r_2^2-r_3^2-x_2^2+x_3^2+2x_{2}x-2x_{3}x-y_2^2+y_3^2}{2(y_{3}-y_{2})};\end{cases}[/latex] [latex]\begin{cases}x=\frac{r_1^2-r_2^2-y_1^2+y_2^2+2y_{1}y-2y_{2}y-x_1^2+x_2^2}{2(x_{2}-x_{1})},\\x=\frac{r_2^2-r_3^2-y_2^2+y_3^2+2y_{2}y-2y_{3}y-x_2^2+x_3^2}{2(x_{3}-x_{2})};\end{cases}[/latex]

Приравняем соответствующие координаты объекта, получим систему вида:

[latex]\begin{cases}\frac{r_1^2-r_2^2-x_1^2+x_2^2+2x_{1}x-2x_{2}x-y_1^2+y_2^2}{2(y_{2}-y_{1})}=\frac{r_2^2-r_3^2-x_2^2+x_3^2+2x_{2}x-2x_{3}x-y_2^2+y_3^2}{2(y_{3}-y_{2})},\\\frac{r_1^2-r_2^2-y_1^2+y_2^2+2y_{1}y-2y_{2}y-x_1^2+x_2^2}{2(x_{2}-x_{1})}=\frac{r_2^2-r_3^2-y_2^2+y_3^2+2y_{2}y-2y_{3}y-x_2^2+x_3^2}{2(x_{3}-x_{2})};\end{cases}[/latex]

Находим координаты объекта:

[latex]\begin{cases} \begin{split} 2(y_{3}-y_{2})(r_1^2-r_2^2-x_1^2+x_2^2+2x_{1}x-2x_{2}x-y_1^2+y_2^2)= \\ =2(y_{2}-y_{1})(r_2^2-r_3^2-x_2^2+x_3^2+2x_{2}x-2x_{3}x-y_2^2+y_3^2),\\2(x_{3}-x_{2})(r_1^2-r_2^2-y_1^2+y_2^2+2y_{1}y-2y_{2}y-x_1^2+x_2^2)= \\ =2(x_{2}-x_{1})(r_2^2-r_3^2-y_2^2+y_3^2+2y_{2}y-2y_{3}y-x_2^2+x_3^2); \end{split} \end{cases}[/latex] [latex]\begin{cases} \begin{split} 2(y_{3}-y_{2})(2x_{1}x-2x_{2}x)-2(y_{2}-y_{1})(2x_{2}x-2x_{3}x) = \\ =2(y_{2}-y_{1})(r_2^2-r_3^2-x_2^2+x_3^2-y_2^2+y_3^2)-\\-2(y_{3}-y_{2})(r_1^2-r_2^2-x_1^2+x_2^2-y_1^2+y_2^2),\\2(x_{3}-x_{2})(2y_{1}y-2y_{2}y)-2(x_{2}-x_{1})(2y_{2}y-2y_{3}y)= \\ =2(x_{2}-x_{1})(r_2^2-r_3^2-y_2^2+y_3^2-x_2^2+x_3^2)-\\-2(x_{3}-x_{2})(r_1^2-r_2^2-y_1^2+y_2^2-x_1^2+x_2^2);\end{split}\end{cases}[/latex] [latex]\begin{cases} \begin{split} 4x(y_{3}-y_{2})(x_{1}-x_{2})-4x(y_{2}-y_{1})(x_{2}-x_{3})= \\ =2(y_{2}-y_{1})(r_2^2-r_3^2-x_2^2+x_3^2-y_2^2+y_3^2)-\\-2(y_{3}-y_{2})(r_1^2-r_2^2-x_1^2+x_2^2-y_1^2+y_2^2),\\4y(x_{3}-x_{2})(y_{1}-y_{2})-4y(x_{2}-x_{1})(y_{2}-y_{3})= \\ =2(x_{2}-x_{1})(r_2^2-r_3^2-y_2^2+y_3^2-x_2^2+x_3^2)-\\-2(x_{3}-x_{2})(r_1^2-r_2^2-y_1^2+y_2^2-x_1^2+x_2^2);\end{split}\end{cases}[/latex] [latex]\begin{cases}x=\frac{2((y_{2}-y_{1})(r_2^2-r_3^2-x_2^2+x_3^2-y_2^2+y_3^2)-(y_{3}-y_{2})(r_1^2-r_2^2-x_1^2+x_2^2-y_1^2+y_2^2))}{4((y_{3}-y_{2})(x_{1}-x_{2})-(y_{2}-y_{1})(x_{2}-x_{3}))},\\y=\frac{2((x_{2}-x_{1})(r_2^2-r_3^2-y_2^2+y_3^2-x_2^2+x_3^2)-(x_{3}-x_{2})(r_1^2-r_2^2-y_1^2+y_2^2-x_1^2+x_2^2))}{4((x_{3}-x_{2})(y_{1}-y_{2})-(x_{2}-x_{1})(y_{2}-y_{3}))};\end{cases}[/latex] [latex]\begin{cases}x=\frac{(y_{2}-y_{1})(r_2^2-r_3^2-x_2^2+x_3^2-y_2^2+y_3^2)-(y_{3}-y_{2})(r_1^2-r_2^2-x_1^2+x_2^2-y_1^2+y_2^2)}{2((y_{3}-y_{2})(x_{1}-x_{2})-(y_{2}-y_{1})(x_{2}-x_{3}))},\\y=\frac{(x_{2}-x_{1})(r_2^2-r_3^2-y_2^2+y_3^2-x_2^2+x_3^2)-(x_{3}-x_{2})(r_1^2-r_2^2-y_1^2+y_2^2-x_1^2+x_2^2)}{2((x_{3}-x_{2})(y_{1}-y_{2})-(x_{2}-x_{1})(y_{2}-y_{3}))}.\end{cases}[/latex]

Далее проводим проверку на принадлежность найденных координат объекта одной из окружностей. Если найденные координаты принадлежат окружности, то выводим два числа — координаты объекта с точностью до шести знаков после запятой. Если найденные координаты не принадлежат окружности, это означает, что не существует такого местоположения объекта, тогда выводим единственное слово «Impossible».

Ссылки

Условие на e-olymp

Код программы (Линейные вычисления)

Код программы (Ветвления)

Related Images:

e-olymp 7943. Периметр прямоугольника

15/12/2018 by Александр Колаев

Задача

Найдите периметр прямоугольника.

Входные данные

Целочисленные стороны прямоугольника [latex]a[/latex] и [latex]b\left(1\leq a, b\leq 1000\right)[/latex]

Выходные данные

Выведите периметр прямоугольника.

Тесты

Входные данные	Выходные данные
1 1	4
1000 1000	4000
10 20	60
12 13	50
176 37	426

Решение

#include <iostream>;
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    cout << (a + b) * 2;
    return 0;
}

#include <iostream>;

using namespace std;

int main() {

int a, b;

cin >> a >> b;

cout << (a + b) * 2;

return 0;

}

Объяснение

Поскольку стороны прямоугольника, используемые в задаче, целочисленные, и каждое из них меньше [latex]1000[/latex] то переменные создаём типа int. Для решения этой задачи воспользуемся формулой нахождения периметра прямоугольника: [latex] (a+b) \cdot 2 [/latex]

e-olymp
Запустить код на выполнение можно здесь

Related Images:

e-olymp 1312. Шкаф

04/12/2018 by Николь Метри

Задача

Размеры шкафа [latex] a \times b \times c [/latex]. Возможно ли его пронести через дверной проём с размерами [latex]x \times y[/latex]? Считается, что шкаф проходит в проем, если размеры, которыми его будут вносить сквозь дверь, не больше соответствующих размеров двери.

Входные данные

Целые числа [latex] a, b, c, x, y (1 ≤ a, b, c, x, y ≤ 100)[/latex].

Выходные данные

Вывести строку «YES«, если шкаф пронести возможно, и «NO» если нельзя.

Тесты

№	Ввод	Вывод
1	4 5 6 10 20	YES
2	4 5 6 3 4	NO
3	12 3 4 5 6	YES
4	12 3 6 5 6	YES
5	12 3 7 5 6	NO

Код программы

#include <iostream>
using namespace std;

int main() {
    int a, b, c, y, x;
    std::cin >> a >> b >> c >> y >> x;
    if ((a<=y && b<=x) || (a<=x && b<=y) || (a<=y && c<=x) || (a<=x && c<=y) ||
        (b<=y && c<=x) || (b<=x && c<=y)) cout << "YES";
    else cout << "NO";
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int a, b, c, y, x;

std::cin >> a >> b >> c >> y >> x;

if ((a<=y && b<=x) || (a<=x && b<=y) || (a<=y && c<=x) || (a<=x && c<=y) ||

(b<=y && c<=x) || (b<=x && c<=y)) cout << "YES";

else cout << "NO";

return 0;

}

Либо

#include <iostream>

using namespace std; 

bool skf(int q, int w, int e, int r){
    return ((q<=e && w<=r) || (q<=r && w<=e));
}

int main(){
    int a, b, c, x, y;
    cin >> a >> b >> c >> x >> y;
    if (skf(a, b, x, y) || skf(b, c, x, y) || skf(a, c, x, y)) cout << "YES";
    else cout << "NO";
return 0;

}

#include <iostream>

using namespace std;

bool skf(int q, int w, int e, int r){

return ((q<=e && w<=r) || (q<=r && w<=e));

}

int main(){

int a, b, c, x, y;

cin >> a >> b >> c >> x >> y;

if (skf(a, b, x, y) || skf(b, c, x, y) || skf(a, c, x, y)) cout << "YES";

else cout << "NO";

return 0;

}

Без условных операторов

#include <iostream>
using namespace std; 

bool skf(int q, int w, int e, int r){
    return ((q<=e && w<=r) || (q<=r && w<=e)); 
}

int main (){ 
    int a, b, c, x, y; 
    cin >> a >> b >> c >> x >> y; 
    (skf(a, c, x, y) or skf(b, c, x, y) or skf(a, b, x, y)) && cout << "YES";
    !(skf(a, c, x, y) or skf(b, c, x, y) or skf(a, b, x, y)) && cout << "NO";
    return 0; 
}

#include <iostream>

using namespace std;

bool skf(int q, int w, int e, int r){

return ((q<=e && w<=r) || (q<=r && w<=e));

}

int main (){

int a, b, c, x, y;

cin >> a >> b >> c >> x >> y;

(skf(a, c, x, y) or skf(b, c, x, y) or skf(a, b, x, y)) && cout << "YES";

!(skf(a, c, x, y) or skf(b, c, x, y) or skf(a, b, x, y)) && cout << "NO";

return 0;

}

Решение задачи

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

Ссылки

Related Images:

e-olymp 4717. Дележ яблок — 2

30/11/2018 by Дарья Найденова

Задача

$n$ школьников делят $k$ яблок поровну, не делящийся остаток остаётся в корзинке. Сколько яблок останется в корзинке?

Входные данные

Два положительных целых числа $n$ и $k$, не больших 1500.

Выходные данные

Вывести количество яблок, которое останется в корзинке.

Тесты

Входные данные	Выходные данные
200 300	100
1500 1500	0
30 600	0
12 15	3
152 1432	64

Код программы

#include <iostream>
using namespace std;
 
int main() {
    int n, k;
    cin >> n >> k; //n - количество школьников, k - количество яблок
    cout << k % n;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n, k;

cin >> n >> k; //n - количество школьников, k - количество яблок

cout << k % n;

return 0;

}

Решение

Ответом является остаток от деления $k$ на $n$.

e-olymp

ideone

Related Images:

e-olymp 1949. Торт

27/11/2018 by Дмитрий Лозинский

На свой день рождения Петя купил красивый и вкусный торт, который имел идеально круглую форму. Петя не знал, сколько гостей придет на его день рождения, поэтому вынужден был разработать алгоритм, согласно которому он сможет быстро разрезать торт на [latex]N[/latex] равных частей. Следует учесть, что разрезы торта можно производить как по радиусу, так и по диаметру.

Помогите Пете решить эту задачу, определив наименьшее число разрезов торта по заданному числу гостей.

Задача взята с сайта e-olymp.

Входные данные

Входной файл содержит натуральное число [latex]N[/latex] – число гостей, включая самого виновника торжества ([latex]N \leq 1000[/latex]).

Выходные данные

Выведите минимально возможное число разрезов торта.

Тесты

Число гостей	Минимальное количество рaзрезов
1	0
8	4
13	13

Алгоритм

В данной задаче достаточно заметить следующее:

В случае четного количества гостей необходимо сделать [latex]\frac{N}{2}[/latex] разрезов по диаметру торта.
В случае нечетного количества гостей необходимо сделать [latex]N[/latex] разрезов по радиусу торта.
В случае если гостей 1 то выведем 0 т.к. торт резать не нужно.

Код с использованием ветвления:

#include <iostream>
using namespace std;

int main() {
    int N;
    cin >> N;
    cout << ((N % 2 == 0) || (N == 1)? N/2 : N); 
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int N;

cin >> N;

cout << ((N % 2 == 0) || (N == 1)? N/2 : N);

return 0;

}

Код без использования ветвления:

#include <iostream>
using namespace std;

int main() {
    int N;
    cin >> N;
    (N % 2 == 0 || N == 1) && (cout << N/2);
    !(N % 2 == 0 || N == 1) && (cout << N);
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int N;

cin >> N;

(N % 2 == 0 || N == 1) && (cout << N/2);

!(N % 2 == 0 || N == 1) && (cout << N);

return 0;

}

Код программы:

Related Images:

e-olymp 945. Без средней

26/11/2018 by Евгений Рудницкий

Задача: Без средней

Записать заданное трехзначное натуральное число без средней цифры.
Входные данные
Одно натуральное трехзначное число.
Выходные данные
Вывести трехзначное число без средней цифры.

Тесты

Ввод	Вывод
157	17
242	22
578	58

Решение

Есть как минимум два способа решения данной задачи. Первый очень простой — нам просто нужно вывести 1-ю цифру и 3-ю. Таким образом мы выведем число без средней.

#include <iostream>
using namespace std;
int main()
{
    char a;
    cin.get(a);
    cout << a;
    cin.get(a);
    cin.get(a);
    cout << a;
    return 0;
}

#include <iostream>

using namespace std;

int main()

{

char a;

cin.get(a);

cout << a;

cin.get(a);

cout << a;

return 0;

}

Второй способ сложнее и выполняется дольше, но он использует линейные вычисления. Мы вводим а, затем получаем разряд сотен умножаем его на 10, потом единиц и суммируем. Таким образом мы получим число, у которого разряд единиц от предыдущего а десятки от сотен предыдущего. Таким образом мы исключаем среднее.

#include <iostream>
using namespace std;
int main() {
  int a;
  cin >> a;
  a = (a / 100) * 10 + a % 10;
  cout << a;
  return 0;
}

#include <iostream>

using namespace std;

int main() {

int a;

cin >> a;

a = (a / 100) * 10 + a % 10;

cout << a;

return 0;

}

Ссылки

Related Images:

e-olymp 2060 Сказка о яблоке

20/11/2018 by Николай Козиний

Задача взята с сайта e-olymp

Задача

Однажды царь наградил крестьянина яблоком из своего сада. Пошёл крестьянин к саду и видит: весь сад огорожен $n$ заборами, в каждом заборе только одни ворота, и в каждых воротах стоит сторож. Подошёл крестьянин к первому сторожу и показал царский указ, а сторож ему в ответ: «Иди возьми, но при выходе отдашь мне половину тех яблок, что несёшь, и ещё одно». То же ему сказали и второй, и третий сторож и т.д. Сколько яблок должен взять крестьянин, чтобы после расплаты со сторожами у него осталось одно яблоко?

Входные данные

Количество заборов $n (1 \leqslant n \leqslant 62)$ в саду.

Выходные данные

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

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	1	4
2	3	22
3	30	50331646
4	60	3458764513820540926
5	62	13835058055282163710

Решение

Циклы

Последовательность необходимых количеств яблок задается формулой $x_{n+1}=2 \cdot (x_{n}+1);x_{1}=1.$ Мы можем поочередно вычислять элементы последовательности через цикл.

#include <iostream>
int main() {
    int n;
    std::cin>>n;
    unsigned long long k = 1;
    for(int i = 0; i<n; i++)k = (k + 1) * 2;
    std::cout<<k;
}

#include <iostream>

int main() {

int n;

std::cin>>n;

unsigned long long k = 1;

for(int i = 0; i<n; i++)k = (k + 1) * 2;

std::cout<<k;

}

Линейное решение

Преобразуем исходное выражение для $x_{n+1}=2 \cdot x_{n}+2.$ Можно видеть, что каждая следующая итерация увеличивает степень всех двоек входящих в предыдущую на 1 и добавляет 2. Выпишем формулу для $x_{n+m}=2^{m}x_n+2^{m-1}x_n+\cdots+2.$ Можно увидеть, что $x_{n+m}$ содержит слагаемое $2^{m}x$, а так же сумму слагаемых вида $\displaystyle \sum_{i=1}^{m}2^i \displaystyle.$ Если учесть, что $x_{1}=1$, то $\displaystyle x_n=2^{n}+ \sum_{i=1}^{n}2^i \displaystyle=2^{n+1}+2^n-2=2^{n}\cdot(2+1) -2.$ Следовательно формула $n$-го члена — [latex]x_n=3\cdot 2^n-2.[/latex]

#include <iostream>
int main() {
    int n;
    std::cin>>n;
    unsigned long long t = 2;
    std::cout<<3*(t<<n-1)-2;
}

#include <iostream>

int main() {

int n;

std::cin>>n;

unsigned long long t = 2;

std::cout<<3*(t<<n-1)-2;

}

Решения на ideone

Related Images:

e-olymp 8352. Такси

08/11/2018 by Дария Даниленко

В час пик на остановку одновременно подъехали три маршрутных такси, следующие по одному маршруту, в которые тут же набились пассажиры. Водители обнаружили, что количество людей в разных маршрутках разное, и решили пересадить часть пассажиров так, чтобы в каждой маршрутке было поровну пассажиров. Требуется определить, какое наименьшее количество пассажиров придется при этом пересадить.

Входные данные

Три натуральных числа, не превосходящих $100$ — количество пассажиров в первой, второй и третьей маршрутках соответственно.

Выходные данные

Выведите одно число — наименьшее количество пассажиров, которое требуется пересадить. Если это невозможно, выведите слово [latex]IMPOSSIBLE[/latex] (заглавными буквами).

Тесты

№	Ввод	Вывод
1	1 2 3	1
2	100 100 99	IMPOSSIBLE
3	100 100 100	0
4	19 59 6	31
5	30 9 74	IMPOSSIBLE

Код программы (Линейные вычисления)

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

int main() {
  int b1, b2, b3, pas, need; 
  bool f;
  cin >> b1 >> b2 >> b3;
  need = (b1 + b2 + b3)/3;
  pas = (abs(b1 - need) + abs(b2 - need) + abs(b3 - need)) / 2;
  f = (b1 + b2 + b3) % 3;
  (f == true) and cout << "IMPOSSIBLE";
  (f == false) and cout << pas;
  return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main() {

int b1, b2, b3, pas, need;

bool f;

cin >> b1 >> b2 >> b3;

need = (b1 + b2 + b3)/3;

pas = (abs(b1 - need) + abs(b2 - need) + abs(b3 - need)) / 2;

f = (b1 + b2 + b3) % 3;

(f == true) and cout << "IMPOSSIBLE";

(f == false) and cout << pas;

return 0;

}

Решение

В начале выводим полную формулу. Для этого находим, сколько пассажиров должно быть в одном автобусе после всех перестановок : $\frac{b_1 + b_2 + b_3}{3}$. Далее, от количества пассажиров в каждом автобусе изначально отнимаем требуемое значение. Так как оно может отличаться как в плюс, так и в минус используем модуль : $|b_1-need|+|b_2-need|+|b_3-need|$. А так как «излишки» перераспределяются между оставшимися двумя автобусами, то чтобы избежать повторения мы делим все на $2$ : $\frac{|b_1-need|+|b_2-need|+|b_3-need|}{2}$.

Далее мы вычисляем, существует ли остаток от деления общего количества пассажиров на $3$; для этого используем логическую переменную. Если остаток существует и f == true, то выводится [latex]IMPOSSIBLE[/latex]. Если же f == false, то вычисляется и выводится количество перестановок пассажиров.

Код программы (Ветвление)

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

int main() {
    int b1, b2, b3, need;
    cin >> b1 >> b2 >> b3;
    need = (b1 + b2 + b3) / 3;
    if ((b1 + b2 + b3) % 3!=0) {
        cout << "IMPOSSIBLE";
    }
    else cout << (abs(b1 - need) + abs(b2 - need) + abs(b3 - need))/2;
    return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main() {

int b1, b2, b3, need;

cin >> b1 >> b2 >> b3;

need = (b1 + b2 + b3) / 3;

if ((b1 + b2 + b3) % 3!=0) {

cout << "IMPOSSIBLE";

}

else cout << (abs(b1 - need) + abs(b2 - need) + abs(b3 - need))/2;

return 0;

}

Решение

Алгоритм решения в данном случае полностью повторяет предыдущий, но с помощью условного оператора мы можем сразу же проверить сумму пассажиров на делимость, вывести [latex]IMPOSSIBLE[/latex] и завершить программу не вычисляя формулы.

Ссылки

Условие задачи на E-Olymp
Код программы на IdeOne (Линейные вычисления)
Код программы на IdeOne (Ветвление)

Related Images:

e-olymp 8371. Четное или нечетное

28/10/2018 by Владислав Бебик

Задача

Задано натуральное число $n$. Определить его четность.

Входные данные

Одно натуральное число $n$ $\left(1 \leq n \leq 10^{9}\right)$.

Выходные данные

Если число $n$ четное, то вывести EVEN. Если нечетное, то вывести ODD.

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	1	ODD
2	99	ODD
3	500	EVEN
4	1000000000	EVEN

Код программы (Линейные вычисления)

#include <iostream>
using namespace std;

int main() {
  int n;
  cin >> n;
  (n%2==0) && (cout << "EVEN") || (n%2==1) && (cout << "ODD");
  return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

cin >> n;

(n%2==0) && (cout << "EVEN") || (n%2==1) && (cout << "ODD");

return 0;

}

Решение задачи

Если число четное, то будет выполняться условие n%2==0, тогда выводим EVEN. Если число нечетное, то будет выполняться условие n%2==1, тогда выводим ODD.

Код программы (Ветвление)

#include <iostream>
using namespace std;

int main() {
  int n;
  cin >> n;
  cout << (n % 2 == 0 ? "EVEN" : "ODD"); //проверяем на четность
  return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

cin >> n;

cout << (n % 2 == 0 ? "EVEN" : "ODD"); //проверяем на четность

return 0;

}

Решение задачи

Число четное, если оно делится на $2$ без остатка, значит выполняется условие: n % 2 == 0. В противном случае, число будет нечетным.

Ссылки

Условие задачи на E-Olymp

Код программы на IdeOne (Линейные вычисления)

Код программы на IdeOne (Ветвление)

Related Images:

e-olymp 8522. Делимость

17/10/2018 by Андрей Зиновьев

Задача

Заданы два натуральных числа $a$ и $b$. Проверьте, делится ли $a$ на $b$.

Входные данные: Два натуральных числа $a$ и $b$ $(1 \le a, b \le 10^9)$

Выходные данные: Если $a$ не делится на $b$ нацело, вывести в одной строке частное и остаток от деления $a$ на $b$. Иначе вывести "Divisible".

Тесты

$a$	$b$	Вывод программы
15	3	Divisible
12	7	1 5
15	23	0 15
1000000000	889879	1123 665883

Continue reading →

Related Images:

e-olymp 990. 12345

12/10/2018 by Яна Юрковская

Задача

Вывести цифры 1, 2, 3, 4, 5 каждое в отдельной строке.

Входные данные

Входные данные отсутствуют.

Выходные данные

Выведите цифры 1, 2, 3, 4, 5 каждое в отдельной строке как показано в примере.

Тесты

ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
	1 2 3 4 5

Код. Вариант 1

#include <iostream>
using namespace std;

int main() {
    cout << 1 << endl << 2 << endl << 3 << endl << 4 << endl << 5;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

cout << 1 << endl << 2 << endl << 3 << endl << 4 << endl << 5;

return 0;

}

Решение

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

Код. Вариант 2

#include 
using namespace std;

int main() {
    cout << 1 << '\n' << 2 << '\n' << 3 << '\n' << 4 << '\n' << 5;
    return 0;
}

#include

using namespace std;

int main() {

cout << 1 << '\n' << 2 << '\n' << 3 << '\n' << 4 << '\n' << 5;

return 0;

}

Решение

В решении используется символ перехода на новую строку ‘\n’.

Ссылки

e-olymp
ideone(Решение 1)
ideone(Решение 2)

Related Images:

e-olymp 1289. Ланч

10/10/2018 by Александр Мога

Задача

Влад хочет взять с собой для ланча пару фруктов. У него есть $a$ различных бананов, $b$ различных яблок и $c$ различных груш. Сколькими способами он может выбрать 2 разных фрукта из имеющихся у него?

Входные данные

В одной строке заданы три неотрицательных числа: $a$, $b$, $c$. Все числа не превышают [latex]10^6[/latex].

Входные данные

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

Тесты

Вход	Выход
2 3 4	26
6 2 4	44
0 4 8	32
1052 886 225	1368122
772 621 124	652144

Код программы

#include <iostream>
using namespace std;

int main() {
    long int a,b,c,n;
    cin >> a >> b >> c;
    n= a*b+b*c+a*c; 
    cout << n;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

long int a,b,c,n;

cin >> a >> b >> c;

n= a*b+b*c+a*c;

cout << n;

return 0;

}

Решение

Пусть у нас $1$ банан и $b$ различных яблок. Мы можем взять $1$ банан и одно яблоко $b$ способами. Так как бананов $a$, по одному яблоку и банану можем взять [latex](a \cdot b)[/latex] способами. Аналогично, так как груш $с$, то есть [latex](a \cdot с)[/latex] способов взять по одному банану и одну грушу, и [latex](c \cdot b)[/latex] способов взять по одному яблоку и одну грушу. То есть всего [latex](a \cdot b + b \cdot c + c \cdot a) [/latex].

Ссылки

e-olymp

ideone