e-olymp 914. Модуль максимального

23/12/2018 by Николай Козиний

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

Задача

Задана послідовність дійсних чисел. Обчислимо їх модулі. Знайдіть максимальне значення серед цих модулей.

Вхідні дані

У першому рядку задано кількість елементів $n\left(n \leqslant 100 \right)$ у послідовності. У наступному рядку задано $n$ дійсних чисел — елементи послідовності, значення яких не первищують за модулем 100.

Вихідні дані

Виведіть максимальне значення серед цих модулей з 2 десятковими знаками.

Тести

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	0 -1 1	1.00
2	3 -1.1 1.2 -1.3	1.30
3	5 5.16 0 -7.18 3 4.99	7.18
4	4 -75.111 7.5 -5.1 75.110	75.11
5	10 -1 -2 -3 -4 -5 -6 -7 -8 -9 1	9.00

Решение

Задача сходиться до пошуку максимального елемента послідовності. Зрозуміло, що найменше можливе значення модуля числа — 0. Тому, считуючи дані зі вхідного потоку будемо порівнювати їх зі змінною, що дорівнює 0. Якщо значення модуля числа більше за змінну — надаємо змінній значення модуля числа. Таким чином після завершення вхідного потоку змінна буде дорівнювати найбільшому числу послідовності за модулем.

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main() {
    int n;
    cin >> n;
    double max = 0;
    for(int i = 0;i < n;i++){
        double a;
        cin >> a;
        if(abs(a) > max)max = abs(a);
    }
    cout<< fixed << setprecision(2) << max;
}

#include <iostream>

#include <iomanip>

#include <cmath>

using namespace std;

int main() {

int n;

cin >> n;

double max = 0;

for(int i = 0;i < n;i++){

double a;

cin >> a;

if(abs(a) > max)max = abs(a);

}

cout<< fixed << setprecision(2) << max;

}

Зараховане рішення на e-olymp
Код задачі на ideone

Related Images:

e-olymp 441. Наиболее круглое число

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

Задача

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

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

В первой строке входных данных задано количество чисел [latex]N (1 \leqslant N \leqslant 100)[/latex]. Каждая из последующих [latex]N[/latex] строк содержит одно число в пределах от [latex]1[/latex] до [latex]10^9[/latex].

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

Вывести наиболее круглое число среди заданных [latex]N[/latex] чисел.

Тесты

№	Ввод	Вывод
1	3 600000 1000 20000	600000
2	4 71200 10 200 10001	200
3	6 19 3 4580004 26 8302 5	3
4	4 32900 23090 20309 23900	23900

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

#include <iostream>

using namespace std;

int main() {
    unsigned int n, a, acopy, max_number = 0, value = 1000000000, local_number;
    cin >> n;
    while (n--) {
        cin >> a;
        acopy = a;
        for (local_number = 0; acopy % 10 == 0; local_number++) acopy /= 10;
        if ( local_number > max_number) {
            max_number = local_number;
            value = a;
        }
        else if (local_number == max_number && a < value) value = a;
    }
    cout << value;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

unsigned int n, a, acopy, max_number = 0, value = 1000000000, local_number;

cin >> n;

while (n--) {

cin >> a;

acopy = a;

for (local_number = 0; acopy % 10 == 0; local_number++) acopy /= 10;

if ( local_number > max_number) {

max_number = local_number;

value = a;

}

else if (local_number == max_number && a < value) value = a;

}

cout << value;

return 0;

}

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

Основная цель задачи — среди a чисел выбрать то, которое будет иметь наибольшее число нолей в конце и при этом быть наименьшим среди чисел с таким же количеством ноле в конце. Заводим переменные max_number, value, local_number. Первая будет обозначать максимальное число нолей в конце. Вторая будет значением числа с максимальным количеством нолей. Третья же, как следует из её названия, означает локальное количество нолей, то есть того числа, с которым непосредственно идёт работа. Сперва считаем количество нолей в конце числа или, вернее, его копии, которую мы будем делить на десять, пока «крайняя» справа цифра равна 0. Число нолей будет равно числу проделанных делений. После имеет смысл рассматривать два случая: когда количество нолей введенного последним числа больше максимального и когда значения равны. В первом изменяются и максимум max_number, и само число value, получая значения соответственно количества нолей последнего введенного числа и его самого, если локальное число нолей больше максимального. Во втором же только value, если число из потока оказывается меньше и имеет то же кол-во нолей; в этом случае изменять max_number просто не имеет смысла.
В итоге выводим наиболее круглое число — value.

Ссылки

Related Images:

e-olymp 31. Суеверный Дед Мороз

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

Задача

Как известно, в разные годы дежурят и развозят подарки разные Деды Морозы. Но все они суеверны — развозят подарки на протяжении всего года, кроме дней, когда на календаре Деда Мороза «Пятница 13».

Сколько дней Дед Мороз не развозил подарки во время своего дежурства?

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

В первой строке задано количество смен $k$ дежурства Деда Мороза.

Далее в k строках указаны года $a$ и $b$ ($1920 ≤ a ≤ b ≤ 2050$ по григорианскому календарю), попадающие на очередную смену.

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

Вывести количество дней, когда Дед Мороз не будет развозить подарки.

Тесты

№	Ввод	Вывод
1	2 1999 2000 1991 1997	13
2	3 1939 1945 1937 1938 1953 1964	37
3	3 1993 1996 2007 2017 1979 1981	32
4	4 1997 1999 1967 1972 2032 2032 1930 1933	24
5	4 1959 1960 1965 1966 1991 2011 1947 1959	63

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

#include <iostream>
#include <algorithm>

using namespace std;

int c2[12] = {16, 18, 19, 25, 1, 2, 3, 4, 7, 8, 13, 14};
int c3[4] = {21, 24, 27, 10};

int main (){
    int a, year1, year2, counter = 0;
    cin >> a;
    while (a--){
        cin >> year1 >> year2;
        for (int i = year1; i <= year2; i++){
            if (any_of(begin(c2), end(c2), [=](int n){return n == i%28;})) counter+=2;
            else if(any_of(begin(c3), end(c3), [=](int n){return n == i%28;})) counter+=3;
            else counter++;
        }
    }
    cout << counter;
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

int c2[12] = {16, 18, 19, 25, 1, 2, 3, 4, 7, 8, 13, 14};

int c3[4] = {21, 24, 27, 10};

int main (){

int a, year1, year2, counter = 0;

cin >> a;

while (a--){

cin >> year1 >> year2;

for (int i = year1; i <= year2; i++){

if (any_of(begin(c2), end(c2), [=](int n){return n == i%28;})) counter+=2;

else if(any_of(begin(c3), end(c3), [=](int n){return n == i%28;})) counter+=3;

else counter++;

}

cout << counter;

return 0;

}

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

Сперва стоит сказать, что полный цикл чередования лет с пятницей 13 в одни и те же месяца — 28 лет. Всего в году их может быть от 1 до 3. Всего в этих 28 годах будут 4 года с тремя пятницами 13 и по 12 с одной и двумя.
Все решение задачи сводится сводится к тому, чтобы посчитать количество пятниц 13 в каждом году данного нам отрезка времени. Создадим два массива — c2 и c3 — каждый будет содержать остатки от деления лет, содержащих 2 и 3 пятницы 13 соответсвенно, на 28. Все прочие остатки от деления «достанутся» годам, в которых 1 пятница 13; отдельный массив для них, очевидно, смысла создавать нет.
Сначала, по условию, вводим число смен и после в цикле года очередной смены. Для каждого года из отдельной смены считаем количество пятниц 13 путём проверки в соответствующих массивах остатка от деления этого года на 28. Если его нет в двух массивах, то, очевидно, в этом году всего одна пятница 13 и мы прибавляем к счетчику пятниц counter 1. Если все-таки есть, то прибавляем 2 или 3 в зависимости от того, в каком массиве нашлось необходимое число. В конце выводим значение счётчика.
Отметим, что задача решается и без использования массивов, но в таком случае придётся проверить остаток от деления каждого года на 28 на равенство числам, которые в данном случае находятся в массивах.

Ссылки

код на ideone
условие задачи на e-olymp

Related Images:

e-olymp 904. Увеличить на 2

23/12/2018 by Наталья Федина

Задача

Задана последовательность целых чисел. Увеличить на $2$ каждый ее неотрицательный элемент.

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

В первой строке задано количество элементов последовательности $n(n ≤ 100).$ Во второй строке заданы сами элементы, значение каждого из которых по модулю не превышает $100.$

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

Вывести в одной строке $n$ чисел: новые значения элементов последовательности в том же порядке, в котором они были заданы.

Тесты

	Входные данные	Выходные данные
1	4 1 2 3 -4	3 4 5 -4
2	7 7 -3 4 -2 5 0 -1	9 -3 6 -2 7 0 -1
3	5 6 -12 28 -32 -1	8 -12 30 -32 -1
4	3 -2 -3 -4	-2 -3 -4

Код

#include <iostream>
using namespace std;
 
int main() {
    int k, x; 
    cin >> k;
    for (int i = 0; i < k; i++) {
        cin >> x;
        cout << (x < 0? x: x + 2) << " ";
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int k, x;

cin >> k;

for (int i = 0; i < k; i++) {

cin >> x;

cout << (x < 0? x: x + 2) << " ";

}

return 0;

}

Решение

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

Ссылки

Related Images:

e-olymp 1753. Младший бит

23/12/2018 by Юлиана Боурош

Задача

Для заданного положительного целого $A$ $(1 \leq A \leq 100),$ вывести младший бит $A$.

Например, если $A = 26$, то его мы можем записать в двоичном виде, как $11010$, и младший бит $A$ есть $10$, и на выходе должно быть $2.$

Другой пример выглядит следующим образом: при $A = 88$, это число $A$ мы можем записать в двоичной форме $1011000$, младший бит в $A$ есть $1000,$ и на выходе должно быть $8.$

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

Каждая строка входных данных содержит только одно целое число $A$ $(1 \leq A \leq 100).$ Строка, содержащая «0» означает конец ввода, и эта строка не является частью входных данных.

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

Для каждого числа $A,$ полученного на входе, в отдельной строке вывести значение его младшего бита.

Тесты

	Входные данные	Выходные данные
1	26 88 0	2 8
2	99 45 66 20	1 1 2 4
3	100 0 6	4
4	66 33 98 42 84 39	2 1 2 2 4 1

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

#include <iostream>
using namespace std;

int main() {
    int a;
    while (cin >> a && a != 0) {
        int LSB = 1; // Least Significant Bit
        while ((a & LSB) == 0){
            LSB = LSB << 1;
        }
        cout << LSB << endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int a;

while (cin >> a && a != 0) {

int LSB = 1; // Least Significant Bit

while ((a & LSB) == 0){

LSB = LSB << 1;

}

cout << LSB << endl;

}

return 0;

}

Решение

Объявляем переменную a. Начинается цикл while, условием окончания которого будет введённая a, неравная нулю. В цикле объявляем переменную LSB = 1, после чего начинается новый цикл while, который сдвигает бит LSB влево, пока выражение побитовой конъюнкции a & LSB нулевое. Соответственно, как только выражение будет ненулевым — будет найден первый общий бит, который и будет младшим битом числа a. Его и выводим.

Ссылки

Related Images:

e-olymp 1325. Васькины дорожки

27/11/2018 by Иван Киреев

Кот Василий узнал, что у соседа Димы, проживающего от него через какое-то количество заборов завелись мыши. Так как в своём хозяйстве всех мышей он уже давно выловил, кот отправляется на охоту за мышами к соседу, пролезая через дыры в ограде. На каждом участке Василий, как любой воспитанный кот, перемещается по уже проложенным там тропинкам. В деревне Старые Васюки, где проживает Василий, всего одна улица и та протянулась вдоль реки, поэтому домики расположены только по одну сторону улицы. Известно, что между любыми соседними участками в заборе ровно одна дыра. Сколькими способами Василий может попасть на участок Димы, если известно, что Дима проживает на участке под номером $k,$ а сам Василий проживает на участке под номером $m$?

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

В единственной строке находятся через пробел сначала количество домов в деревне $n,$ затем номер участка Василия $m,$ номер участка Димы $k,$ а далее $n$ чисел, обозначающее количество тропинок, ведущих либо к дыре в заборе, либо от дыры в заборе, либо между дырами в заборе соседей $i$ и $i+1.$ Все входные данные натуральные числа, не превышающие $10.$

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

Единственное число — количество различных способов для Василия попасть на нужный участок для охоты.

Тесты

№	Ввод	Вывод
1	3 2 3 4 5 3	15
2	10 5 7 1 2 3 4 5 6 7 8 9 10	210
3	4 2 1 3 4 7 8	12
4	10 8 8 1 9 6 7 5 3 8 2 4 10	2
5	1 1 1 1	1
6	10 1 10 1 1 1 1 1 1 1 1 1 10	10
7	7 5 3 2 2 2 4 4 4 5	32
8	10 1 10 10 10 10 10 10 10 10 10 10 10	10000000000
7	5 3 2 1 2 3 4 5 6 7 8 9 10	6

Решение

Что бы определить количество различных способов попасть на нужный участок мы должны, сначала, посчитать сколькими способами кот Василий может пересечь (по тропинкам) участок на котором он находится. Затем, для каждого из возможных вариантов пересечения первого участка посчитать сколькими способами Василий может пересечь второй участок и так далее, до заданного. Таким образом общее количество вариантов попасть, для нашего друга, из участка $m$ в участок $k$ является произведением количества вариантов пересечения каждого участка в отдельности.

Прочтём значения $n$, $m$ и $k$. Переменная rez будет хранить результат. В цикле от $1$ до наибольшего номера из участков Димы и Василия, будем проверять достигли ли мы наименьшего номера их участков. По достижении начинаем перемножать количества тропинок ведущих к дыркам в заборе. Мы можем это делать с начиная с любого из участков так как операция умножения коммутативна. Завершив цикл в переменной rez у нас уже будет правильный ответ. Выведем его.

Типа данных unsigned long хватит по условию данной задачи, так как все числа натуральные, а значит большие $0$. И не превышают $10$, следовательно максимальное значение переменной rez будет $10^{10}$ что помещается в unsigned long.

Код

#include <iostream>
using namespace std;

int main() {
    int n, m, k, a, MIN, MAX;
    unsigned long rez = 1;
    cin >> n >> m >> k;
    MIN = min(m, k);
    MAX = max(m, k);
    for (int i = 1; i <= MAX; i++) {
        cin >> a;
        if (i >= MIN) rez *= a;
    }
    cout << rez;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n, m, k, a, MIN, MAX;

unsigned long rez = 1;

cin >> n >> m >> k;

MIN = min(m, k);

MAX = max(m, k);

for (int i = 1; i <= MAX; i++) {

cin >> a;

if (i >= MIN) rez *= a;

}

cout << rez;

return 0;

}

Условие задачи

Решение

Код на ideone

Related Images:

e-olymp 97. Числа Белла

23/05/2018 by Томас Пасенченко

Задача

Число Белла [latex]B_n[/latex] равно количеству разбиений множества из [latex]n[/latex] элементов на произвольное количество непересекающихся непустых подмножеств. Например, [latex]B_3 = 5[/latex], так как существует [latex]5[/latex] возможных разбиений множества [latex]\lbrace a, b, c\rbrace[/latex]: [latex]\lbrace\lbrace a\rbrace, \lbrace b\rbrace, \lbrace c\rbrace\rbrace, \lbrace\lbrace a, b\rbrace, \lbrace c\rbrace\rbrace, \lbrace\lbrace a, c\rbrace, \lbrace b\rbrace\rbrace, \lbrace\lbrace a\rbrace, \lbrace b, c\rbrace\rbrace, \lbrace\lbrace a, b, c\rbrace\rbrace[/latex]. Дополнительно считаем, что [latex]B_0 = 1[/latex].
Рассмотрим определитель [latex]D_n[/latex]:
$$D_n = \begin{vmatrix}
B_0& B_1& B_2&\ldots& B_n\\
B_1& B_2& B_3&\ldots& B_{n+1}\\
\ldots& \ldots& \ldots& \ldots& \ldots\\
B_n& B_{n+1}& B_{n+2}&\ldots& B_{2n}
\end{vmatrix}$$
Для заданного простого числа [latex]p[/latex] найти наибольшее целое [latex]k[/latex], для которого [latex]D_n[/latex] делится на [latex]p^k[/latex].

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

Каждая строка ввода содержит два целых числа [latex]n[/latex] и [latex]p[/latex] ( [latex]\;0\leq\; n,\;p \;\leq\; 10000[/latex] ). Известно, что [latex]p[/latex] – простое.

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

Для каждой пары входных значений [latex]n[/latex] и [latex]p[/latex] в отдельной строке выведите наибольшее целое [latex]k[/latex], для которого [latex]D_n[/latex] делится на [latex]p^k[/latex].

Тесты

Входные данные	Выходные данные
1 5 3 2 4 2 4 3 10000 3	0 2 5 2 24962375
18 2 465 1009 9998 9221 548 11	134 0 778 14412
1093 1093 1103 1723 3931 617 4868 6113 9534 71	1 0 10635 0 639989
617 17 42 11 0 5	11295 63 0

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

#include <iostream>
using namespace std;

int main() {
    // Числа Белла
    int n, p;
    while (cin >> n >> p) {
        int k = 0;
        for (int i = 1; i <= n; i++) {
            int fact = i;
            while (fact) {
                fact /= p;
                k += fact;
            }
        }
        cout << k << "\n";
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

// Числа Белла

int n, p;

while (cin >> n >> p) {

int k = 0;

for (int i = 1; i <= n; i++) {

int fact = i;

while (fact) {

fact /= p;

k += fact;

}

cout << k << "\n";

}

return 0;

}

Решение

Числа Белла обладают интересным свойством:
$$D_n = \begin{vmatrix}
B_0& B_1& B_2&\ldots& B_n\\
B_1& B_2& B_3&\ldots& B_{n+1}\\
\ldots& \ldots& \ldots& \ldots& \ldots\\
B_n& B_{n+1}& B_{n+2}&\ldots& B_{2n}
\end{vmatrix} = \prod_{i=1}^n i! $$

Воспользуемся этим свойством для решения данной задачи. Найдём степень числа [latex]p[/latex] в разложении на простые множители. Для этого узнаем степень вхождения этого числа в каждый из факториалов. Суммой полученных значений и будет являться искомое число [latex]k[/latex].

Ссылки

Условия задачи на e-olymp
Код задачи на ideone
Число Белла на wikipedia

Related Images:

e-olymp 441. Наиболее круглое число

25/02/2018 by Бондаренко Кирилл

Наиболее круглое число

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

В первой строке входных данных задано количество чисел [latex]N[/latex] [latex](1 ≤ N ≤ 100)[/latex]. Каждая из последующих N строк содержит одно число в пределах от [latex]1[/latex] до [latex]10^{9}[/latex].

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

Вывести наиболее круглое число среди заданных [latex]N[/latex] чисел.

Тесты

Входные данные	Выходные данные
4 71200 10 200 10001	200
5 711 1 2 10001 234567	1
10 7 1 2 1 2 3 4 6 8 9	1
4 100000 200000 500000 800000	100000

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

#include <iostream>
using namespace std;

int main() {
    int n, e, k=0, m, maxk = 0, maxn = 1000000000, p = 1;
    cin >> e;
    while (e -- > 0) {
        cin >> n;
        if (p <= n) {
            m = n;
            k = 0;
            while ((n % 10) == 0) {
                //считает нули
                n = n / 10;
                k ++;
            }
            if (maxk < k) {
                maxn = m;
                maxk = k;
                p = 1;
                for (int i = 1; i < maxk; i ++) {
                    p *= 10;
                }
            } else if (maxk == k) {
                if(maxn > m) {
                    maxn = m;
                }
            }
        }
    }
    cout << maxn;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n, e, k=0, m, maxk = 0, maxn = 1000000000, p = 1;

cin >> e;

while (e -- > 0) {

cin >> n;

if (p <= n) {

m = n;

k = 0;

while ((n % 10) == 0) {

//считает нули

n = n / 10;

k ++;

}

if (maxk < k) {

maxn = m;

maxk = k;

p = 1;

for (int i = 1; i < maxk; i ++) {

p *= 10;

}

} else if (maxk == k) {

if(maxn > m) {

maxn = m;

}

cout << maxn;

return 0;

}

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

Имеет смысл проверять каждое введенное число: не является ли оно меньше либо равно чем [latex]p[/latex], где [latex]p[/latex] — наименьшее число с количеством нулей равным [latex]maxk[/latex]. [latex]maxk[/latex] — текущее наибольшее количество нулей. Для того, чтобы найти [latex]p[/latex], мы в цикле умножаем [latex]1[/latex] [latex]maxk[/latex]-раз на [latex]10[/latex]. Очевидно, что [latex]p[/latex] нужно менять только тогда, когда меняется [latex]maxk[/latex], также следует до цикла полагать [latex]p=1[/latex]. Для того чтобы [latex]p[/latex] не умножалось на [latex]10[/latex] лишнее количество раз. Таким образом мы отсеиваем заведомо негодные числа и ускоряем код.
Положим [latex]maxn[/latex] — наиболее круглое число.
Так как по условию числа не могут быть больше чем [latex]10^{9}[/latex], имеет смысл изначально поставить переменную [latex]maxn=10^{9}[/latex]. Это делается для того случая, когда во всех числах [latex]m[/latex] не будет нулей и нужно будет выбрать наименьшее. Если мы положим в переменную [latex]maxn[/latex] любое другое число то [latex]maxn[/latex] может быть меньше чем [latex]m[/latex] и мы не сможем выбрать ответ так как все [latex]m[/latex] будут больше его.

Условие задачи на e-olimp
Код решения ideone

Related Images:

e-olymp 7368. Средний балл для фигуристов

02/01/2018 by Валерия Ларикова

Задача

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

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

В первой строке находятся два целых числа: количество судей [latex]n[/latex] и количество спортсменов [latex]m[/latex]. В следующих [latex]m[/latex] строках находятся [latex]n[/latex] целых чисел – оценки всех судей [latex](0 < n ≤ 10, 0 < m ≤ 100)[/latex] для каждого из фигуристов.

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

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

Тесты

#	Входные данные	Выходные данные
1	5 4 7 8 9 8 10 6 5 5 4 7 9 9 10 7 7 7 7 10 9 8	8.33 5.33 9.00 8.50
2	6 3 6 7 6 5 4 3 9 8 5 5 6 5 7 6 4 1 2 2	5.25 7.00 3.50
3	4 5 6 7 8 6 9 8 5 4 7 6 7 5 4 3 9 3 7 8 7 6	7.00 6.50 6.00 4.00 7.00
4	4 4 7 7 2 3 9 8 3 3 5 4 9 7 4 3 2 6	3.00 8.00 6.00 3.50
5	8 5 4 5 6 7 7 4 9 8 3 5 6 6 7 8 5 9 7 6 3 9 3 7 9 7 5 6 4 3 7 7 5 7 9 8 4 6 7 9 9 4	6.60 6.17 6.75 5.00 7.00

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

#include <iostream>
#include <iomanip>//данная библиотека позволяет устанавливать количество знаков после запятой 
#include <cmath>//данная библиотеа помогает вычислить min и max
#include <climits>//определяет константы с ограничениями целочисленного типа данных
using namespace std;
 
int main() {
    double n, m;
    double x, min = INT_MAX, max = INT_MIN, sum = 0, a = 0, b = 0;
    cin >> n >> m;
    for (int i = 0; i < m; i++){
        for (int j = 0; j < n; j ++){
            cin >> x;
            if (max == x) a++;
            if (max < x) {
                if (max != min) sum += a*max;
                a = 1;
                max = x;
            }
            if ( min == x) b++;
            if (min > x) {
                if (max != min) sum += b*min;
                b = 1;
                min = x;
            }
        if (x!= min and x != max) sum += x;
        }
        cout << fixed << setprecision(2) << sum / (n - a - b) << " ";//функция с её аргументом позволяет вывеси результат, округлённый до двух десятичных знаков
        sum = a = b = 0;
        min = INT_MAX;
        max = INT_MIN;
    }
    return 0;
}

#include <iostream>

#include <iomanip>//данная библиотека позволяет устанавливать количество знаков после запятой

#include <cmath>//данная библиотеа помогает вычислить min и max

#include <climits>//определяет константы с ограничениями целочисленного типа данных

using namespace std;

int main() {

double n, m;

double x, min = INT_MAX, max = INT_MIN, sum = 0, a = 0, b = 0;

cin >> n >> m;

for (int i = 0; i < m; i++){

for (int j = 0; j < n; j ++){

cin >> x;

if (max == x) a++;

if (max < x) {

if (max != min) sum += a*max;

a = 1;

max = x;

}

if ( min == x) b++;

if (min > x) {

if (max != min) sum += b*min;

b = 1;

min = x;

}

if (x!= min and x != max) sum += x;

}

cout << fixed << setprecision(2) << sum / (n - a - b) << " ";//функция с её аргументом позволяет вывеси результат, округлённый до двух десятичных знаков

sum = a = b = 0;

min = INT_MAX;

max = INT_MIN;

}

return 0;

}

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

Для решения задачи нам необходимо изъять все минимальные и максимальные значения в каждой строчке. Переменные [latex]a[/latex] и [latex]b[/latex] — это количество вхождений максимума и минимума соответственно. Берем любой элемент строки, который обозначили переменной [latex]x[/latex], и будем считать, что он минимальный и максимальный. Далее сравниваем элементы между собой и находим максимум и минимум и подсчитываем их количество. Ещё нам необходимо посчитать сумму оставшихся значений, а также их количество по формуле [latex]n-a-b[/latex]. А затем вычисляем среднее арифметическое для оставшихся значений по формуле [latex]\frac{sum}{n-a-b}[/latex] и выводим результат.

Ссылка на e-olymp

Ссылка на ideone

Related Images:

e-olymp 419. Задача 3n + 1

31/12/2017 by Амир Аль-Омари

Задача

Рассмотрим следующий алгоритм генерации последовательности чисел:

input n
print n
if n = 1 then STOP
if n is odd then n = 3 * n + 1
else n = n / 2
GOTO 2

input n

print n

if n = 1 then STOP

if n is odd then n = 3 * n + 1

else n = n / 2

GOTO 2

Например, для [latex]n[/latex] = 22 будет сгенерирована следующая последовательность чисел:

22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

Полагают (но это еще не доказано), что этот алгоритм сойдется к [latex]n[/latex] = 1 для любого целого [latex]n[/latex]. По крайней мере, это предположение верно для всех целых [latex]n[/latex], для которых 0 < [latex]n[/latex] < 1,000,000.

Длиной цикла числа n будем называть количество сгенерированных чисел в последовательности включая 1. В приведенном примере длина цикла числа 22 равна 16.

Для двух заданных чисел [latex]i[/latex] и [latex]j[/latex] необходимо найти максимальную длину цикла среди всех чисел между [latex]i[/latex] и [latex]j[/latex] включительно.

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

Каждый тест задается в отдельной строке и содержит пару целых чисел [latex]i[/latex] и [latex]j[/latex]. Входные числа будут меньше 1000000 и больше 0. Считайте, что для вычислений достаточно использовать 32 битный целочисленный тип.

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

Для каждой пары чисел [latex]i[/latex] и [latex]j[/latex] выведите числа [latex]i[/latex] и [latex]j[/latex] в том же порядке, в каком они поступили на вход. После чего выведите максимальную длину цикла среди всех целых чисел между [latex]i[/latex] и [latex]j[/latex] включительно. Для каждого теста три числа следует выводить в отдельной строке, разделяя одним пробелом.

Тесты

Входные данные	Выходные данные
1 10 100 200 201 210 900 1000	1 10 20 100 200 125 201 210 89 900 1000 174
1 10 10 1	1 10 20 10 1 20
5 25 70 54 38 250	5 25 24 70 54 113 38 250 128

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

#include <iostream>
using namespace std;

int length(int ch) {
    int it = 1;
    while (ch != 1) {
        if (ch % 2 == 1) {
            ch = ch * 3 + 1;
        }
        else {
            ch = ch / 2;
        }
        it++;
    }
    return it;
}

int main() {
    int i, j;
    while(cin >> i) {
        cin >> j;
        int it, maxIt = 0;
        for (int a = min(i, j); a <= max(i, j); a++) {
            it = length(a);
            if (it > maxIt) {
                maxIt = it;
            }
        }
        cout << i << ' ' << j << ' ' << maxIt << endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

int length(int ch) {

int it = 1;

while (ch != 1) {

if (ch % 2 == 1) {

ch = ch * 3 + 1;

}

else {

ch = ch / 2;

}

it++;

}

return it;

}

int main() {

int i, j;

while(cin >> i) {

cin >> j;

int it, maxIt = 0;

for (int a = min(i, j); a <= max(i, j); a++) {

it = length(a);

if (it > maxIt) {

maxIt = it;

}

cout << i << ' ' << j << ' ' << maxIt << endl;

}

return 0;

}

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

Алгоритм, описанный в условии задачи используется для построения сиракузской последовательности. Интересный факт — какое бы число не взять, в конце получаем единицу. Нам же надо посчитать сколько раз должен сработать алгоритм для подсчитывания «длины цикла». Считывая пару чисел из потока ввода я высчитывал «длину цикла» для каждого числа из заданного введенной парой промежутка. После чего сравнивал количество итераций для каждого такого числа и находил максимальное. И так для каждой пары чисел.

Ссылки

Задача на сайте e-olymp
Код решения в Ideone

Related Images:

e-olymp 520. Сумма всех

26/12/2017 by Даниил Крутоголов

Сумма всех

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

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

Содержит [latex]n[/latex] [latex] (1 ≤ n ≤ 10^5) [/latex] целых чисел. Все числа не превосходят [latex]10^9[/latex] по абсолютной величине.

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

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

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	[latex]2[/latex] [latex]4[/latex]	[latex]6[/latex]
2	[latex]3[/latex]	[latex]3[/latex]
3	[latex]1[/latex] [latex]2[/latex] [latex]3[/latex] [latex]2[/latex] [latex]1[/latex]	[latex]9[/latex]
4	[latex]1[/latex] [latex]2[/latex] [latex]3[/latex] [latex]4[/latex]	[latex]10[/latex]
5	[latex]0[/latex] [latex]0[/latex] [latex]0[/latex] [latex]0[/latex]	[latex]0[/latex]

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

#include <iostream>
 
using namespace std;
 
int main() {
    long x;
    long sum = 0;
    while (cin >> x){
        sum+= x;
    }
    cout << sum;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

long x;

long sum = 0;

while (cin >> x){

sum+= x;

}

cout << sum;

return 0;

}

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

Пользователь вводит числа до тех пор, пока программа не завершит работу. Как только это случается, программа выдаёт ответ в виде суммы всех ранее введённых чисел. Также, стоит использовать переменную типа long из-за того, что сумма чисел может быть довольно большой и явно превышать максимальное допустимое значение для переменной типа int.

Ссылки

• Задача на e-olymp.

• Решение на сайте ideone.

Related Images:

MS12. Линейные уравнения

24/12/2017 by Сытников Дан

Условие задачи

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

Линейное_уравнение

Тесты

№	Входные данные	Выходные данные
1	0 0 1 0 0 1	Infinite set of roots; 0.0; No roots;
2	2.02134 -0.52412 15.578 0 5.302 -89 -431.345 9.43 7 49	0.25929334006154336; 0.0; 16.786118445869484; 0.021861850722739336; -7.0;
3	1 1 -6 -2 1 -2 10 0	-1.0; -0.3333333333333333; 2.0; 0.0;

Код на языке C++

#include <iostream>
using namespace std;

int main() {
    double a, b, x;
    int n = 0;
    while (cin >> a >> b) {
        cout << ++n << ") ";    
        if (a == 0) {
            if (b == 0) cout << "Infinite set of roots; \n";
            else        cout << "No roots; \n";
        } else {
            x = (-b/a == -0)? b/a : -b/a;
            cout << x << "; \n";
        }
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

double a, b, x;

int n = 0;

while (cin >> a >> b) {

cout << ++n << ") ";

if (a == 0) {

if (b == 0) cout << "Infinite set of roots; \n";

else cout << "No roots; \n";

} else {

x = (-b/a == -0)? b/a : -b/a;

cout << x << "; \n";

}

return 0;

}

Код на языке Java

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone {
    public static void main (String[] args) throws java.lang.Exception {
        double a, b, x;
        Scanner in = new Scanner(System.in);
        while (in.hasNextDouble()) {
            a = in.nextDouble();
            b = in.nextDouble();
            if (a == 0) {
                if (b == 0) System.out.println("Infinite set of roots; ");
                else        System.out.println("No roots; ");
            } else {
                x = (-b/a == -0)? b/a : -b/a; // Тернарная операция, чтобы избежать выражения "-0"
                System.out.println(x + "; ");
            }
        }
    }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone {

public static void main (String[] args) throws java.lang.Exception {

double a, b, x;

Scanner in = new Scanner(System.in);

while (in.hasNextDouble()) {

a = in.nextDouble();

b = in.nextDouble();

if (a == 0) {

if (b == 0) System.out.println("Infinite set of roots; ");

else System.out.println("No roots; ");

} else {

x = (-b/a == -0)? b/a : -b/a; // Тернарная операция, чтобы избежать выражения "-0"

System.out.println(x + "; ");

}

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

Линейное уравнение, зависящее от двух параметров, в общей форме имеет вид: [latex] ax + b = 0 [/latex]. Количество решений зависит от параметров [latex]a[/latex] и [latex]b[/latex].

Если [latex] a = b = 0 [/latex], то уравнение имеет бесконечное множество решений, поскольку [latex]\forall x\in \mathbb {R} :x\cdot 0=0[/latex].
Если [latex] a=0,b\neq 0[/latex], то уравнение не имеет решений, поскольку [latex] \not \exists x\in \mathbb {R} :0\cdot x=-b\neq 0[/latex].
Если [latex] a\neq 0[/latex], то уравнение имеет единственное решение [latex] x=-{\frac {b}{a}} [/latex].

Условие задачи.
Код программы на языке C++;
Код программы на языке Java.

Related Images:

e-olymp 1000. Задача a + b

20/12/2017 by Александра Рябова

Задача

Вычислите сумму [latex]\textbf {a + b}[/latex].

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

В каждой строке задано два целых числа [latex]\textbf{a}[/latex] и [latex]\textbf{b}[/latex] ([latex] \bigl| \textbf {a} \bigr|, \bigl| \textbf {b} \bigr| \textbf {≤ 30000}[/latex]).

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

Для каждого теста выведите сумму [latex]\textbf {a + b}[/latex] в отдельной строке.

Тесты

Входные данные	Выходные данные
$4$ $8$ $5$ $0$ $-6$ $8$	$12$ $5$ $2$
$-3$ $3$	$0$
$12$ $8$ $10$ $10$	$20$ $20$
$30000$ $30000$ $3000$ $3000$ $300$ $300$ $30$ $30$ $3$ $3$	$60000$ $6000$ $600$ $60$ $6$
$10$ $23$ $613$ $2$ $-200$ $300$	$33$ $615$ $100$

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

#include <iostream>
using namespace std;

int main() {
    int a, b;
    while (cin >> a >> b)
    {
        cout << a+b << "\n";
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int a, b;

while (cin >> a >> b)

{

cout << a+b << "\n";

}

return 0;

}

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

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

Ссылки

Условие задачи на сайте E-Olymp
Код решения задачи

Related Images:

MS10. Зашифровка текста

08/03/2017 by Иванна Ялымова

Задача

Зашифруйте текст из входного потока, заменяя каждый символ результатом сложения по модулю два его кода и кода предыдущего зашифрованного символа. Первый символ шифруется инверсией бит.

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

Символьная последовательность.

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

Зашифрованная символьная последовательность.

Тесты

Входные данные	Выходные данные
Where is the table?	a8 c0 a5 d7 b2 92 fb 88 a8 dc b4 d1 f1 85 e4 86 ea 8f b0
What a nice day!	a8 c0 a1 d5 f5 94 b4 da b3 d0 b5 95 f1 90 e9 c8

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

#include <iostream>

int main() {
    unsigned char x1, x2; 
    scanf("%c", &x1); 
    x1 = ~x1; 
    printf("%x ", x1);
    while (scanf("%c", &x2)) {
        if (x2 == '\n') break; 
        x2 = x1 ^ x2; 
        printf("%x ", x2);
        x1 = x2;
    }
    return 0;
}

#include <iostream>

int main() {

unsigned char x1, x2;

scanf("%c", &x1);

x1 = ~x1;

printf("%x ", x1);

while (scanf("%c", &x2)) {

if (x2 == '\n') break;

x2 = x1 ^ x2;

printf("%x ", x2);

x1 = x2;

}

return 0;

}

Решение

Выделяем участки памяти для символьных переменных, считываем первый символ и его инвертируем, затем выводим в шестнадцатеричной системе счисления с пробелом.
Используем цикл «while»: пока считываются данные в переменную x2, XORим предыдущий и новый символы, выводим новый символ и запоминаем новый зашифрованный символ, который становится предыдущим.

Ссылки

Условие задачи
Решение задачи на сайте Ideone.com

Related Images:

MS13. Решение квадратных уравнений

16/12/2016 by Валентина Андриеш

Условие задачи:
Каждая четвёрка чисел входного потока представляет собой квадратное уравнение в такой форме $ax^2+bx+c=d.$ Выпишите через запятую решения этих уравнений (если это возможно).

Тесты:

Входной поток чисел	Корни уравнений
1 -6 8 0 1 12 20 0	2, 4; -10, -2;
1 1 -6 -2 1 -2 10 0	-2.56155, 1.56155; нет корней;
2 -0.5 2.2 0 5 0 -25 0	нет корней; -2.23607, 2.23607;

Код на языке C++:

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

int main() {
    double a, b, c, d, D;
    double x1,x2,x3;
    while(cin>>a>>b>>c>>d){
        D=b*b-4*a*(c-d);
        if(D>0)
        {
            x1=(-b-sqrt(D))/(2*a);
            x2=(-b+sqrt(D))/(2*a);
            cout<<x1<<", "<<x2<<"; ";
        }
        else
        {
            if(D==0)
            {
                x3=(-b)/(2*a);
                cout<<x3<<"; ";
            }
            else cout<<"нет корней"<<"; ";
        }
    }
    return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main() {

double a, b, c, d, D;

double x1,x2,x3;

while(cin>>a>>b>>c>>d){

D=b*b-4*a*(c-d);

if(D>0)

{

x1=(-b-sqrt(D))/(2*a);

x2=(-b+sqrt(D))/(2*a);

cout<<x1<<", "<<x2<<"; ";

}

else

{

if(D==0)

{

x3=(-b)/(2*a);

cout<<x3<<"; ";

}

else cout<<"нет корней"<<"; ";

}

return 0;

}

Код на языке Java:

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        double a,b,c,d,D;
        double x1,x2,x3;
        Scanner in = new Scanner(System.in);
        while (in.hasNextDouble()){
                    a = in.nextDouble();
            b = in.nextDouble();
                    c = in.nextDouble();
                    d = in.nextDouble();
                    D=b*b-4*a*(c-d);
                    if(D>0){
                        x1=(-b-Math.sqrt(D))/(2*a);
                        x2=(-b+Math.sqrt(D))/(2*a);
                        System.out.println(x1+" "+x2+";");
                    }
                    else{
                        if(D==0){
                            x3=(-b)/(2*a);
                            System.out.println(x3+";");
                        }
                        else System.out.println("нет корней;");
                    }
                }
    }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static void main (String[] args) throws java.lang.Exception

{

double a,b,c,d,D;

double x1,x2,x3;

Scanner in = new Scanner(System.in);

while (in.hasNextDouble()){

a = in.nextDouble();

b = in.nextDouble();

c = in.nextDouble();

d = in.nextDouble();

D=b*b-4*a*(c-d);

if(D>0){

x1=(-b-Math.sqrt(D))/(2*a);

x2=(-b+Math.sqrt(D))/(2*a);

System.out.println(x1+" "+x2+";");

}

else{

if(D==0){

x3=(-b)/(2*a);

System.out.println(x3+";");

}

else System.out.println("нет корней;");

}

Решение задачи:
Для решения этой задачи используется цикл, который выполняется до тех пор, пока в потоке подряд расположены четыре числа, четыре коэффициента, которые стоят перед неизвестными в квадратном уравнении классического вида: [latex]ax^{2}\pm bx\pm c=d[/latex]. Для самого нахождения корней использовалась известная формула [latex]x_{1,2}=\frac{-b-\sqrt{b^{2} \pm 4a(c-d)}}{2a}[/latex]. В коде, для удобства, она была разделена на две части: нахождение дискриминанта [latex]D[/latex] и нахождение самих корней, что возможно (на вещественной числовой оси) лишь при условии [latex]D>0[/latex].

Решение задачи на C++: Ideone
Решение задачи на Java: Ideone

Related Images:

MS17. Самосинхронизирующийся скремблер

11/12/2016 by Вадим Гордийчук

Задача

Рассматривая входной поток как последовательность бит, зашифруйте его при помощи восьмибитового самосинхронизирующегося скремблера. Начальное значение и обратные связи скремблера должны быть заданы в программе значениями двух переменных типа unsigned char. Как расшифровать полученный код.

Примечание: разобьём данную нам задачу на две подзадачи. В первой будет рассмотрено скремблирование входных данных, а во второй будет проведено дескремблирование исходных данных первой подзадачи.

Подзадача 1

Рассматривая входной поток как последовательность бит, зашифруйте его при помощи восьмибитового самосинхронизирующегося скремблера.

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

Некая символьная последовательность.

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

Зашифрованная символьная последовательность.

Тесты

Входные данные	Выходные данные
Dogs eat meat.	ea 27 33 77 25 11 66 75 5 3b e0 89 6b fa
Scramble it!	fc 5a 80 ef 75 43 1e 92 9b 46 57 6
Base, base, it’s cheeseburger 1. Can you hear me?	ec 49 a0 c9 72 75 43 13 55 66 28 80 e7 ed d2 75 b7 bf 69 93 c7 df 4e d0 be 3f b1 de 5c f6 ea 6c 94 f5 8d 1f 86 80 aa 74 5e c7 9e 17 2 47 41 76 7c d4 a1

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

#include<iostream>
using namespace std;

class self_synchronizing_scrambler
{
    unsigned char key;
    unsigned char shift_register;

    bool pickbit(const unsigned char val, const short index)
    {
        return ((val >> index)%2);
    }

    public:
    self_synchronizing_scrambler() {}

    self_synchronizing_scrambler(unsigned char key, unsigned char shift_register)
    {
        this->key = key;
        this->shift_register = shift_register;
    }

    void assign_key(unsigned char key) {this->key = key;}
    void assign_register(unsigned char shift_register) {this->shift_register = shift_register;}

    unsigned char key_value() {return key;}
    unsigned char register_value() {return shift_register;}

    void scramble(unsigned char &letter)
    {
        unsigned char output = 0;
        for (unsigned char i = 0; i < 8; ++i)
        {
            bool newbit = pickbit(letter, 7-i);
            for (unsigned char j = 0; j < 8; ++j)
            {
                newbit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);
            }
            output ^= (newbit << (7-i));

            key = (key >> 1) + (newbit << 7);
        }
        letter = output;
    }

    void descramble(unsigned char &letter)
    {
        unsigned char output = 0;
        for(unsigned char i = 0; i < 8; ++i)
        {
            bool oldbit = pickbit(letter, 7-i), scrambit = 0;
            for(unsigned char j = 0; j < 8; ++j)
            {
                scrambit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);
            }
            output ^= ((scrambit^oldbit) << (7-i));

            key = (key >> 1) + (oldbit << 7);
        }
        letter = output;
    }
};

int main()
{
    self_synchronizing_scrambler A(5, 17);
    unsigned char input;

    while (scanf("%c", &input))
    {
        if (input == '\n') break;
        A.scramble(input);
        printf("%x ", input);
    }
    return 0;
}

#include<iostream>

using namespace std;

class self_synchronizing_scrambler

{

unsigned char key;

unsigned char shift_register;

bool pickbit(const unsigned char val, const short index)

{

return ((val >> index)%2);

}

public:

self_synchronizing_scrambler() {}

self_synchronizing_scrambler(unsigned char key, unsigned char shift_register)

{

this->key = key;

this->shift_register = shift_register;

}

void assign_key(unsigned char key) {this->key = key;}

void assign_register(unsigned char shift_register) {this->shift_register = shift_register;}

unsigned char key_value() {return key;}

unsigned char register_value() {return shift_register;}

void scramble(unsigned char &letter)

{

unsigned char output = 0;

for (unsigned char i = 0; i < 8; ++i)

{

bool newbit = pickbit(letter, 7-i);

for (unsigned char j = 0; j < 8; ++j)

{

newbit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);

}

output ^= (newbit << (7-i));

key = (key >> 1) + (newbit << 7);

}

letter = output;

}

void descramble(unsigned char &letter)

{

unsigned char output = 0;

for(unsigned char i = 0; i < 8; ++i)

{

bool oldbit = pickbit(letter, 7-i), scrambit = 0;

for(unsigned char j = 0; j < 8; ++j)

{

scrambit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);

}

output ^= ((scrambit^oldbit) << (7-i));

key = (key >> 1) + (oldbit << 7);

}

letter = output;

}

};

int main()

{

self_synchronizing_scrambler A(5, 17);

unsigned char input;

while (scanf("%c", &input))

{

if (input == '\n') break;

A.scramble(input);

printf("%x ", input);

}

return 0;

}

import java.util.*;
import java.io.*;

class SelfSynchronizingScrambler
{
    private char key, shift_register;

    private static int pickbit(char val, int index)
    {
        return ((val >> index)%2);
    }

    public SelfSynchronizingScrambler() {}

    public SelfSynchronizingScrambler(char key, char shift_register)
    {
        this.key = key;
        this.shift_register = shift_register;
    }

    public void assignKey(char key) {this.key = key;}
    public void assignRegister(char shift_register) {this.shift_register = shift_register;}

    public char keyValue() {return key;}
    public char registerValue() {return shift_register;}

    public char scramble(char letter)
    {
        char output = 0;
        for (char i = 0; i < 8; ++i)
        {
            int newbit = pickbit(letter, 7-i);
            for (char j = 0; j < 8; ++j)
            {
                newbit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);
            }
            output ^= (newbit << (7-i));

            key = (char)((key >> 1) + (newbit << 7));
        }
        return output;
    }

    public char descramble(char letter)
    {
        char output = 0;
        for(char i = 0; i < 8; ++i)
        {
            int oldbit = pickbit(letter, 7-i), scrambit = 0;
            for(char j = 0; j < 8; ++j)
            {
                scrambit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);
            }
            output ^= ((scrambit^oldbit) << (7-i));

            key = (char)((key >> 1) + (oldbit << 7));
        }
        return output;
    }
};

public class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        SelfSynchronizingScrambler A = new SelfSynchronizingScrambler((char)5,(char)17);
        PrintWriter out = new PrintWriter(System.out);

        char letter = (char)System.in.read();
        while(letter != '\n')
        {
            out.print((int)(A.scramble(letter)));
            out.print(' ');
            letter = (char)System.in.read();
        }
        out.flush();
    }
}

import java.util.*;

import java.io.*;

class SelfSynchronizingScrambler

{

private char key, shift_register;

private static int pickbit(char val, int index)

{

return ((val >> index)%2);

}

public SelfSynchronizingScrambler() {}

public SelfSynchronizingScrambler(char key, char shift_register)

{

this.key = key;

this.shift_register = shift_register;

}

public void assignKey(char key) {this.key = key;}

public void assignRegister(char shift_register) {this.shift_register = shift_register;}

public char keyValue() {return key;}

public char registerValue() {return shift_register;}

public char scramble(char letter)

{

char output = 0;

for (char i = 0; i < 8; ++i)

{

int newbit = pickbit(letter, 7-i);

for (char j = 0; j < 8; ++j)

{

newbit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);

}

output ^= (newbit << (7-i));

key = (char)((key >> 1) + (newbit << 7));

}

return output;

}

public char descramble(char letter)

{

char output = 0;

for(char i = 0; i < 8; ++i)

{

int oldbit = pickbit(letter, 7-i), scrambit = 0;

for(char j = 0; j < 8; ++j)

{

scrambit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);

}

output ^= ((scrambit^oldbit) << (7-i));

key = (char)((key >> 1) + (oldbit << 7));

}

return output;

}

};

public class Main

{

public static void main (String[] args) throws java.lang.Exception

{

SelfSynchronizingScrambler A = new SelfSynchronizingScrambler((char)5,(char)17);

PrintWriter out = new PrintWriter(System.out);

char letter = (char)System.in.read();

while(letter != '\n')

{

out.print((int)(A.scramble(letter)));

out.print(' ');

letter = (char)System.in.read();

}

out.flush();

}

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

Для зашифровки будем использовать стандартный алгоритм скремблирования. Скремблером будет переменная key, которая изначально равна [latex]5[/latex]. Выбирать из скремблера будем нулевой и четвёртый биты. Входные данные будут поступать в переменную input, после чего на них и на скремблере будет применяться функция scram.
Так как входные данные имеют формат unsigned char, считывание не прекратится никогда вплоть до принудительной остановки программы, ведь любые входные данные могут быть восприняты как символы. Для предотвращения этого, необходим символ, который будет служить «сигналом» для остановки программы. В нашем случае, это будет символ перехода на следующую строку.
Основная проблема задачи заключается в выводе зашифрованных данных, так как в результате скремблирования некоторые символы могут оказаться не отображаемыми. Дабы избежать подобной ситуации, зашифрованные данные будем выводить в шестнадцатеричном (для кода на Java — в десятичном) числовом формате.

Подзадача 2

Расшифровать входные данные из предыдущей подзадачи.

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

Некие зашифрованные данные, записанные в виде последовательности чисел шестнадцатеричного (для кода на Java — десятичного) формата.

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

Расшифрованные данные.

Тесты

Входные данные	Выходные данные
ea 27 33 77 25 11 66 75 5 3b e0 89 6b fa	Dogs eat meat.
fc 5a 80 ef 75 43 1e 92 9b 46 57 6	Scramble it!
ec 49 a0 c9 72 75 43 13 55 66 28 80 e7 ed d2 75 b7 bf 69 93 c7 df 4e d0 be 3f b1 de 5c f6 ea 6c 94 f5 8d 1f 86 80 aa 74 5e c7 9e 17 2 47 41 76 7c d4 a1	Base, base, it’s cheeseburger 1. Can you hear me?

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

#include <iostream>
using namespace std;

class self_synchronizing_scrambler
{
    unsigned char key;
    unsigned char shift_register;

    bool pickbit(const unsigned char val, const short index)
    {
        return ((val >> index)%2);
    }

    public:
    self_synchronizing_scrambler() {}

    self_synchronizing_scrambler(unsigned char key, unsigned char shift_register)
    {
        this->key = key;
        this->shift_register = shift_register;
    }

    void assign_key(unsigned char key) {this->key = key;}
    void assign_register(unsigned char shift_register) {this->shift_register = shift_register;}

    unsigned char key_value() {return key;}
    unsigned char register_value() {return shift_register;}

    void scramble(unsigned char &letter)
    {
        unsigned char output = 0;
        for (unsigned char i = 0; i < 8; ++i)
        {
            bool newbit = pickbit(letter, 7-i);
            for (unsigned char j = 0; j < 8; ++j)
            {
                newbit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);
            }
            output ^= (newbit << (7-i));

            key = (key >> 1) + (newbit << 7);
        }
        letter = output;
    }

    void descramble(unsigned char &letter)
    {
        unsigned char output = 0;
        for(unsigned char i = 0; i < 8; ++i)
        {
            bool oldbit = pickbit(letter, 7-i), scrambit = 0;
            for(unsigned char j = 0; j < 8; ++j)
            {
                scrambit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);
            }
            output ^= ((scrambit^oldbit) << (7-i));

            key = (key >> 1) + (oldbit << 7);
        }
        letter = output;
    }
};

int main()
{
    self_synchronizing_scrambler A(5,17);
    unsigned short scrambled;
    unsigned char output;

    while (cin >> hex >> scrambled)
    {
        output = scrambled;
        A.descramble(output);
        cout << output;
    }

    return 0;
}

#include <iostream>

using namespace std;

class self_synchronizing_scrambler

{

unsigned char key;

unsigned char shift_register;

bool pickbit(const unsigned char val, const short index)

{

return ((val >> index)%2);

}

public:

self_synchronizing_scrambler() {}

self_synchronizing_scrambler(unsigned char key, unsigned char shift_register)

{

this->key = key;

this->shift_register = shift_register;

}

void assign_key(unsigned char key) {this->key = key;}

void assign_register(unsigned char shift_register) {this->shift_register = shift_register;}

unsigned char key_value() {return key;}

unsigned char register_value() {return shift_register;}

void scramble(unsigned char &letter)

{

unsigned char output = 0;

for (unsigned char i = 0; i < 8; ++i)

{

bool newbit = pickbit(letter, 7-i);

for (unsigned char j = 0; j < 8; ++j)

{

newbit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);

}

output ^= (newbit << (7-i));

key = (key >> 1) + (newbit << 7);

}

letter = output;

}

void descramble(unsigned char &letter)

{

unsigned char output = 0;

for(unsigned char i = 0; i < 8; ++i)

{

bool oldbit = pickbit(letter, 7-i), scrambit = 0;

for(unsigned char j = 0; j < 8; ++j)

{

scrambit ^= pickbit(this->key, 7-j) & pickbit(this->shift_register, 7-j);

}

output ^= ((scrambit^oldbit) << (7-i));

key = (key >> 1) + (oldbit << 7);

}

letter = output;

}

};

int main()

{

self_synchronizing_scrambler A(5,17);

unsigned short scrambled;

unsigned char output;

while (cin >> hex >> scrambled)

{

output = scrambled;

A.descramble(output);

cout << output;

}

return 0;

}

import java.util.*;
import java.io.*;

class SelfSynchronizingScrambler
{
    private char key, shift_register;

    private static int pickbit(char val, int index)
    {
        return ((val >> index)%2);
    }

    public SelfSynchronizingScrambler() {}

    public SelfSynchronizingScrambler(char key, char shift_register)
    {
        this.key = key;
        this.shift_register = shift_register;
    }

    public void assignKey(char key) {this.key = key;}
    public void assignRegister(char shift_register) {this.shift_register = shift_register;}

    public char keyValue() {return key;}
    public char registerValue() {return shift_register;}

    public char scramble(char letter)
    {
        char output = 0;
        for (char i = 0; i < 8; ++i)
        {
            int newbit = pickbit(letter, 7-i);
            for (char j = 0; j < 8; ++j)
            {
                newbit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);
            }
            output ^= (newbit << (7-i));

            key = (char)((key >> 1) + (newbit << 7));
        }
        return output;
    }

    public char descramble(char letter)
    {
        char output = 0;
        for(char i = 0; i < 8; ++i)
        {
            int oldbit = pickbit(letter, 7-i), scrambit = 0;
            for(char j = 0; j < 8; ++j)
            {
                scrambit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);
            }
            output ^= ((scrambit^oldbit) << (7-i));

            key = (char)((key >> 1) + (oldbit << 7));
        }
        return output;
    }
};

public class Main
{

    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        SelfSynchronizingScrambler A = new SelfSynchronizingScrambler((char)5,(char)17);
        char scrambled;

        while(in.hasNextInt())
        {
            scrambled = (char)in.nextInt();
            out.print(A.descramble(scrambled));
        }

        out.flush();
    }
}

import java.util.*;

import java.io.*;

class SelfSynchronizingScrambler

{

private char key, shift_register;

private static int pickbit(char val, int index)

{

return ((val >> index)%2);

}

public SelfSynchronizingScrambler() {}

public SelfSynchronizingScrambler(char key, char shift_register)

{

this.key = key;

this.shift_register = shift_register;

}

public void assignKey(char key) {this.key = key;}

public void assignRegister(char shift_register) {this.shift_register = shift_register;}

public char keyValue() {return key;}

public char registerValue() {return shift_register;}

public char scramble(char letter)

{

char output = 0;

for (char i = 0; i < 8; ++i)

{

int newbit = pickbit(letter, 7-i);

for (char j = 0; j < 8; ++j)

{

newbit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);

}

output ^= (newbit << (7-i));

key = (char)((key >> 1) + (newbit << 7));

}

return output;

}

public char descramble(char letter)

{

char output = 0;

for(char i = 0; i < 8; ++i)

{

int oldbit = pickbit(letter, 7-i), scrambit = 0;

for(char j = 0; j < 8; ++j)

{

scrambit ^= pickbit(this.key, 7-j) & pickbit(this.shift_register, 7-j);

}

output ^= ((scrambit^oldbit) << (7-i));

key = (char)((key >> 1) + (oldbit << 7));

}

return output;

}

};

public class Main

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

PrintWriter out = new PrintWriter(System.out);

SelfSynchronizingScrambler A = new SelfSynchronizingScrambler((char)5,(char)17);

char scrambled;

while(in.hasNextInt())

{

scrambled = (char)in.nextInt();

out.print(A.descramble(scrambled));

}

out.flush();

}

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

Для расшифровки будем применять обратный алгоритм к использованному в предыдущей задаче. Значение необходимого для расшифровки дескремблера нам известно из предыдущей задачи (а именно — [latex]5[/latex]), поэтому его мы и используем.
Входные данные будут считываться методом cin (для C++), где параметр hex будет указывать на то, что данные поданы в шестнадцатеричном формате. После считывания на входных данных будет применяться алгоритм дескремблирования, и итоговые данные будут выведены на экран.

Ссылки

Related Images:

MS1. Количество чисел в потоке

24/11/2016 by Антон Куперман

Задание

Сосчитайте количество чисел во входном потоке.

Тесты

Вход	Выход
20 16 11	3
17 22.4 41.9 74.5	4
122 347 1567 21 40	5
13 28 17 8 2	5
abc 123 5.5 21 go 4	4

Код на C++

#include <iostream>
using namespace std;

int main() {
    double x, S=0;
    while (cin >> x) 
    {
       S++;
    }
    cout << S;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

double x, S=0;

while (cin >> x)

{

S++;

}

cout << S;

return 0;

}

Код на Java

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{   
    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner in = new Scanner(System.in);
        int s=0;
        while(in.hasNextDouble()){
            double x=in.nextDouble();
            s+=1;
        }
        System.out.print(s);
    }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

int s=0;

while(in.hasNextDouble()){

double x=in.nextDouble();

s+=1;

}

System.out.print(s);

}

Решение

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

Ссылки

1.Код на C++

2.Код на Java

Related Images:

А137г

01/12/2014 by Носуленко Марк

Даны натуральное число [latex]n[/latex], действительные числа [latex]a_{1}, a_{2}, \ldots a_{n}[/latex].
Вычислить: [latex]a_{1},-a_{1}a_{2},a_{1}a_{2}a_{3}, \ldots (-1)^{n+1}a_{1}a_{2} \ldots a_{n}[/latex].

Решение. Вводим переменную [latex]n[/latex], переменную [latex]a[/latex](куда будем считывать наши числа), а так же [latex]f[/latex]-произведение введенных чисел. Каждый раз в цикле уже введенные числа умножаются на следующее число взятое с противоположным знаком, а изначально «f» равна «[latex]-1[/latex]» так как «Очередное произведение отличается от предыдущего сомножителем [latex](-a_{i})[/latex]».

Тесты:
[latex]n=3[/latex]

Числа[latex](a_{n})[/latex]	Результат:
1	1, -2, 6.
2
3

[latex]n=7[/latex]

Числа[latex](a_{n})[/latex]	Результат:
1.8	1.8, -7.02, 0.000702, 0.055458, -25.3432, 22.8114, -91.2456.
3.9
0.0001
-79
456.98
0.9001
4

#include <iostream>
#include <math.h>
using namespace std;

int main() {
	int n; //Количество вводимых чисел.
	cin >>n;
	double a,f; //а-переменна для считывания чисел, f-произведения введенных чисел, m-результат из f умноженый на -1 в степени n+1.
	f=-1;
	for(int k=1; k<=n; ++k){
		cin >>a;
		f*=-a;
		cout <<f; //Выводим результат.
		if(k<n) //Тут думаю нечего обьяснять.
			cout <<", ";
		else
			cout <<".";
		
	}
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n; //Количество вводимых чисел.

cin >>n;

double a,f; //а-переменна для считывания чисел, f-произведения введенных чисел, m-результат из f умноженый на -1 в степени n+1.

f=-1;

for(int k=1; k<=n; ++k){

cin >>a;

f*=-a;

cout <<f; //Выводим результат.

if(k<n) //Тут думаю нечего обьяснять.

cout <<", ";

else

cout <<".";

}

return 0;

}

Ссылка на код.

Related Images:

А165ж

22/10/2014 by Денисова Ольга

Задача

Даны действительные числа [latex]a_{1},a_{2}[/latex] … Известно, что [latex]a_{1}>0[/latex] и что среди [latex]a_{2}, a_{3}[/latex] … есть хотя бы одно отрицательное число. Пусть [latex]a_{1},\ldots,a_{n}[/latex] — члены данной последовательности, предшествующие первому отрицательному члену ( [latex]n[/latex] заранее неизвестно). Получить:

[latex]a_{1}a_{2}+a_{2}a_{3}+\ldots+a_{n-1}a_{n}+a_{n}a_{1}[/latex] .

Тесты:

Введенные числа	Результат	Комментарий
2 3 4 -5	26	пройден
6 0 45 3 -1	153	пройден
1 -223	1	пройден

Решение:

#include <iostream>
using namespace std;
 
int main() {
	double sum = 0 , a_first, a_prev, a_cur;
	cin >> a_first;
    a_cur = a_first;
    a_prev = a_first;
 
	while (a_cur >= 0) {
		cin >> a_cur;
		if (a_cur < 0) {
			sum += a_prev*a_first;
			break;
		}
		sum += a_prev*a_cur;
		a_prev = a_cur;
	}
 
	cout << "Sum = " << sum << endl;
 
	return 0;
}

#include <iostream>

using namespace std;

int main() {

double sum = 0 , a_first, a_prev, a_cur;

cin >> a_first;

a_cur = a_first;

a_prev = a_first;

while (a_cur >= 0) {

cin >> a_cur;

if (a_cur < 0) {

sum += a_prev*a_first;

break;

}

sum += a_prev*a_cur;

a_prev = a_cur;

}

cout << "Sum = " << sum << endl;

return 0;

}

Программа считает по формуле (данной в условии) все введенные положительные числа, пока не встретится отрицательное число.

Ссылка на код.

А на Java решение выглядит так:

import java.util.*;
import java.lang.*;
import java.io.*;

class solution
{
	public static void main (String[] args)
	{
		Scanner sc = new Scanner(System.in);
		double sum = 0 , a_first, a_prev, a_cur;
		a_first = sc.nextDouble();
	    a_cur = a_first;
	    a_prev = a_first;
	 
		while (a_cur >= 0) {
			a_cur = sc.nextDouble();
			if (a_cur < 0) {
				sum += a_prev*a_first;
				break;
			}
			sum += a_prev*a_cur;
			a_prev = a_cur;
		}
	 
		System.out.println("Sum = " + sum);
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class solution

{

public static void main (String[] args)

{

Scanner sc = new Scanner(System.in);

double sum = 0 , a_first, a_prev, a_cur;

a_first = sc.nextDouble();

a_cur = a_first;

a_prev = a_first;

while (a_cur >= 0) {

a_cur = sc.nextDouble();

if (a_cur < 0) {

sum += a_prev*a_first;

break;

}

sum += a_prev*a_cur;

a_prev = a_cur;

}

System.out.println("Sum = " + sum);

}

Related Images:

А161

14/10/2014 by Карагяур Мілан Сергійович

Задача: Даны натуральное число n, действительные числа [latex]a_{1},…,a_{n}[/latex], получить [latex]b_{1},…,b_{n}[/latex], где [latex]b_{i}= \frac{a_{i}}{1 + (a_{1} +… + a_{i})^{2}}[/latex], [latex]i = 1,…, n[/latex].

[latex]n[/latex]	[latex]a[/latex]	[latex]b[/latex]
7	1 2 3 4 5 6 7	0.500 0.200 0.081 0.040 0.022 0.014 0.009
10	4.5 3.1 6.7 1.1 8.9 4.32 1.45 5.1 4.5 8.1	0.212 0.053 0.033 0.005 0.015 0.005 0.002 0.004 0.003 0.004

#include <iostream>
using namespace std;

int main()
{
	double a, b, an = 0;
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		if (scanf("%lf", &a) == EOF) break;
		b = a / (1 + ((a + an) * (a + an)));//Вычисляем формулу 
		printf("\n%3.2lf %3.3lf", a, b);
		an = a + an; // Запоминаем сумму 
	}
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

double a, b, an = 0;

int n;

scanf("%d", &n);

for (int i = 0; i < n; i++)

{

if (scanf("%lf", &a) == EOF) break;

b = a / (1 + ((a + an) * (a + an)));//Вычисляем формулу

printf("\n%3.2lf %3.3lf", a, b);

an = a + an; // Запоминаем сумму

}

return 0;

}

Создаем цикл от i до заданного n. В нем каждый раз читаем [latex]a[/latex] и по формуле получаем [latex]b[/latex]. В конце цикла запоминаем [latex]a_{n}[/latex] для вычисления суммы [latex]a_{1}+…+a_{i}[/latex]. Если цикл дошел до конца файла то прерываем его.

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

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		double a, b, an = 0;
		int n = in.nextInt();   
		for (int i = 0; i < n; i++)
		{
			a = in.nextDouble();
			b = a / (1 + ((a + an) * (a + an)));//Вычисляем формулу 
			System.out.format("\n %3.2f %3.3f", a, b);
			an = a + an; // Запоминаем сумму 
		}
	}
}