Category Archives: 5. Массивы

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

Массивы

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

К этой рубрике относятся задания на использование классических массивов, работе с ними через указатели и ссылочные типы. Желательно снова перечитать параграф 3.5 и 3.6 из праймера. Размер массива обычно будет читаться из входного потока. Это вынуждает использовать динамические массивы. В качестве заготовки можно использовать такой код:

#include <iostream>
using namespace std;
 
int main() {
    size_t n;   
    cin >> n;
    double *x = new double [n];
    for(size_t i = 0; i < n; i++)
        cin >> x[i];
        
    // Processing 
    for(size_t i = 0; i < n; i++)
        cout << "x[" << i << "] = " << x[i] << "\t";
}

#include <iostream>

using namespace std;

int main() {

size_t n;

cin >> n;

double *x = new double [n];

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

cin >> x[i];

// Processing

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

cout << "x[" << i << "] = " << x[i] << "\t";

}

Выполнить программу Обратите внимание, что цикл в котором … Continue reading →

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

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

Санта Клаус
Кубики — 3 — используйте массив bool для хранения предположений о потери кубика для каждой из 26+26=52 букв.
Прямоугольник — используйте массив точек.

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

e-olymp 2099. Два массива

26/05/2019 by Даниил Мозгунов

Задача

Даны два массива чисел. Требуется вывести те элементы первого массива (в том порядке, в каком они идут в первом массиве), которых нет во втором массиве.

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

Сначала подаётся количество [latex]n[/latex] элементов в первом массиве, затем [latex]n[/latex] чисел — элементы массива. Затем записано количество [latex]m[/latex] элементов во втором массиве. Далее заданы элементы второго массива. Количество элементов каждого массива не превышает [latex]100[/latex]. Все элементы — целые числа.

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

В первой строке выведите количество искомых элементов, а во второй выведите те элементы первого массива, которых нет во втором, в том порядке, в каком они идут в первом массиве.

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	7 3 1 3 4 2 4 12 6 4 15 43 1 15 1	4 3 3 2 12
2	5 12 16 17 45 68 6 1 93 45 68 34 38	3 12 16 17
3	10 15 47 68 59 75 25 35 61 21 86 10 15 47 69 58 75 26 36 61 21 89	5 68 59 25 35 86
4	10 15 47 68 59 75 25 35 61 21 86 10 15 47 68 59 75 25 35 61 21 86	0 0

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

#include <iostream>
using namespace std;
 
int main() {
  bool q;
  int n, m, c = 0;
  int arr1[101], arr2[101], arr3[101];
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> arr1[i];
  }
  cin >> m;
  for (int i = 0; i < m; i++) {
    cin >> arr2[i];
  }
  for (int i = 0; i < n; i++) {
    q = false;
    for (int j = 0; j < m; j++)
      if (arr1[i] == arr2[j]) q = true;
    if (q == false) {
      arr3[c] = arr1[i];
      c++;
    }
  }
  cout << c << endl;
  for (int i = 0; i < c - 1; i++) {
    cout << arr3[i] << " ";
  }
  cout << arr3[c - 1];
  return 0;
}

#include <iostream>

using namespace std;

int main() {

bool q;

int n, m, c = 0;

int arr1[101], arr2[101], arr3[101];

cin >> n;

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

cin >> arr1[i];

}

cin >> m;

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

cin >> arr2[i];

}

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

q = false;

for (int j = 0; j < m; j++)

if (arr1[i] == arr2[j]) q = true;

if (q == false) {

arr3[c] = arr1[i];

c++;

}

cout << c << endl;

for (int i = 0; i < c - 1; i++) {

cout << arr3[i] << " ";

}

cout << arr3[c - 1];

return 0;

}

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

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

Ссылки

Related Images:

e-olymp 8173. Большинство

04/05/2019 by Никита Шпилевский

Задача

Голоса собраны! Были опрошены математики по всему миру, и каждый из них выбрал свой любимый номер между [latex]1[/latex] и [latex]1000[/latex]. Ваша цель — подсчитать голоса и определить самый популярный номер.

Если существует несколько голосов с наибольшим количеством, то выберите наименьшее число с максимальным количеством голосов.

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

Первая строка содержит количество тестов, от [latex]1[/latex] до [latex]100[/latex] включительно. Первая строка каждого теста содержит количество голосов [latex]V (1 \leq V \leq 1000)[/latex], за которой следуют [latex]V[/latex] строк — каждая из них содержит одно число от [latex]1[/latex] до [latex]1000[/latex].

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

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

Тесты

№	Входные данные	Выходные данные
1	2 3 42 42 19 4 7 99 99 7	42 7
2	1 5 11 12 13 14 15	11
3	2 2 1000 1000 1 3	1000 3

Код

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

int main() {
    int testAmount, V, digit, numberOfMax, max, maxDigit, answer;
    cin >> testAmount;
    for(int i = 0; i < testAmount; i++) {
        int digitAmountArray[1001] = {};
        maxDigit = 0;
        answer = 0;
        cin >> V;
        for (int k = 0; k < V; k++) {
            cin >> digit; 
            if(digit > maxDigit) maxDigit = digit;
            digitAmountArray[digit]++;
        }

        max = digitAmountArray[0];
        for (int p = 1; p <= maxDigit; p++) {
            if(digitAmountArray[p] > max) {
                max = digitAmountArray[p];
                numberOfMax = p;
            }
        } 
        for(int l = 0; l <= maxDigit; l++) {
            if(digitAmountArray[l] == digitAmountArray[numberOfMax]) {
                answer = min(numberOfMax, l); 
            }   
        }
        cout << answer << endl;
    }
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

int main() {

int testAmount, V, digit, numberOfMax, max, maxDigit, answer;

cin >> testAmount;

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

int digitAmountArray[1001] = {};

maxDigit = 0;

answer = 0;

cin >> V;

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

cin >> digit;

if(digit > maxDigit) maxDigit = digit;

digitAmountArray[digit]++;

}

max = digitAmountArray[0];

for (int p = 1; p <= maxDigit; p++) {

if(digitAmountArray[p] > max) {

max = digitAmountArray[p];

numberOfMax = p;

}

for(int l = 0; l <= maxDigit; l++) {

if(digitAmountArray[l] == digitAmountArray[numberOfMax]) {

answer = min(numberOfMax, l);

}

cout << answer << endl;

}

return 0;

}

Решение

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

Ссылки

- Задача на e-olymp
- Решение на e-olymp

Related Images:

e-olymp 2322. Столбцы

28/04/2019 by Михаил Бутник

Столбцы

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

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

В первой строке задано число [latex]x[/latex], не превышающее по модулю 2 [latex]\cdot[/latex] 10⁹. Во второй строке задано число [latex]n \left(1 \leqslant n \leqslant 100\right)[/latex]. Каждая из следующих [latex]n[/latex] строк содержит [latex]n[/latex] целых чисел, не превышающих по модулю 2 [latex]\cdot[/latex] 10⁹ — числа в ячейках таблицы.

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

Для каждого столбца в отдельной строке выведите YES, если в нем есть число [latex]x[/latex], и NO в противном случае.

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	1 2 0 1 0 0	NO YES
2	23 3 23 0 23 21 12 23 11 13 23	YES NO YES
3	7 1 0	NO
4	13 3 13 33 75 23 45 31 13 13 13	YES YES YES

Код

#include <iostream>
using namespace std; 
 
int arr[101];
int main() {
    long long x, c;
    cin >> x;
    int n, i = 0;
    cin >> n;
    while (cin >> c) {
        if (c == x) {
            arr[i % n]++;
        }
        i++;
    }
    for (int i = 0; i < n; i++) {
        if (arr[i] > 0) {
            cout << "YES" << endl;
        }
        else {
            cout << "NO" << endl;
        }
    }
    return 0;
}

#include <iostream>

using namespace std;

int arr[101];

int main() {

long long x, c;

cin >> x;

int n, i = 0;

cin >> n;

while (cin >> c) {

if (c == x) {

arr[i % n]++;

}

i++;

}

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

if (arr[i] > 0) {

cout << "YES" << endl;

}

else {

cout << "NO" << endl;

}

return 0;

}

Решение

Для решения этой задачи заведём массив на [latex]n[/latex] элементов, в котором каждый элемент будет счётчиком соответствующего столбца. В цикле будем смотреть все элементы и, если нам встретится элемент [latex]x[/latex], увеличим соответствующий счётчик. Затем в другом цикле смотрим счётчик каждого столбца, если он больше нуля, то выводим YES, иначе — NO.

Запустить код (ideone) можно здесь
Задача на E-olymp

Related Images:

e-olymp 4752. Кинотеатр

28/03/2019 by Анна Неделева

Задача

Однажды, ученики B-й школы города G решили съездить в кино. Администрация кинотеатра расположила их в зале размера n × m, который специально был подобран так, чтобы все места были заняты школьниками. Каждому посетителю кинотеатра был выдан свой номер.

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

Однако классный руководитель решил, что такая рассадка плохо влияет на поведение учащихся и пересадил их по-другому: ученики сначала занимали все первые места каждого ряда, потом все вторые места каждого ряда и т.д. (см. рисунок).

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

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

В первой строке заданы числа $n$ и $m$ $(1 ≤ n, m ≤ 1000)$.

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

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

Тесты

№	Входные данные	Выходные данные
1	3 3	3
2	3 4	2
3	6 3	2
4	5 9	5
5	7 5	3

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

#include <iostream>
using namespace std;

int main() {
  int arr[1000][1000], n, m, count1 = 1, count2 = 1, result = 0;
  cin >> n >> m;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++)
      arr[i][j] = count1++;
  for (int j = 0; j < m; j++) {
    for (int i = 0; i < n; i++) {
      if (arr[i][j] == count2) result++;
      count2++;
    }
  }
  cout << result << "\n";
}

#include <iostream>

using namespace std;

int main() {

int arr[1000][1000], n, m, count1 = 1, count2 = 1, result = 0;

cin >> n >> m;

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

for (int j = 0; j < m; j++)

arr[i][j] = count1++;

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

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

if (arr[i][j] == count2) result++;

count2++;

}

cout << result << "\n";

}

Код программы с линейным массивом

#include <iostream>
using namespace std;
 
int main() {
  int arr[1000 * 1000], n, m, result = 0;
  cin >> n >> m;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++)
      arr[i * m + j] = i * m + j;
  for (int j = 0; j < m; j++) 
    for (int i = 0; i < n; i++) 
      if (arr[i * m + j] == j * n + i) result++;
  cout << result << "\n";
}

#include <iostream>

using namespace std;

int main() {

int arr[1000 * 1000], n, m, result = 0;

cin >> n >> m;

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

for (int j = 0; j < m; j++)

arr[i * m + j] = i * m + j;

for (int j = 0; j < m; j++)

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

if (arr[i * m + j] == j * n + i) result++;

cout << result << "\n";

}

Код программы без массива

#include <iostream>
using namespace std;
 
int main() {
  int n, m, result = 0;
  cin >> n >> m;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++)
      if (i * m + j == j * n + i) result++;
  cout << result << "\n";
}

#include <iostream>

using namespace std;

int main() {

int n, m, result = 0;

cin >> n >> m;

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

for (int j = 0; j < m; j++)

if (i * m + j == j * n + i) result++;

cout << result << "\n";

}

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

Для решения задачи проверяем значения до пересадки и после, если они совпадут соответственно, то инкрементируем счётчик. А в конце выводим результат.

Ссылки

Related Images:

e-olymp 8530. Печать матрицы

26/02/2019 by Лиза Севастьянова

Задача

Условие

Задана матрица $n \cdot n$ — назовем ее $[1..n] \cdot [1..n]$ массивом. Для заданных $r$ и $c$ следует вывести $[1..r] \cdot [1..c]$ массив ($r$ строк и $c$ столбцов исходного массива).

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

Первая строка содержит число $n (1 \leq n \leq 100)$. Следующие строки содержат матрицу $n \cdot n$. Последняя строка содержит два числа $r$ и $c$ $(1 \leq r, c \leq n)$. Все числа в матрице не превышают по модулю $100$.

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

Выведите матрицу $r \cdot c$.

Тесты

№	Входные данные	Выходные данные
1	4 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 3 2	1 2 5 6 9 1
2	5 18 25 34 44 -43 54 65 75 85 -32 95 15 25 35 -3 -4 15 -6 37 0 44 43 23 3 -12 4 3	18 25 34 54 65 75 95 15 25 -4 15 -6
3	2 0 -1 23 69 1 1	0
4	3 1 2 3 -4 -5 -6 7 8 9 3 1	1 -4 7

Решение

Для решения данной задачи необходимо ввести в массив все имеющиеся данные и вывести необходимые, соответственно заданным параметрам. Можно использовать как одномерные массивы, так и двухмерные.
В реализации с одномерными вводим все данные в массив $n \cdot n$, а затем выводим, используя вложенные циклы. Цикл проходит от $0$ до $r$ и от $(j \cdot n)$ — первого элемент необходимой строки до $(c + j \cdot n)$ — последнего элемента. В реализации с двумерными массивами заводим все данные в один массив и после выводим необходимые.

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

#include <iostream>
using namespace std;
 
#define N 100
 
int main() {
    int n;
    cin >> n;
    int arr[N * N];
    for (int i = 0; i < n * n; i++) {
        cin >> arr[i]; 
    }
    int r, c;
    cin >> r >> c;
    for (int i = 0; i < c * r; i++) {
        cout << arr[((i / c) * n) + (i % c)] << ((1+i) % c == 0? "\n" : " ");
    }
}

#include <iostream>

using namespace std;

#define N 100

int main() {

int n;

cin >> n;

int arr[N * N];

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

cin >> arr[i];

}

int r, c;

cin >> r >> c;

for (int i = 0; i < c * r; i++) {

cout << arr[((i / c) * n) + (i % c)] << ((1+i) % c == 0? "\n" : " ");

}

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

#include <iostream>
using namespace std;
 
#define N 100
 
int main() {
    int n, r, c;
    cin >> n;
    int arr[N][N];
    for (int i = 0; i < n; i++) {
        for (int j = 0 ; j < n; j++) 
            cin >> arr[i][j];
    }
    cin >> r >> c;
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            cout << arr[i][j] << " ";
        } cout << endl;
    }
    return 0; 
}

#include <iostream>

using namespace std;

#define N 100

int main() {

int n, r, c;

cin >> n;

int arr[N][N];

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

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

cin >> arr[i][j];

}

cin >> r >> c;

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

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

cout << arr[i][j] << " ";

} cout << endl;

}

return 0;

}

Ссылки

Related Images:

e-olymp 7504. Три прямоугольника

19/01/2019 by Николай Козиний

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

Задача

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

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

Одно число — количество закрашенных клеток

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

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

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	0 0 1 1 1 1 2 2 0 0 2 2	4
2	2 -2 -2 2 -1 -1 1 1 40 40 41 41	17
3	-1 2 2 -1 1 0 4 2 1 0 3 6	21
4	-100 -100 -99 -99 100 100 99 99 -100 -100 100 100	40000
5	3 0 4 1 1 0 3 3 1 0 3 3	7

Решение

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

Для нахождения пересечения прямоугольников рассмотрим проекции координат прямоугольника на координатные оси $x$ и $y$. В случае, если интервалы пересекаются, началом пересечения будет наибольшее из начал интервалов, а концом — наименьшее из их концов. В ином же случае дадим точкам по этой координате одинаковые значения, в результате чего площадь такого прямоугольника и всех пересечений, которые он образует будет равна нулю. Координатами точек пересечения прямоугольников будут, следовательно, соответствующие координаты пересечения интервалов на осях.

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

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

#include <iostream>
#include <cmath>
using namespace std;
struct point{int x;int y;};
struct rect{point a;point b;};
rect getrect(point a, point b, rect c){
    if(a.x > b.x)swap(a.x,b.x);
    if(a.y > b.y)swap(a.y,b.y);
    c.a = a;
    c.b = b;
    return c;
}
rect getrekt(rect c){
    point a,b;
    cin >> a.x >> a.y >> b.x >> b.y;
    return getrect(a,b,c);
}
int area(rect sq){return (sq.b.x - sq.a.x) * (sq.b.y - sq.a.y);}

rect cross(rect l,rect r){
    rect cr;
    point a1,b1;
    a1.x = ((l.a.x > r.b.x or r.a.x > l.b.x)?0:max(l.a.x,r.a.x));
    a1.y = ((l.a.y > r.b.y or r.a.y > l.b.y)?0:max(l.a.y,r.a.y));
    b1.x = ((l.a.x > r.b.x or r.a.x > l.b.x)?0:min(l.b.x,r.b.x));
    b1.y = ((l.a.y > r.b.y or r.a.y > l.b.y)?0:min(l.b.y,r.b.y));
    return getrect(a1,b1,cr);
}
int farea(rect *q){
    return area(q[0]) + area(q[1]) + area(q[2]) - area(cross(q[0],q[1])) - area(cross(q[0],q[2])) - area(cross(q[2],q[1])) + area(cross(q[0],cross(q[1],q[2])));
}
int main() {
    rect *q = new rect [3];
    for(int i = 0;i < 3;i++)q[i] = getrekt(q[i]);
    cout<<farea(q);
}

#include <iostream>

#include <cmath>

using namespace std;

struct point{int x;int y;};

struct rect{point a;point b;};

rect getrect(point a, point b, rect c){

if(a.x > b.x)swap(a.x,b.x);

if(a.y > b.y)swap(a.y,b.y);

c.a = a;

c.b = b;

return c;

}

rect getrekt(rect c){

point a,b;

cin >> a.x >> a.y >> b.x >> b.y;

return getrect(a,b,c);

}

int area(rect sq){return (sq.b.x - sq.a.x) * (sq.b.y - sq.a.y);}

rect cross(rect l,rect r){

rect cr;

point a1,b1;

a1.x = ((l.a.x > r.b.x or r.a.x > l.b.x)?0:max(l.a.x,r.a.x));

a1.y = ((l.a.y > r.b.y or r.a.y > l.b.y)?0:max(l.a.y,r.a.y));

b1.x = ((l.a.x > r.b.x or r.a.x > l.b.x)?0:min(l.b.x,r.b.x));

b1.y = ((l.a.y > r.b.y or r.a.y > l.b.y)?0:min(l.b.y,r.b.y));

return getrect(a1,b1,cr);

}

int farea(rect *q){

return area(q[0]) + area(q[1]) + area(q[2]) - area(cross(q[0],q[1])) - area(cross(q[0],q[2])) - area(cross(q[2],q[1])) + area(cross(q[0],cross(q[1],q[2])));

}

int main() {

rect *q = new rect [3];

for(int i = 0;i < 3;i++)q[i] = getrekt(q[i]);

cout<<farea(q);

}

Решение. Многомерные массивы

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

#include <iostream>
#include <cmath>
#define N 100
using namespace std;
 
int main() {
    int rect[3][4];
    int field[2*N][2*N];
    int count = 0;
    for(int i = 0;i < 2*N;i++)for(int k = 0;k < 2*N;k++)field[i][k] = 0;
    for(int i = 0;i < 3;i++){
        for(int k = 0;k < 4;k++){
            cin >> rect[i][k];
            rect[i][k] = rect[i][k] + N;
        }
    }
    for(int k = 0;k<3;k++){
        for(int i = min(rect[k][0],rect[k][2]);i < max(rect[k][0],rect[k][2]);i++){
            for(int j = min(rect[k][1],rect[k][3]);j < max(rect[k][1],rect[k][3]);j++){
                field[i][j]=1;
            }
        }
    }
    for(int i = 0;i < 2*N;i++){
        for(int k = 0;k < 2*N;k++){
            if(field[i][k] & 1)count++;
        }
    }
    cout<<count;
}

#include <iostream>

#include <cmath>

#define N 100

using namespace std;

int main() {

int rect[3][4];

int field[2*N][2*N];

int count = 0;

for(int i = 0;i < 2*N;i++)for(int k = 0;k < 2*N;k++)field[i][k] = 0;

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

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

cin >> rect[i][k];

rect[i][k] = rect[i][k] + N;

}

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

for(int i = min(rect[k][0],rect[k][2]);i < max(rect[k][0],rect[k][2]);i++){

for(int j = min(rect[k][1],rect[k][3]);j < max(rect[k][1],rect[k][3]);j++){

field[i][j]=1;

}

for(int i = 0;i < 2*N;i++){

for(int k = 0;k < 2*N;k++){

if(field[i][k] & 1)count++;

}

cout<<count;

}

Код задачи на ideone
Еще один код задачи на ideone(многомерные массивы)
Засчитанное решение на e-olymp

Related Images:

e-olymp 94. Problem of prime numbers!

10/01/2019 by Руслан Масальский

The task is taken from e-olymp

Task

One of the most difficulties of an instructor is question design for the final-term exam. Dr. Ghavamnia teaches “Fundamentals of Algorithms” at University of Isfahan (UI) and has designed a good practical algorithmic problem for his exam. He wants that students use all of their algorithmic skills to code this problem as best and efficient as they can. The problem is as follows: a ring is composed of [latex]N[/latex] circles numbered from [latex]1[/latex] to [latex]N[/latex] as shown in diagram. You are given [latex]N[/latex] integer numbers. Put these numbers into each circle separately with the condition that sum of numbers in three adjacent circles must be a prime.
Each test case may have several solutions and your task is to find the one with minimum weighted sum. Weighted sum is defined as the sum of products of each number in circle by the sequence number of that circle. For instance, the weighted sum in above diagram is [latex]36[/latex] (and also it is the minimum).

Input

The first line of input contains a single integer, the number of test cases. Following, there is one line for each test case. Each test case begins with one integer, [latex]N[/latex] ([latex]3 \leq N \leq 15[/latex]), which is the number of circles. Next [latex]N[/latex] integers are the given numbers to put in circles (all between [latex]1[/latex] and [latex]100[/latex], inclusively).

Output

There should be one line for each test case in output. If there’s no way for building the ring, the word «impossible» should be outputted, or otherwise, a single integer which is the minimum weighted sum.

Tests

№	Inputs	Outputs
1	5 4 1 3 7 9 4 1 1 3 5 15 11 6 2 3 2 14 1 2 10 7 2 2 3 6 2 9 1 1 1 2 2 2 2 2 2 7 1 2 3 4 5 6 7	36 imposible 396 72 imposible

Code

#include <iostream>
#include <vector> 
#include <string>
using namespace std;
int length;
vector <int> input(16);
vector <int> output(16);
bool used[16];
const int SIZE = 350;
bool isPrime[SIZE];
const int INF = 2147483647;
long min;
bool prime(int k) {
    return isPrime[k];
}
void init() { // initialization for Sieve of Eratosthenes
    for (int i = 0; i < SIZE; i++) {
        isPrime[i] = true;
    }
    for (int i = 2; i * i < SIZE; i++) {
        if (isPrime[i]) {
            for (int j = i * i; j < SIZE; j += i) {
                isPrime[j] = false;
            }
        }
    }
}
void perm(int pos) {
    if (pos == length) {
        if (!prime(output[pos - 1] + output[0] + output[1]) || !prime(output[pos - 1] + output[pos - 2] + output[0])) {
            return;
        }
        for (int z = 0; z < length; z++) {
            long temp = 0;
            for (int i = 1; i <= length; i++) {
                temp += i * output[i - 1];
            }
            if (temp < ::min) {
                ::min = temp;
            }
            int k = output[0];
            for (int j = 0; j < length - 1; j++) {
                output[j] = output[j + 1];
            }
            output[length - 1] = k;
        }
        return;
    }
    for (int i = 0; i < length; i++)
        if (!used[i]) {
            output[pos] = input[i];
            if (pos >= 2 && !prime(output[pos] + output[pos - 1] + output[pos - 2])) {
                continue;
            }
            used[i] = true;
            perm(pos + 1);
            used[i] = false;
        }
}
int main() {
    string f;
    init();
    int t;
    cin >> t;
    for (int j = 0; j < t; j++) {::min = INF;
        scanf("%d", &length);
        for (int i = 0; i < length; i++) {
            scanf("%d", &(input[i]));
        }
        output[0] = input[0];
        used[0] = true;
        perm(1);
        f = (::min == INF ? "impossible" : to_string(::min));
        printf("%s\n", f.c_str());
    }
    return 0;
}

#include <iostream>

#include <vector>

#include <string>

using namespace std;

int length;

vector <int> input(16);

vector <int> output(16);

bool used[16];

const int SIZE = 350;

bool isPrime[SIZE];

const int INF = 2147483647;

long min;

bool prime(int k) {

return isPrime[k];

}

void init() { // initialization for Sieve of Eratosthenes

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

isPrime[i] = true;

}

for (int i = 2; i * i < SIZE; i++) {

if (isPrime[i]) {

for (int j = i * i; j < SIZE; j += i) {

isPrime[j] = false;

}

void perm(int pos) {

if (pos == length) {

if (!prime(output[pos - 1] + output[0] + output[1]) || !prime(output[pos - 1] + output[pos - 2] + output[0])) {

return;

}

for (int z = 0; z < length; z++) {

long temp = 0;

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

temp += i * output[i - 1];

}

if (temp < ::min) {

::min = temp;

}

int k = output[0];

for (int j = 0; j < length - 1; j++) {

output[j] = output[j + 1];

}

output[length - 1] = k;

}

return;

}

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

if (!used[i]) {

output[pos] = input[i];

if (pos >= 2 && !prime(output[pos] + output[pos - 1] + output[pos - 2])) {

continue;

}

used[i] = true;

perm(pos + 1);

used[i] = false;

}

int main() {

string f;

init();

int t;

cin >> t;

for (int j = 0; j < t; j++) {::min = INF;

scanf("%d", &length);

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

scanf("%d", &(input[i]));

}

output[0] = input[0];

used[0] = true;

perm(1);

f = (::min == INF ? "impossible" : to_string(::min));

printf("%s\n", f.c_str());

}

return 0;

}

Solution

We need all permutations of our array and if permutation suits us update [latex]min[/latex] value. To check if number is prime I use Sieve of Eratosthenes. To get all permutation I use recursive function which works in this way:
We accumulate an array in all possible ways. What we do:

Fixed empty position in array with a value
Remember that we used this value
Find all permutations of array with size which is smaller by 1
Forget that we used this value (to use it in next permutations)

We stop when we accumulate an array with size we need and check if this permutation suits us(if sum of all triples of this circle are prime). If yes update answer(if it is less than answer). So if we send this solution to server we will get time limit. We need to reduce permutations which do not suit us. To speed up our program we can reduce amount of permutations in this way: if we find out that sum of previous three numbers, which are fixed, is not prime, we do not need to continue this branch of recursion. Really if in our array we found that one sum of three number is not prime we do not need to accumulate this array further. But anyway we get time limit.
Let’s see the differences in complete array where any some of three numbers is prime number.
Input: 8 2 1
Let’s find all suitable permutations:

8 2 1
2 8 1
2 1 8
1 8 2
8 1 2
1 2 8

As you can see first three are different with shifts. Last three are also different with shifts. So we can fix one element find all permutations we need with less by 1 amount of elements and then shift all elements of every array to get all possible permutations which are correct as you can see above (1,2,3) (4,5,6). In the worst case it will work not for [latex]15![/latex] but for [latex]14![/latex]. And now we get Accept.
The complexity is [latex]O(n!)[/latex] Why I did not get time limit at all (because of complexity)? In task said than amount of test which works with [latex]O(n!)[/latex] can be huge. But who will make so many tests? In our case there are near 5 tests in one.

e-olymp 4751. Диагонали

08/01/2019 by Александр Мога

Задача

В квадратной таблице [latex] n × n [/latex] подсчитать сумы чисел, стоящих на главной и побочной диагоналях.

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

Вводится число [latex]n (1 \le n \le 500)[/latex], а затем матрица [latex] n × n [/latex]. Элементы матрицы — числа по модулю не больше [latex]10^5[/latex].

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

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

Вывести сумму чисел сначала на главной, а затем на побочной диагонали.

Тесты

Вход	Выход
4 134 475 30 424 303 151 419 235 248 166 90 42 318 237 184 36	411 1327
7 -59 21 7 5 12 868 -565 32 19 52 3 7 11 0 3 -123 -52 -99 -857 -4621 -561 11 232 86 652 46 3244 572 857 -1242 -6767 923 -575 12 1 552 232 2 63 -76 23 0 12 34 87 20 -7 767 959	967 -7282
3 1 45 82 96 29 90 757 23 12	42 868
2 12 32 99 71	83 131
5 12 32 54 76 12 95 23 21 123 0 65 32 1 773 992 5 32 155 866 912 134 44 74 11 23	36 136

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

#include <iostream>
using namespace std;

int main() {
    int n;
    int m=0;
    int c=0;
    cin >> n;
    int ** x = new int * [n];
    for (int i = 0; i < n; i++) 
        x[i] = new int[n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) 
            cin >> x[i][j];
    }
    for (int i = 0; i < n; i++){
        m+=x[i][i];
        c+=x[i][n-1-i];
    }
    for (int i = 0; i < n; i++) 
        delete []x[i];
    delete []x;
    cout <<  m << " " << c;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

int m=0;

int c=0;

cin >> n;

int ** x = new int * [n];

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

x[i] = new int[n];

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

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

cin >> x[i][j];

}

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

m+=x[i][i];

c+=x[i][n-1-i];

}

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

delete []x[i];

delete []x;

cout << m << " " << c;

return 0;

}

Решение

Создаем динамический массив.

Чтобы найти сумму главной диагонали берём, лишь те элементы массива, в которых номер строки и столбца равны.

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

Ссылки

e-olymp

ideone

Related Images:

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

25/12/2018 by Алина Гук

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

Задача

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

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

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

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

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

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
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	3 4 1 2 3 3 5 2 7 1 6 9 8 3	2.00 3.00 6.00 8.00
3	10 2 1 2 3 4 5 6 7 8 9 10 1 1 1 2 2 2 3 3 3 4	5.50 2.50

Код программы (Потоковая обработка)

#include <iostream>
#include <iomanip>
using namespace std;
 
int main() {
    cout << fixed << setprecision(2);
    int n, m, tmp, sumGl, sumMin, sumMax, valMin, valMax, countMin, countMax;
    cin >> n >> m;
    for(int j = 0 ; j < m ; j++){
        sumGl = sumMin = sumMax = 0;
        valMin = 11;
        valMax = 0;
        countMin = countMax = 0;
        for(int i = 0 ; i < n; i++) {
            cin >> tmp;
            sumGl += tmp;
            if(tmp < valMin) {
                sumMin = tmp;
                valMin = tmp;
                countMin = 1;
            }
            else if(tmp == valMin) {
                sumMin += tmp;
                countMin++;
            }
            if(tmp > valMax) {
                sumMax = tmp;
                valMax =tmp;
                countMax = 1;
            }
            else if(tmp == valMax) {
                sumMax += tmp;
                countMax++;
            }
        }
        cout << (sumGl - sumMax - sumMin) / (double)(n - countMax - countMin) << " ";
    }
    return 0;
}

#include <iostream>

#include <iomanip>

using namespace std;

int main() {

cout << fixed << setprecision(2);

int n, m, tmp, sumGl, sumMin, sumMax, valMin, valMax, countMin, countMax;

cin >> n >> m;

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

sumGl = sumMin = sumMax = 0;

valMin = 11;

valMax = 0;

countMin = countMax = 0;

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

cin >> tmp;

sumGl += tmp;

if(tmp < valMin) {

sumMin = tmp;

valMin = tmp;

countMin = 1;

}

else if(tmp == valMin) {

sumMin += tmp;

countMin++;

}

if(tmp > valMax) {

sumMax = tmp;

valMax =tmp;

countMax = 1;

}

else if(tmp == valMax) {

sumMax += tmp;

countMax++;

}

cout << (sumGl - sumMax - sumMin) / (double)(n - countMax - countMin) << " ";

}

return 0;

}

Решение

Читая каждую оценку:

Добавляем оценку к общей сумме;
Если введенная оценка равна минимальной, то добавляем ее к сумме минимальных и увеличиваем счётчик количества минимальных.
Если введенная оценка меньше минимальной, то минимальной становится введённая оценка. Счетчик количества минимальных равен [latex]1.[/latex] Сумма минимальных равна введённой оценке.
Если введенная оценка равна максимальной, то добавляем ее к сумме максимальных и увеличиваем счётчик количества максимальных.
Если введенная оценка больше максимальной, то максимальной становится введённая оценка. Счетчик количества максимальных равен [latex]1.[/latex] Сумма максимальных равна введённой оценке.

Тогда после введения всех [latex]n[/latex] оценок имеем:

[latex]sumMax[/latex] — сумма максимальных оценок.
[latex]sumMin[/latex] — сумма минимальных оценок.
[latex]countMax[/latex] — количество максимальных оценок.
[latex]countMin[/latex] — количество минимальных оценок.
[latex]sumGl[/latex] — общая сумма оценок.

Для нахождения среднего арифметического значения оценок, соответствующего условию будем применять формулу: [latex]S_с = \frac{sumGL-sumMin-sumMax}{n-countMin-countMax}[/latex]

Код программы (Массивы)

#include <iostream> 
#include <iomanip> 
using namespace std; 
 
double res(int *arr, int len) {
    int min,max;
    min = arr[0];
    max = arr[0];
    for(int i = 1; i < len; i++) {
        if(arr[i] > max) {
            max = arr[i];
        }   
        if(arr[i]<min) {
            min = arr[i];
        }
    }
    int sum = 0;
    int count = 0;
    for(int i = 0; i < len; i++) {
        if(arr[i] != max && arr[i] != min) {
            sum += arr[i];
            count++;
        }
    }  
    return sum/((double)count);
 
} 
 
int main() {  
    int m, n;
    cin >> n >> m;
    cout << fixed << setprecision(2);
    for(int i = 0; i < m; i++) {
        int* arr = new int[n];
        for(int j = 0 ; j < n; j++) {
            cin >> arr[j];
        }
        cout << res(arr, n) << " ";
        delete[] arr;
    }
    return 0;
}

#include <iostream>

#include <iomanip>

using namespace std;

double res(int *arr, int len) {

int min,max;

min = arr[0];

max = arr[0];

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

if(arr[i] > max) {

max = arr[i];

}

if(arr[i]<min) {

min = arr[i];

}

int sum = 0;

int count = 0;

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

if(arr[i] != max && arr[i] != min) {

sum += arr[i];

count++;

}

return sum/((double)count);

}

int main() {

int m, n;

cin >> n >> m;

cout << fixed << setprecision(2);

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

int* arr = new int[n];

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

cin >> arr[j];

}

cout << res(arr, n) << " ";

delete[] arr;

}

return 0;

}

Решение

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

Ссылки

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

Код программы на ideone (Потоковая обработка)

Код программы на ideone (Массивы)

Related Images:

e-olymp 8361. Робот

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

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

Условие

Движение робота управляется программой. Программа состоит из следующих команд:

[latex]S[/latex] — сделать шаг вперед
[latex]L[/latex] — повернуться на [latex]90°[/latex] влево
[latex]R[/latex] — повернуться на [latex]90°[/latex]вправо

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

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

Одна строка из заглавных латинских букв [latex]S[/latex], [latex]L[/latex], [latex]R[/latex], описывающая программу для робота. Общее число команд в программе не превышает [latex]200[/latex], при этом команд [latex]S[/latex] — не более [latex]50[/latex].

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

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

Тесты

№	Inputs	Outputs
1	SSLSLSLSSRSRS	5
2	LSSSS	-1
3	LLSRSRSRSLLLLSSSSLRSRSSSRSRSRS	15
4	LLLLLLLL	-1
5	SRLSRLSLRSLRLSLSLSLSSSLRLSSLRSLRSRSRSRSLRLSRLLLLLSRLSRL	7

Код

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

struct point{
    int x, y;
    point(){
        x = 0;
        y = 0;
    }
    point(int x1,int y1){
        x=x1;
        y=y1;
    }
    bool isequal(point&a, point&b);
}my_point;
 
bool point::isequal(point&a, point&b){
    return a.x == b.x and a.y == b.y;
} 
 
int main() {
    int counter = 0, x = 0, y = 0, res = 0;
    point a;
    char c;
    bool stop = false;
    vector coor(1);
    while(cin >> c and stop == false){
        if(c == 'L'){
            counter = (counter + 1)%4;
        }
        else if(c == 'R'){
            counter = ((counter - 1) + 4)%4;
        }
        else{
            if(counter == 0){
                y++;
            }
            else if(counter == 1){
                x--;
            }
            else if(counter == 2){
                y--;
            }
            else{
                x++;
            }
            res++;
            point a(x,y);
            for(int j = 1; j < coor.size();j++){
                if(my_point.isequal(coor[j],a)){
                    stop = true;
                }
            }
            coor.push_back(a);
        }
    }
    cout << ((stop == true) ? res : -1);
    return 0;
}

#include <iostream>

#include <vector>

using namespace std;

struct point{

int x, y;

point(){

x = 0;

y = 0;

}

point(int x1,int y1){

x=x1;

y=y1;

}

bool isequal(point&a, point&b);

}my_point;

bool point::isequal(point&a, point&b){

return a.x == b.x and a.y == b.y;

}

int main() {

int counter = 0, x = 0, y = 0, res = 0;

point a;

char c;

bool stop = false;

vector coor(1);

while(cin >> c and stop == false){

if(c == 'L'){

counter = (counter + 1)%4;

}

else if(c == 'R'){

counter = ((counter - 1) + 4)%4;

}

else{

if(counter == 0){

y++;

}

else if(counter == 1){

x--;

}

else if(counter == 2){

y--;

}

else{

x++;

}

res++;

point a(x,y);

for(int j = 1; j < coor.size();j++){

if(my_point.isequal(coor[j],a)){

stop = true;

}

coor.push_back(a);

}

cout << ((stop == true) ? res : -1);

return 0;

}

Решение

Если представить, что точка старта движения робота имеет координаты [latex]\left(0;0 \right)[/latex], то, соответственно, при движении координата будет изменяться на 1 единицу за шаг. Всего координата может изменяться четырьмя способами: координата [latex]x[/latex] уменьшается на единицу, координата [latex]x[/latex] увеличивается на единицу, координата [latex]y[/latex] уменьшается на единицу, координата [latex]y[/latex] увеличивается на единицу. Тогда можно сделать вывод, что эти 4 состояния можно привязать к счетчику, который будет меняться при каждом повороте налево и направо. Для хранения координат как единого объекта можно создать структуру point. Также необходимо запоминать в массив координаты точки после передвижения вперед для того, чтобы в будущем проверять каждую точку на совпадение с предыдущими, чтобы знать когда прервать проверку строки. В главном цикле при встрече символа «[latex]S[/latex]» делаем проверку на состояние счетчика, чтобы увеличивать соответствующую координату. После изменения координаты необходимо проверить ее на совпадение с предыдущими, если она совпала, то назначаем переменной stop значение true для того, чтобы прервать цикл и вывести результат. Если координата не совпала, то добавляем ее в массив(если использовать vector, это делается с помощью команды push_back(), если обычный массив, то придется создать дополнительную переменную и увеличивать ее каждую встречу команды «[latex]S[/latex]»). Если в итоге робот не вернется в то место, где побывал, то переменная stop останется со значением false и выведется «[latex]-1[/latex]».

Ссылки

Related Images:

e-olymp 458. Черно-белая графика

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

Задача

Одна из базовых задач компьютерной графики – обработка черно-белых изображений. Изображения можно представить в виде прямоугольников шириной $w$ и высотой $h,$ разбитых на $w × h$ единичных квадратов, каждый из которых имеет либо белый, либо черный цвет. Такие единичные квадраты называются пикселами. В памяти компьютера сами изображения хранятся в виде прямоугольных таблиц, содержащих нули и единицы.

Во многих областях очень часто возникает задача комбинации изображений. Одним из простейших методов комбинации, который используется при работе с черно-белыми изображениями, является попиксельное применение некоторой логической операции. Это означает, что значение пиксела результата получается применением этой логической операции к соответствующим пикселам аргументов. Логическая операция от двух аргументов обычно задается таблицей истинности, которая содержит значения операции для всех возможных комбинаций аргументов. Например, для операции «ИЛИ» эта таблица выглядит так.

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

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

Первая строка содержит два целых числа $w$ и $h$ $(1 \leq w, h \leq 100).$ Последующие $h$ строк описывают первое изображение и каждая из этих строк содержит $w$ символов, каждый из которых равен нулю или единице. Далее следует описание второго изображения в аналогичном формате. Последняя строка содержит описание логической операции в виде четырех чисел, каждое из которых – ноль или единица. Первое из них есть результат применения логической операции в случае, если оба аргумента нули, второе – результат в случае, если первый аргумент ноль, второй единица, третье – результат в случае если первый аргумент единица, второй ноль, а четвертый – в случае, если оба аргумента единицы.

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

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

Тесты

	Входные данные	Выходные данные
1	5 3 01000 11110 01000 10110 00010 10110 0110	11110 11100 11110
2	2 3 010 111 000 101 1010	11 10 10
3	4 4 1111 0101 0000 1110 0011 0101 0111 1111 0011	1111 0101 0000 1110
4	3 6 100011 000111 000000 111011 001100 010101 1000	000 100 110 000 101 010

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

( использован одномерный массив)

#include <iostream>
using namespace std;

bool my_operation (bool a, bool b, bool* res) {
    if (!a and !b) return res[0];
    else if (!a and b) return res[1];
    else if (a and !b) return res[2];
    else return res[3];
}

int main() {
    int w, h, n;
    bool truth_t[4];
    cin >> w >> h;
    n = w * h;
    bool *first_t = new bool [n];
    bool *second_t = new bool [n];
    char c;
    for (int i = 0; i < n; i++) {
        cin >> c;
        first_t[i] = (c == '1' ? true : false);
    }
    for (int i = 0; i < n; i++) {
        cin >> c;
        second_t[i] = (c == '1' ? true : false);
    }
    for (int i = 0; i < 4; i++) {
        cin >> c;
        truth_t[i] = (c == '1' ? true : false);
    }
    for (int i = 0; i < n; i++) {
        if (i != 0 && i % w == 0)
        cout << endl;
        cout << my_operation(first_t[i], second_t[i], truth_t);
    }
    return 0;
}

#include <iostream>

using namespace std;

bool my_operation (bool a, bool b, bool* res) {

if (!a and !b) return res[0];

else if (!a and b) return res[1];

else if (a and !b) return res[2];

else return res[3];

}

int main() {

int w, h, n;

bool truth_t[4];

cin >> w >> h;

n = w * h;

bool *first_t = new bool [n];

bool *second_t = new bool [n];

char c;

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

cin >> c;

first_t[i] = (c == '1' ? true : false);

}

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

cin >> c;

second_t[i] = (c == '1' ? true : false);

}

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

cin >> c;

truth_t[i] = (c == '1' ? true : false);

}

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

if (i != 0 && i % w == 0)

cout << endl;

cout << my_operation(first_t[i], second_t[i], truth_t);

}

return 0;

}

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

(использован двумерный массив)

#include <iostream>
using namespace std;

bool my_operation (bool a, bool b, bool* res) {
    if (!a and !b) return res[0];
    else if (!a and b) return res[1];
    else if (a and !b) return res[2];
    else return res[3];
}

int main() {
    int w, h;
    bool truth_t[4];
    cin >> w >> h;
    bool **first_t = new bool *[h];
    bool **second_t = new bool *[h];
    for (int i = 0; i < h; i++) {
        first_t[i] = new bool [w];
        second_t[i] = new bool [w];
    }
    char c;
    for (int i = 0; i < h; i++){
        for (int j = 0; j < w; j++) {
            cin >> c;
            first_t[i][j] = (c == '1' ? true : false);
        }
    }
    for (int i = 0; i < h; i++){ 
        for (int j = 0; j < w; j++) {
            cin >> c;
            second_t[i][j] = (c == '1' ? true : false);
        }
    }
    for (int i = 0; i < 4; i++) {
        cin >> c;
        truth_t[i] = (c == '1' ? true : false);
    }
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            cout << my_operation(first_t[i][j], second_t[i][j], truth_t);
        }
        if (i < h - 1) cout << endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

bool my_operation (bool a, bool b, bool* res) {

if (!a and !b) return res[0];

else if (!a and b) return res[1];

else if (a and !b) return res[2];

else return res[3];

}

int main() {

int w, h;

bool truth_t[4];

cin >> w >> h;

bool **first_t = new bool *[h];

bool **second_t = new bool *[h];

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

first_t[i] = new bool [w];

second_t[i] = new bool [w];

}

char c;

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

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

cin >> c;

first_t[i][j] = (c == '1' ? true : false);

}

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

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

cin >> c;

second_t[i][j] = (c == '1' ? true : false);

}

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

cin >> c;

truth_t[i] = (c == '1' ? true : false);

}

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

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

cout << my_operation(first_t[i][j], second_t[i][j], truth_t);

}

if (i < h - 1) cout << endl;

}

return 0;

}

Решение

Объявляем два булевых динамических массива под две пиксельные таблицы и один статический для таблицы истинности, вводим входные данные. Затем поочерёдно сравниваем соответствующие элементы массивов с помощью функции my_operation, которая принимает две переменные a и b булевского типа и булев массив res с таблицей истинности, и возвращает соответствующее значение из таблицы для комбинации значений a и b. Результат сравнения выводим.

Ссылки

Одномерный массив
- ideone.com
- e-olymp.com
Двумерный массив
- ideone.com
- e-olymp.com

Related Images:

e-olymp 5090. На перекрёстке

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

Задача

Есть таблица $n × n.$ Оживленностью строки или столбца назовем сумму чисел в ней. Нам очень хочется определить число на перекрестке самой оживленной строки и самого неоживленного столбца. Причем, чем выше будет этот перекресток (а среди них – чем левее), тем больше будет вероятность прохождения теста.

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

В первой строке находится число $n (1 \leq n \leq 100).$ В следующих $n$ строчках задана таблица. Числа в таблице натуральные и не превышают $100000.$

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

Выведите число на перекрестке самой оживленной строки и самого неоживленного столбца.

Тесты

	Входные данные	Выходные данные
1	2 4 3 2 1	3
2	3 1 1 1 1 1 1 1 1 1	1
3	5 13 15 17 2 9 4 56 8 90 0 4 3 5 7 5 23 4 5 71 4 5 6 7 8 10	0
4	4 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1	1

Код

С помощью одномерного массива

#include <iostream>
using namespace std;
 
int main() {
    int n, ns;
    cin >> n;
    ns = n*n;
    int *x = new int[ns];
    for (int i = 0; i < ns; i++)
        cin >> x[i];
    int I, J, min, max;
    for (int i = 0; i < ns; i += n) {
        int lmax = 0;
        for (int j = 0; j < n; j++)
            lmax += x[i + j];
        if (lmax > max || i == 0) {
            max = lmax;
            I = i;
        }
    }
    for (int j = 0; j < n; j++) {
        int lmin = 0;
        for (int i = 0; i < ns; i += n)
            lmin += x[i + j];
        if (lmin < min || j == 0) {
            min = lmin;
            J = j;
        }
    }
    cout << x[I + J];
    delete []x;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n, ns;

cin >> n;

ns = n*n;

int *x = new int[ns];

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

cin >> x[i];

int I, J, min, max;

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

int lmax = 0;

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

lmax += x[i + j];

if (lmax > max || i == 0) {

max = lmax;

I = i;

}

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

int lmin = 0;

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

lmin += x[i + j];

if (lmin < min || j == 0) {

min = lmin;

J = j;

}

cout << x[I + J];

delete []x;

return 0;

}

С помощью двумерного массива

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int **x = new int*[n];
    for (int i = 0; i < n; i++) 
        x[i] = new int [n];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) 
            cin >> x[i][j];
    int I, J, min, max;
    for (int i = 0; i < n; i++) {
        int lmax = 0;
        for (int j = 0; j < n; j++)
            lmax += x[i][j];
        if (lmax > max || i == 0) {
           max = lmax;
           I = i;
        }
    }
    for (int j = 0; j < n; j++) {
        int lmin = 0;
        for (int i = 0; i < n; i++)
            lmin += x[i][j];
        if (lmin < min || j == 0) {
            min = lmin;
            J = j;
        }
    }
    cout << x[I][J];
    for (int i = 0; i < n; i++)
        delete []x[i];
        delete []x;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

cin >> n;

int **x = new int*[n];

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

x[i] = new int [n];

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

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

cin >> x[i][j];

int I, J, min, max;

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

int lmax = 0;

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

lmax += x[i][j];

if (lmax > max || i == 0) {

max = lmax;

I = i;

}

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

int lmin = 0;

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

lmin += x[i][j];

if (lmin < min || j == 0) {

min = lmin;

J = j;

}

cout << x[I][J];

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

delete []x[i];

delete []x;

return 0;

}

Решение

Для решения данной задачи используем двумерный массив размера $n \times n$. С помощью цикла for ищем самую оживленную строку, затем самый неоживленный столбец, и выводим элемент таблицы на их перекрёстке.
Для решения с помощью одномерного массива действуем аналогично, работая с массивом длинны $n^2$, используя следующее соответствие: $x[i][j] \sim x[i \cdot n + j]$

Ссылки

С помощью одномерного массива
- e-olymp
- ideone
С помощью двумерного массива
- ideone
- e-olymp

Related Images:

e-olymp 113. Шарики

24/12/2018 by Богдан Павлов

Задача

У продавца воздушных шариков есть [latex]n[/latex] шаров. Каждый из них имеет некоторый цвет. Однако совсем недавно Три Толстяка издали указ, разрешающий торговать шариками какого-то одного цвета. Чтобы не нарушать закон, но при этом и не потерять прибыль, продавец решил перекрасить некоторые из своих шариков.

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

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

В первой строке задано количество шаров [latex]n (1\leqslant n \leqslant 100000)[/latex]. Вторая строка состоит из [latex]n[/latex] целых чисел, в пределах от 1 до 9, определяющие цвета шаров (1 — синий, 2 — зеленый, 3 — голубой, 4 — красный, 5 — розовый, 6 — желтый, 7 — серый, 8 — черный, 9 — белый).

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

Выведите минимальное количество шариков, которое необходимо перекрасить, чтобы все шарики были одного цвета.

Тесты

#	ВХОДНЫЕ ДАННЫЕ	ВЫХОДНЫЕ ДАННЫЕ
1	4 3 1 2 1	2
2	1 1	0
3	6 1 1 1 2 2 2	3
4	3 1 2 3	2
5	4 3 3 3 8	1

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

#include <iostream>
using namespace std;
int n,tmp,cl1,cl2,cl3,cl4,cl5,cl6,cl7,cl8,cl9;
int main(){
    cin >> n;
    for(auto i = 0; i < n; ++i){
        cin >> tmp;
        (tmp==1) ? ++cl1 : (tmp==2) ? ++cl2 : (tmp==3) ? ++cl3 : (tmp==4) ? ++cl4 : (tmp==5) ? ++cl5 : (tmp==6) ? ++cl6 : (tmp==7) ? ++cl7 : (tmp==8) ? ++cl8 : ++cl9;
    }
    cout << n-max(cl1,max(cl2,max(cl3,max(cl4,max(cl5,max(cl6,max(cl7,max(cl8,cl9))))))));
}

#include <iostream>

using namespace std;

int n,tmp,cl1,cl2,cl3,cl4,cl5,cl6,cl7,cl8,cl9;

int main(){

cin >> n;

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

cin >> tmp;

(tmp==1) ? ++cl1 : (tmp==2) ? ++cl2 : (tmp==3) ? ++cl3 : (tmp==4) ? ++cl4 : (tmp==5) ? ++cl5 : (tmp==6) ? ++cl6 : (tmp==7) ? ++cl7 : (tmp==8) ? ++cl8 : ++cl9;

}

cout << n-max(cl1,max(cl2,max(cl3,max(cl4,max(cl5,max(cl6,max(cl7,max(cl8,cl9))))))));

}

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

Для того, чтобы найти количество шариков, которые необходимо перекрасить, нужно узнать максимальное количество шариков одного цвета и из общего количества шариков n вычесть найденный максимум. Для нахождения максимума считываем номер цвета шара в цикле и увеличиваем соответствующую переменную cl на единицу. По окончанию цикла ищем максимальное количество шаров одного цвета и выводим n-max.

Ссылки

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 5282. Седловые точки

22/12/2018 by Иван Киреев

Задача. Седловые точки

Задана матрица $K$, содержащая $n$ строк и $m$ столбцов. Седловой точкой этой матрицы назовем элемент, который одновременно является минимумом в своей строке и максимумом в своем столбце.
Найдите количество седловых точек заданной матрицы.

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

Первая строка содержит целые числа $n$ и $m$. $(1 \leq n, m \leq 750)$. Далее следуют $n$ строк по $m$ чисел в каждой. $j$-ое число $i$-ой строки равно $k_{ij}$. Все $k_{ij}$ по модулю не превосходят $1000$.

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

Выведите количество седловых точек.

Тесты

№	Ввод	Вывод
1	2 2 0 0 0 0	4
2	2 2 1 2 3 4	1
3	5 5 100 -100 100 1000 110 10 -1000 100 -1000 110 100 -1000 100 100 110 1000 -1000 1000 1000 100 1000 -1000 1000 1000 -1000	1
4	4 4 1000 1000 100 100 1000 1000 1000 1000 100 100 100 1000 100 1000 1000 1000	4
5	2 3 1 -1 1 0 -1 0	2
6	5 1 -1 0 -1 0 -1	2
7	4 2 1 2 -2 1 -1 2 -2 -1	1
8	3 3 5 1 3 3 1 2 1 1 2	3
7	3 3 5 2 3 3 4 2 1 8 2	0

Решение

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

Вариант решения за $O\left(n^2\right)$

Для этого мы просто сравниваем каждый максимум с каждым минимумом и считаем их совпадения. В этом случае алгоритм будет выполнятся за $O(n^2)$, где $n$ это наибольшая из длин массивов. Это значит что при достаточно больших массивах программа будет работать непозволительно долго. Но такой подход достаточно прост в реализации и интуитивно понятен.

#include <iostream>
#define N 750
using namespace std;
 
int main() {
    int n, m, MIN[N], MAX[N];
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int input;
            cin >> input;
            if (i == 0) MAX[j] = input;
            else if (MAX[j] < input) MAX[j] = input;
            if (j == 0) MIN[i] = input;
            else if (MIN[i] > input) MIN[i] = input;
        }
    }
    int count = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (MIN[i] == MAX[j]) count++;
    cout << count;
    return 0;
}

#include <iostream>

#define N 750

using namespace std;

int main() {

int n, m, MIN[N], MAX[N];

cin >> n >> m;

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

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

int input;

cin >> input;

if (i == 0) MAX[j] = input;

else if (MAX[j] < input) MAX[j] = input;

if (j == 0) MIN[i] = input;

else if (MIN[i] > input) MIN[i] = input;

}

int count = 0;

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

for (int j = 0; j < m; j++)

if (MIN[i] == MAX[j]) count++;

cout << count;

return 0;

}

Вариант решения за $O\left(n\log n\right)$

В этом случае мы сортируем массивы, для установления взаимосвязи между элементами в них. А далее заведя два указателя на элементы массивов проверяем на равенство только не меньшие элементы от текущих в разных массивах. Если равных элементов окажется несколько подряд, то их количество будет равно произведению количества их повторений в каждом из массивов. Дойдя до конца одного из них нужно не забыть проверить остались ли в другом массиве равные последнему в пройденном элементы. Проверять стоит лишь не меньшие элементы. Таким алгоритмом мы проверяем совпадения линейно за $O(n)$, где $n$ это наибольшая из длин массивов, но для него необходимо отсортировать оба массива за $O(n\log n)$. Таким образом мы получаем вычислительную сложность $O(n\log n)$, что уже быстрее предыдущего варианта.

#include <iostream>
#define N 750
using namespace std;
 
void merge_sort(int *arr, int n) {
    if (n == 1) return;
    int len_l = n / 2, len_r = n - len_l;
    int l[len_l], r[len_r];
    for (int i = 0; i < n; i++)
        if (i < len_l) l[i] = arr[i];
        else r[i - len_l] = arr[i];
    merge_sort(l, len_l);
    merge_sort(r, len_r);
    int i = 0, j = 0;
    while (i < len_l && j < len_r)
        if (l[i] < r[j]) arr[i + j] = l[i++];
        else arr[i + j] = r[j++];
    while (i < len_l) arr[i + j] = l[i++];
    while (j < len_r) arr[i + j] = r[j++];
}
 
int main() {
    int n, m, MIN[N], MAX[N];
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int input;
            cin >> input;
            if (i == 0) MAX[j] = input;
            else if (MAX[j] < input) MAX[j] = input;
            if (j == 0) MIN[i] = input;
            else if (MIN[i] > input) MIN[i] = input;
        }
    }
    merge_sort(MAX, m);
    merge_sort(MIN, n);
    int i = 0, j = 0, count_i = 1, count_j = 1, counter = 0;
    while (i < n && j < m) {
        while (i < n-1 && MIN[i] == MIN[i+1]) {
            count_i++;
            i++;
        } 
        while (j < m-1 && MAX[j] == MAX[j+1]) {
            count_j++;
            j++;
        }
        if (MIN[i] < MAX[j]) {
            i++;
            count_i = 1;
        } else if (MIN[i] > MAX[j]) {
            j++;
            count_j = 1;
        } else {
            counter += count_i * count_j;
            i++;
            j++;
            count_i = 1;
            count_j = 1;
        }
    }
    while (i < n && MIN[i] <= MAX[m-1]) {
        while (i < n-1 && MIN[i] == MIN[i+1]) {
            count_i++;
            i++;
        } 
        if (MIN[i] == MAX[m-1]) {
            i++;
            counter += count_i;
            count_i = 1;
        }
 
    }
    while (j < m && MAX[j] <= MIN[n-1]) {
        while (j < m-1 && MAX[j] == MAX[j+1]) {
            count_j++;
            j++;
        } 
        if (MAX[j] == MIN[n-1]) {
            j++;
            counter += count_j;
            count_j = 1;
        }
 
    }
    cout << counter;
    return 0;
}

#include <iostream>

#define N 750

using namespace std;

void merge_sort(int *arr, int n) {

if (n == 1) return;

int len_l = n / 2, len_r = n - len_l;

int l[len_l], r[len_r];

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

if (i < len_l) l[i] = arr[i];

else r[i - len_l] = arr[i];

merge_sort(l, len_l);

merge_sort(r, len_r);

int i = 0, j = 0;

while (i < len_l && j < len_r)

if (l[i] < r[j]) arr[i + j] = l[i++];

else arr[i + j] = r[j++];

while (i < len_l) arr[i + j] = l[i++];

while (j < len_r) arr[i + j] = r[j++];

}

int main() {

int n, m, MIN[N], MAX[N];

cin >> n >> m;

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

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

int input;

cin >> input;

if (i == 0) MAX[j] = input;

else if (MAX[j] < input) MAX[j] = input;

if (j == 0) MIN[i] = input;

else if (MIN[i] > input) MIN[i] = input;

}

merge_sort(MAX, m);

merge_sort(MIN, n);

int i = 0, j = 0, count_i = 1, count_j = 1, counter = 0;

while (i < n && j < m) {

while (i < n-1 && MIN[i] == MIN[i+1]) {

count_i++;

i++;

}

while (j < m-1 && MAX[j] == MAX[j+1]) {

count_j++;

j++;

}

if (MIN[i] < MAX[j]) {

i++;

count_i = 1;

} else if (MIN[i] > MAX[j]) {

j++;

count_j = 1;

} else {

counter += count_i * count_j;

i++;

j++;

count_i = 1;

count_j = 1;

}

while (i < n && MIN[i] <= MAX[m-1]) {

while (i < n-1 && MIN[i] == MIN[i+1]) {

count_i++;

i++;

}

if (MIN[i] == MAX[m-1]) {

i++;

counter += count_i;

count_i = 1;

}

while (j < m && MAX[j] <= MIN[n-1]) {

while (j < m-1 && MAX[j] == MAX[j+1]) {

count_j++;

j++;

}

if (MAX[j] == MIN[n-1]) {

j++;

counter += count_j;

count_j = 1;

}

cout << counter;

return 0;

}

Related Images:

e-olymp 8515. Homo or Hetero?

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

Task

Consider a list of numbers with two operations:
$\cdot$ insert number— adds the specified number to the end of the list.
$\cdot$ delete number— removes the first occurrence of the specified number from the list. If the list does not contain the number specified, no changes are performed.

For example: the result of the insertion of a number $4$ to the list $[1,2,1]$ is the list $[1,2,1,4]$. If we delete the number $1$ from this list, we get the list $[2,1,4]$, but if we delete the number $3$ from the list $[1,2,1,4]$,the list stays unchanged.

The list is homogeneous if it contains at least two equal numbers and the list is heterogeneous if it contains at least two different numbers. For example: the list $[2,2]$ is homogeneous, the list $[2,1,4]$ is heterogeneous, the list $[1,2,1,4]$ is both, and the empty list is neither homogeneous, nor heterogeneous.

Write a program that handles a number of the operations insert and delete on the empty list and determines list’s homogeneity and heterogeneity after each operation.

Input

The first line of the input file contains an integer number $N$ $(1 \leq N \leq 10^{5})$ — the number of operations to handle. Following $N$ lines contain one operation description each. The operation description consists of a word “insert” or “delete”, followed by an integer number $K$ $(-10^{9} \leq K \leq 10^{9})$ — the operation argument.

Output

For each operation output a line, containing a single word, describing the state of the list after the operation:

$\cdot$ “both” — if the list is both homogeneous and heterogeneous.
$\cdot$ “homo” — if the list is homogeneous, but not heterogeneous.
$\cdot$ “hetero” — if the list is heterogeneous, but not homogeneous.
$\cdot$ “neither” — if the list is neither homogeneous nor heterogeneous.

Tests

#	Input	Output
1	11 $insert$ 1 $insert$ 2 $insert$ 1 $insert$ 4 $delete$ 1 $delete$ 3 $delete$ 2 $delete$ 1 $insert$ 4 $delete$ 4 $delete$ 4	$neither$ $hetero$ $both$ $both$ $hetero$ $hetero$ $hetero$ $neither$ $homo$ $neither$ $neither$
2	15 $insert$ -50 $insert$ -2 $insert$ 1 $insert$ 4 $delete$ 1 $delete$ 3 $delete$ -2 $delete$ -50 $insert$ 4 $delete$ 4 $delete$ 4 $insert$ 100 $insert$ -150 $delete$ -150 $delete$ 100	$neither$ $hetero$ $hetero$ $hetero$ $hetero$ $hetero$ $hetero$ $neither$ $homo$ $neither$ $neither$ $neither$ $hetero$ $neither$ $neither$

Code 1

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

struct Key {
    int a;
    int b;
};
Key x[200000];

int main() {
    int n,k,i,i1,j1=0,j2=0,p,p1=0,p2=0,q,l,m,r;
    char s[10];
    cin >> n;
    char y[n]; int z[n]; int u[n];
    for (i=0; i<n; i++) {
        cin >> s >> k;
        y[i]=s[0]; z[i]=k;
        if (s[0]=='i') {
            u[j1]=k; j1++;
        }
    }
    sort(u,u+j1);
    for (i=0; i<j1; i++) {
        if (u[i]!=u[i+1]) {
            x[j2].a=u[i]; j2++;
        }
    }
    for (i=0; i<n; i++) {
        p=0; l=0; r=j2-1;
        while (l<=r && p==0) {
            m=(l+r)/2;
            if (z[i]==x[m].a) {
                i1=m; p=1;
            } else if (z[i]<x[m].a) r=m-1;
            else l=m+1;
        }
        if (p==1) {
            q=x[i1].b;
            if (y[i]=='i') {
                q++;
                if (q==1) p1++;
                if (q==2) p2++;
                x[i1].b=q;
            } else if (q>0) {
                q--;
                if (q==0) p1--;
                if (q==1) p2--;
                x[i1].b=q;
            }
        }
        if (p1>=2 && p2>=1) cout << "both" << endl;
        else if (p1<2 && p2>=1) cout << "homo" << endl;
        else if (p1>=2 && p2<1) cout << "hetero" << endl;
        else cout << "neither" << endl;
    }
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

struct Key {

int a;

int b;

};

Key x[200000];

int main() {

int n,k,i,i1,j1=0,j2=0,p,p1=0,p2=0,q,l,m,r;

char s[10];

cin >> n;

char y[n]; int z[n]; int u[n];

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

cin >> s >> k;

y[i]=s[0]; z[i]=k;

if (s[0]=='i') {

u[j1]=k; j1++;

}

sort(u,u+j1);

for (i=0; i<j1; i++) {

if (u[i]!=u[i+1]) {

x[j2].a=u[i]; j2++;

}

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

p=0; l=0; r=j2-1;

while (l<=r && p==0) {

m=(l+r)/2;

if (z[i]==x[m].a) {

i1=m; p=1;

} else if (z[i]<x[m].a) r=m-1;

else l=m+1;

}

if (p==1) {

q=x[i1].b;

if (y[i]=='i') {

q++;

if (q==1) p1++;

if (q==2) p2++;

x[i1].b=q;

} else if (q>0) {

q--;

if (q==0) p1--;

if (q==1) p2--;

x[i1].b=q;

}

if (p1>=2 && p2>=1) cout << "both" << endl;

else if (p1<2 && p2>=1) cout << "homo" << endl;

else if (p1>=2 && p2<1) cout << "hetero" << endl;

else cout << "neither" << endl;

}

return 0;

}

Code 2 (map)

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

int main() {
    int n,k,p1=0,p2=0,q;
    char s[10];
    map <int,int> x;
    cin >> n;
    for (int i=0; i<n; i++) {
        cin >> s >> k;
        q=x[k];
        if (s[0]=='i') {
            q++;
            if (q==1) p1++;
            if (q==2) p2++;
            x[k]=q;
        } else if (q>0) {
            q--;
            if (q==0) p1--;
            if (q==1) p2--;
            x[k]=q;
        }
        if (p1>=2 && p2>=1) cout << "both" << endl;
        else if (p1<2 && p2>=1) cout << "homo" << endl;
        else if (p1>=2 && p2<1) cout << "hetero" << endl;
        else cout << "neither" << endl;
    }
    return 0;
}

#include <iostream>

#include <map>

using namespace std;

int main() {

int n,k,p1=0,p2=0,q;

char s[10];

map <int,int> x;

cin >> n;

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

cin >> s >> k;

q=x[k];

if (s[0]=='i') {

q++;

if (q==1) p1++;

if (q==2) p2++;

x[k]=q;

} else if (q>0) {

q--;

if (q==0) p1--;

if (q==1) p2--;

x[k]=q;

}

if (p1>=2 && p2>=1) cout << "both" << endl;

else if (p1<2 && p2>=1) cout << "homo" << endl;

else if (p1>=2 && p2<1) cout << "hetero" << endl;

else cout << "neither" << endl;

}

return 0;

}

Solution

Let’s memorize two numbers on each step: how many of different numbers and different pairs of identical numbers in a one-dimensional array. If there are more than one different numbers in the array and more than zero different pairs of the same numbers, then print "both". If the sum of different numbers in the array is less than two and different pairs of identical numbers are more than zero, then we enter "homo". If there are more than one different numbers in the array and less than one different pairs of the same numbers, then enter "hetero". In other cases, we enter "neither". In the last case, when an array is $0$ numbers or $1$ number.

Links

Related Images:

e-olymp 8374. Нечетное количество раз

09/12/2018 by Инна Литвиненко

Задача

Найдите число, которое встречается в последовательности нечетное количество раз.

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

Первая строка содержит натуральное число $n (n < 500000)$. Далее следуют $n$ натуральных чисел, каждое из которых меньше $10^6$.

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

Во входной последовательности только одно число $x$ повторяется нечетное количество раз. Другие числа повторяются четное число раз. Выведите $x$.

Замечание

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

Тесты

№	Ввод	Вывод
1	9 3 1 2 2 17 1 3 17 3	3
2	5 12 13 14 13 12	14
3	3 20 0 20	0
4	15 5 7 1 2 3 5 7 2 7 5 1 2 3 5 2	7
5	11 10 100 1000 100 100 100 1000 10 100 1000 100	1000

Код 1

#include <iostream>
#include <algorithm>
using namespace std;
 
int main() {
    long long n, *x;
    cin >> n;
    x = new long long[n];
    for (int i = 0; i < n; i++)
        cin >> x[i];
    sort(x, x + n);
    long long k, y;
    k = 1;
    y = x[0];
    for (int i = 1; i < n; i++) {
        if (x[i] == y)
            k++;
        else {
            if (k % 2 != 0) {
                cout << y;
                return 0;
            }
            else {
                k = 1;
                y = x[i];
            }
        }
    }
    cout << x[n - 1];
    delete []x;
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

int main() {

long long n, *x;

cin >> n;

x = new long long[n];

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

cin >> x[i];

sort(x, x + n);

long long k, y;

k = 1;

y = x[0];

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

if (x[i] == y)

k++;

else {

if (k % 2 != 0) {

cout << y;

return 0;

}

else {

k = 1;

y = x[i];

}

cout << x[n - 1];

delete []x;

return 0;

}

Код 2

#include <iostream>
using namespace std;
 
int main() {
    long long n, *x;
    cin >> n;
    x = new long long[n];
    for (int i = 0; i < n; i++)
        cin >> x[i];
    long res = 0;
    for (int i = 0; i < n; i++)
		res ^= x[i];
    cout << res;
    delete []x;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

long long n, *x;

cin >> n;

x = new long long[n];

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

cin >> x[i];

long res = 0;

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

res ^= x[i];

cout << res;

delete []x;

return 0;

}

Код 3 (без массива)

#include <iostream>
using namespace std;

int main() {
	long long n, res = 0, x;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> x;
		res ^= x;
	}
	cout << res;
	return 0;
}

#include <iostream>

using namespace std;

int main() {

long long n, res = 0, x;

cin >> n;

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

cin >> x;

res ^= x;

}

cout << res;

return 0;

}

Решение

Для начала создадим динамический одномерный массив и считаем с потока ввода все его элементы. Конечно, можно было создать статический массив на 500000 элементов, но, скорее всего, памяти выделилось бы намного больше, чем было бы использовано.

Первый способ

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

Затем, заведём две переменные: счётчик и число. Последней присваиваем значение первого элемента массива. Сравниваем следующий элемент с тем, что лежит в переменной. Если они равны, увеличиваем счетчик. В счетчик с самого начала положим единицу, так как предполагаем, что в массиве есть хоть один элемент.

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

Второй способ

Применим исключающее «или» ко всем элементам массива. Предварительно создадим переменную равную нулю, в которой будем это проделывать.

Так как xor двух одинаковых чисел равен нулю, то для любого количества пар одинаковых чисел он будет равен нулю. А вот xor нуля и любого числа равен самому числу.

Таким образом, исключив все пары одинаковых чисел, наша переменная примет значение повторяющегося нечетное количество раз числа.

Третий способ

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

Ссылки

Задача 8374 на e-olymp

Код 1 на Ideone

Код 2 на Ideone

Код 3 на Ideone

Related Images:

e-olymp 8357. Точка в многоугольнике

05/12/2018 by Владислав Шеванов

Задача

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

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

В первой строке заданы три числа: [latex]n (3 \le n \le 10^5)[/latex] и координаты точки. Далее в $n$ строках заданы по паре чисел — координаты очередной вершины простого многоугольника в порядке обхода по или против часовой стрелки.

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

Вывести строку «YES», если заданная точка содержится в приведённом многоугольнике или на его границе, и «NO» в противном случае.

Тесты

Входные данные	Выходные данные
3 0 0 1 0 0 1 1 1	NO
4 3 2 0 0 1 5 5 5 6 0	YES
3 5 6 2 3 8 0 -1 -3	NO
4 -2 3 0 0 5 0 0 6 3 3	NO
5 3 1 9 2 3 0 -2 -4 -4 0 -4 5	YES

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

#include <iostream>
using namespace std;

struct point {
    int x;
    int y;
};

int f (point *p, int N, int x, int y) {
    int i1, i2, n, S, S1, S2, S3, flag;
    for (n = 0; n < N; n++) {
        flag = 0;
        i1 = n < N-1 ? n + 1 : 0;
        while (flag == 0) {
            i2 = i1 + 1;
            if (i2 >= N)
                i2 = 0;
            if (i2 == (n < N-1 ? n + 1 : 0))
                break;
            S = abs (p[i1].x * (p[i2].y - p[n].y) +
                p[i2].x * (p[n].y - p[i1].y) +
                p[n].x  * (p[i1].y - p[i2].y));
            S1 = abs (p[i1].x * (p[i2].y - y) +
                p[i2].x * (y - p[i1].y) +
                x * (p[i1].y - p[i2].y));
            S2 = abs (p[n ].x * (p[i2].y - y) +
                p[i2].x * (y - p[n].y) +
                x * (p[n].y - p[i2].y));
            S3 = abs (p[i1].x * (p[n].y - y) +
                p[n].x * (y - p[i1].y) +
                x * (p[i1].y - p[n].y));
            if (S == S1 + S2 + S3) {
                flag = 1;
                break;
            }
            i1++;
            if (i1 >= N)
                i1 = 0;
            }
        if (flag == 0)
            break;
    }
    return flag;
}

int main() {
    int n, x, y;
    cin >> n >> x >> y;
    point* p = new point[n];
    for (int i = 0; i < n; i++)
        cin >> p[i].x >> p[i].y;
    cout << (f(p, n, x, y) ? "YES" : "NO");
    return 0;
}

#include <iostream>

using namespace std;

struct point {

int x;

int y;

};

int f (point *p, int N, int x, int y) {

int i1, i2, n, S, S1, S2, S3, flag;

for (n = 0; n < N; n++) {

flag = 0;

i1 = n < N-1 ? n + 1 : 0;

while (flag == 0) {

i2 = i1 + 1;

if (i2 >= N)

i2 = 0;

if (i2 == (n < N-1 ? n + 1 : 0))

break;

S = abs (p[i1].x * (p[i2].y - p[n].y) +

p[i2].x * (p[n].y - p[i1].y) +

p[n].x * (p[i1].y - p[i2].y));

S1 = abs (p[i1].x * (p[i2].y - y) +

p[i2].x * (y - p[i1].y) +

x * (p[i1].y - p[i2].y));

S2 = abs (p[n ].x * (p[i2].y - y) +

p[i2].x * (y - p[n].y) +

x * (p[n].y - p[i2].y));

S3 = abs (p[i1].x * (p[n].y - y) +

p[n].x * (y - p[i1].y) +

x * (p[i1].y - p[n].y));

if (S == S1 + S2 + S3) {

flag = 1;

break;

}

i1++;

if (i1 >= N)

i1 = 0;

}

if (flag == 0)

break;

}

return flag;

}

int main() {

int n, x, y;

cin >> n >> x >> y;

point* p = new point[n];

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

cin >> p[i].x >> p[i].y;

cout << (f(p, n, x, y) ? "YES" : "NO");

return 0;

}

Решение

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

Ссылки

Related Images:

e-olymp 8529. Преобразование Капрекара

29/11/2018 by Кирилл Веремйов

Задача

Индийский математик Д. Р. Капрекар известен своими работами по теории чисел. Одна из его работ посвящена так называемому преобразованию Капрекара. Рассмотрим следующую операцию. Пусть задано число $x$. Пусть $M$ — наибольшее число, которое можно получить из $x$ перестановкой его цифр, а $m$ — наименьшее число (это число может содержать ведущие нули). Обозначим как $K(x)$ разность $M$ — $m$, дополненную при необходимости ведущими нулями так, чтобы число цифр в ней было равно числу цифр в $x$.

Например $K(100) = 100 — 001 = 099$, $K(2414) = 4421 — 1244 = 3177$.

Капрекар доказал, что если начать с некоторого четырехзначного числа $x$, в котором не все цифры равны между собой, и последовательно применять к нему эту операцию (вычислять $K(x)$, $K(K(x))$, . . . ), то рано или поздно получится число $6174$. Для него верно равенство $K(6174) = 7641 — 1467 = 6174$, поэтому на нем процесс зациклится.

Ваша задача состоит в том, чтобы написать программу, вычисляющую $K(x)$ по числу $x.$

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

Одно целое число без ведущих нулей $x$ ($1$ ≤ $x$ ≤ $10^9$).

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

Выведите $K(x)$.

Тесты

Входные данные	Выходные данные
100	099
1000000000	0999999999
2414	3177
6174	6174
5	0
7272	5445
142857	750843
495	495
55	00
56	09
554	099
12345	41976

Решение

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

int main() {
	long long x, K = 0, xm = 0, xM = 0;
	//Вводимое число, искомое число, максимальное и минимальное из комбинации цифр
	cin >> x;
	int N[11];
	int n = 0;
	
	while(x != 0){//Количество цифр в числе, запись их в массив цифр
		N[n] = abs(x % 10);
		n++;
		x /= 10;
	}
	
	bool t = true;

	sort(N , N+n);//Сортировка цифр по возрастанию

	long long ten = 1;
	
	for(int j = 0; j < n-1; j++){
		ten *= 10;
	}
	
	long long ten_copy = ten;
	
	for(int i = 0; i < n; i++){//Преобразование цифр в наименьшее число
		xm += N[i] * ten;
		ten /= 10;
	}
	
	for(int i = n-1; i >= 0; i--){//Преобразование цифр в наибольшее число
		xM += N[i] * ten_copy;
		ten_copy /= 10;
	}
	
	K = xM - xm;
	int c = 0;
	
	long long K_tmp = K;
	//Проверка на равенство количества цифр исходного числа и числа K
	while(K_tmp != 0){
		c++;
		K_tmp /= 10;
	}
	
	//Добавление недостающих ведущих нулей
	for(int i = 0; i < n-c; i++) cout << 0;
	
	if(K!=0)//Если K==0, то нули были выведены предыдущим циклом
		cout << K;//Вывод числа K
		
	return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

int main() {

long long x, K = 0, xm = 0, xM = 0;

//Вводимое число, искомое число, максимальное и минимальное из комбинации цифр

cin >> x;

int N[11];

int n = 0;

while(x != 0){//Количество цифр в числе, запись их в массив цифр

N[n] = abs(x % 10);

n++;

x /= 10;

}

bool t = true;

sort(N , N+n);//Сортировка цифр по возрастанию

long long ten = 1;

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

ten *= 10;

}

long long ten_copy = ten;

for(int i = 0; i < n; i++){//Преобразование цифр в наименьшее число

xm += N[i] * ten;

ten /= 10;

}

for(int i = n-1; i >= 0; i--){//Преобразование цифр в наибольшее число

xM += N[i] * ten_copy;

ten_copy /= 10;

}

K = xM - xm;

int c = 0;

long long K_tmp = K;

//Проверка на равенство количества цифр исходного числа и числа K

while(K_tmp != 0){

c++;

K_tmp /= 10;

}

//Добавление недостающих ведущих нулей

for(int i = 0; i < n-c; i++) cout << 0;

if(K!=0)//Если K==0, то нули были выведены предыдущим циклом

cout << K;//Вывод числа K

return 0;

}

Объяснение

Поскольку нужно находить минимальную и максимальную комбинацию из цифр числа, удобно в самом начале записать это число в виде массива и отсортировать. Далее найти, собственно, искомые числа, и получить из них само $K(x)$. Потом остаётся проверить количество цифр и вывести, при недостатке, соответствующее количество нулей.

Код на ideone
Зачтено на e-olymp

Related Images:

e-olymp 2501. Круговая диаграмма

04/11/2018 by Александр Дьяченко

Задача

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

Исходными данными для этой диаграммы является набор чисел $a_1,\ldots, a_n, а$ диаграмма представляет собой круг радиуса $r$, разделенный на секторы. При этом каждому из чисел соответствует ровно один сектор, площадь которого пропорциональна этому числу. Общая площадь секторов равна площади круга.

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

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

Первая строка содержит два целых числа $n$ и $r \space (1 \leq n, r \leq 100)$. Вторая строка содержит $n$ целых чисел $a_1,\ldots, a_n \space (1 \leq a_i \leq 100$ для всех $i$ от $1$ до $n)$.

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

Выведите $n$ вещественных чисел — площади секторов, соответствующих числам $a_1,\ldots, a_n$. Выводите каждое из чисел в отдельной строке.

Все эти числа должны быть выведены с точностью не хуже $10^{-6}$.

Тесты

Входные данные	Выходные данные
3 2 1 4 3	1.570796327 6.283185307 4.712388980
2 3 3 8	7.711181968 20.563151914
4 5 2 5 9 1	9.239978393 23.099945982 41.579902768 4.619989196
5 9 4 16 8 20 11	17.252135928 69.008543713 34.504271856 86.260679641 47.443373803

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

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

int main() {
    int n, r, sum = 0;
    double S;
    cin >> n >> r;
    int *x = new int[n];
    for (int i = 0; i < n; i++)
        cin >> x[i];
    for (int i = 0; i < n; i++)
        sum += x[i];
    S = M_PI * r * r;
    for (int i = 0; i < n; i++)
        cout << fixed << setprecision(9) << (S / sum) * x[i] << endl;
    return 0;
}

#include <iostream>

#include <iomanip>

#include <cmath>

using namespace std;

int main() {

int n, r, sum = 0;

double S;

cin >> n >> r;

int *x = new int[n];

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

cin >> x[i];

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

sum += x[i];

S = M_PI * r * r;

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

cout << fixed << setprecision(9) << (S / sum) * x[i] << endl;

return 0;

}

Решение

Найдем сперва сумму всех чисел $a_i$ и площадь диаграммы (по известной формуле площади круга). Теперь можем легко посчитать площади каждого из секторов нашей диаграммы, разделив площадь последней на ранее найденную сумму и умножив их частное на соответствующее число $a_i$.

Ссылки

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