e-olymp 145. Квадраты

25/06/2019 by Алина Гук

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

Задача

Заданы длины $n$ отрезков. Какое наибольшее количество квадратов можно из них составить? Сторона каждого квадрата должна состоять только из одного отрезка.

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

В первой строке находится количество отрезков $n \left(1 \leqslant n\leqslant 10^6\right)$. Во второй строке заданы $n$ натуральных чисел — длины отрезков, числовые значения которых не превышают $100$.

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

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

Тесты

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

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

#include <iostream>
#define MAX 101
using namespace std;

int a[MAX];

int main() {
    int n, l, res = 0, i;
    cin >> n;
    for(l = 0; l < n; l++) cin >> i, a[i]++;
    for(i = 1; i <= MAX - 1; i++) res += a[i] / 4;
    cout << res << "\n";
    return 0;
}

#include <iostream>

#define MAX 101

using namespace std;

int a[MAX];

int main() {

int n, l, res = 0, i;

cin >> n;

for(l = 0; l < n; l++) cin >> i, a[i]++;

for(i = 1; i <= MAX - 1; i++) res += a[i] / 4;

cout << res << "\n";

return 0;

}

Решение

Пусть имеется $k$ отрезков одинаковой длины. Тогда из них можно составить $\frac{k}{4}$ квадрата. Длины отрезков изменяются от $1$ до $100$. Подсчитываем количество отрезков длины $i\left(1\leqslant i\leqslant 100\right)$ в массив $a\left[i\right]$. Тогда максимально возможное количество квадратов, которое можно составить из данных отрезков, равно $$\frac{a\left[1\right]+a\left[2\right]+\dots +a\left[100\right]}{4}.$$

Для этого совершим сортировку подсчетом. В ячейке a[i] подсчитываем количество отрезков длины i . В переменную res подсчитываем количество квадратов, которое можно построить.

Ссылки

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

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

Сортировка подсчетом на Wikipedia

Related Images:

e-olymp 2371. Черный квадрат

21/06/2018 by Александра Рябова

Условие

Вдохновленный шедевром Казимира Малевича «Черный квадрат», Петр Палевич решил создать собственную версию картины. Он приготовил полотно в виде прямоугольной сетки с $m \times n$ белыми квадратами — $m$ строк по $n$ ячеек каждая.

Петр покрасил некоторые клетки в черный цвет так, что черные ячейки сформировали квадрат размером $s \times s$ ячеек. Но на следующий день Петр разочаровался в своем творении и уничтожил его, разрезав полотно горизонтальными полосами размера $1 \times n$, после чего сжег их в камине.

На следующее утро Петр передумал и решил восстановить картину. Он попытался найти ее останки в камине, и, к счастью, одну из полос, а именно $k$-ую сверху, огонь не тронул.

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

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

Первая строка содержит четыре целых числа: $m$, $n$, $s$ и $k$ $ \left( 1 \leqslant m, n \leqslant 5000, 1 \leqslant s \leqslant \min \left( m, n \right), 1 \leqslant k \leqslant m \right) $.

Вторая строка содержит $n$ символов и описывает $k$-ую строку картины, ‘.’ означает белую клетку, ‘*’ означает черную клетку.

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

Если изображение может быть однозначно восстановлено, то следует вывести «Unique». Если существует несколько вариантов восстановления картины, то вывести «Ambiguous». Если ни одной соответствующей картины не существует, вывести «Impossible».

Тесты

Ввод	Вывод
$3$ $4$ $2$ $3$ ..**	Unique
$4$ $4$ $2$ $3$ ..	Impossible
$3$ $5$ $2$ $2$ .**.	Ambiguous
$2$ $8$ $1$ $2$ ……*.	Unique

Код

String

#include <iostream>
#include <string>
using namespace std;
 
int main() {
    int m, n, s, k;
    cin >> m >> n >> s >> k;
    string str;
    cin >> str;
    int star_number = 0;
    bool end_of_stars = 0;
    bool sec_seq = 0;
    bool imp = 0;
    bool un = 0;
    bool amb = 0;
    for (int i = 0; i < str.length() && !sec_seq; i++){
        if (str[i] == '*') {
            if (end_of_stars == 1) sec_seq = 1;
            else star_number++;
        }
        else {
            if ( (star_number != 0) and (end_of_stars == 0) ) end_of_stars = 1;
        }
    }
    if (sec_seq == 1) imp = 1;
    else {
        if (star_number == 0) {
            if (s > k-1 && s > m-k) imp = 1;
            else {
                if (n>s) amb = 1;
                else {
                    if ( ( (s > m - k) and (k - 1 == s) ) or ( (s > k - 1) and (m - k == s) ) ) un = 1;
                    else amb = 1;
                }
            }
        }
        else {
            if (star_number != s) imp = 1;
            else {
                if (m == s || s == 1 || k == 1 || k == m) un = 1;
                else amb = 1;
            }
        }
    }
    if (un == 1) cout << "Unique";
    if (amb == 1) cout << "Ambiguous";
    if (imp == 1) cout << "Impossible";
    return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main() {

int m, n, s, k;

cin >> m >> n >> s >> k;

string str;

cin >> str;

int star_number = 0;

bool end_of_stars = 0;

bool sec_seq = 0;

bool imp = 0;

bool un = 0;

bool amb = 0;

for (int i = 0; i < str.length() && !sec_seq; i++){

if (str[i] == '*') {

if (end_of_stars == 1) sec_seq = 1;

else star_number++;

}

else {

if ( (star_number != 0) and (end_of_stars == 0) ) end_of_stars = 1;

}

if (sec_seq == 1) imp = 1;

else {

if (star_number == 0) {

if (s > k-1 && s > m-k) imp = 1;

else {

if (n>s) amb = 1;

else {

if ( ( (s > m - k) and (k - 1 == s) ) or ( (s > k - 1) and (m - k == s) ) ) un = 1;

else amb = 1;

}

else {

if (star_number != s) imp = 1;

else {

if (m == s || s == 1 || k == 1 || k == m) un = 1;

else amb = 1;

}

if (un == 1) cout << "Unique";

if (amb == 1) cout << "Ambiguous";

if (imp == 1) cout << "Impossible";

return 0;

}

C-string

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

int main() {
    const int MAXN = 5001;
    int m, n, s, k;
    cin >> m >> n >> s >> k;
    char seq [MAXN];
    cin >> seq;
    int star_number = 0;
    bool end_of_stars = 0;
    bool sec_seq = 0;
    bool imp = 0;
    bool un = 0;
    bool amb = 0;
    for (int i = 0; i < strlen(seq) && !sec_seq; i++){
        if (seq[i] == '*') {
            if (end_of_stars == 1) sec_seq = 1;
            else star_number++;
        }
        else {
            if ( (star_number != 0) and (end_of_stars == 0) ) end_of_stars = 1;
        }
    }
    if (sec_seq == 1) imp = 1;
    else {
        if (star_number == 0) {
            if (s > k-1 && s > m-k) imp = 1;
            else {
                if (n>s) amb = 1;
                else {
                    if ( ( (s > m - k) and (k - 1 == s) ) or ( (s > k - 1) and (m - k == s) ) ) un = 1;
                    else amb = 1;
                }
            }
        }
        else {
            if (star_number != s) imp = 1;
            else {
                if (m == s || s == 1 || k == 1 || k == m) un = 1;
                else amb = 1;
            }
        }
    }
    if (un == 1) cout << "Unique";
    if (amb == 1) cout << "Ambiguous";
    if (imp == 1) cout << "Impossible";
    return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

int main() {

const int MAXN = 5001;

int m, n, s, k;

cin >> m >> n >> s >> k;

char seq [MAXN];

cin >> seq;

int star_number = 0;

bool end_of_stars = 0;

bool sec_seq = 0;

bool imp = 0;

bool un = 0;

bool amb = 0;

for (int i = 0; i < strlen(seq) && !sec_seq; i++){

if (seq[i] == '*') {

if (end_of_stars == 1) sec_seq = 1;

else star_number++;

}

else {

if ( (star_number != 0) and (end_of_stars == 0) ) end_of_stars = 1;

}

if (sec_seq == 1) imp = 1;

else {

if (star_number == 0) {

if (s > k-1 && s > m-k) imp = 1;

else {

if (n>s) amb = 1;

else {

if ( ( (s > m - k) and (k - 1 == s) ) or ( (s > k - 1) and (m - k == s) ) ) un = 1;

else amb = 1;

}

else {

if (star_number != s) imp = 1;

else {

if (m == s || s == 1 || k == 1 || k == m) un = 1;

else amb = 1;

}

if (un == 1) cout << "Unique";

if (amb == 1) cout << "Ambiguous";

if (imp == 1) cout << "Impossible";

return 0;

}

Решение

Основная сложность задачи заключается в аккуратном рассмотрении всех возможных вариантов. После прочтения строки символов, которую представляет собой вытащенная из огня полоска, исследуем ее на количество подряд идущих символов ‘*’. Если последовательностей из звездочек в одной строке несколько, то никакие добавленные полоски не смогут сделать из нее квадрат, и тогда решений нет. Иначе дальнейшее решение делится на два случая:

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

Если сравнивать, что выгоднее использовать в данной задаче для задания спасённой из огня полоски — строку или массив символов, — то использование строки способствует немного более быстрому решению задачи, чем массив символов; объём используемой памяти при этом не изменяется.

Ссылки

Условие на e-olymp.com
Код с использованием string на ideone.com
Код с использованием c-string на ideone.com

Related Images:

e-olymp 7612. Алекс и квадраты оригами

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

Задача

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

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

В одной строке два целых числа [latex]h[/latex] и [latex]w[/latex] ([latex]1 ≤ h, w ≤ 1000[/latex]) — высота и ширина куска бумаги.

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

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

Ответ следует вывести с точностью не меньше трех десятичных знаков.

Тесты

Входные данные	Выходные данные
$100$ $100$	$50.000$
$10$ $80$	$10.000$
$50$ $76$	$25.333$
$60$ $27$	$20.000$
$8$ $3$	$2.667$

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

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

int main()
{
    cout.precision(4);
    double h, w = 0;
    cin >> h;
    cin >> w;
    double b = max(h, w);
    double a = min(w, h);
    double c = min(a, max(b/3, a/2));
    cout << fixed << c;
}

#include<iostream>

#include<cmath>

#include <iomanip>

using namespace std;

int main()

{

cout.precision(4);

double h, w = 0;

cin >> h;

cin >> w;

double b = max(h, w);

double a = min(w, h);

double c = min(a, max(b/3, a/2));

cout << fixed << c;

}

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

Существует два варианта оптимального расположения трех квадратов — три в один ряд,

или же два, соприкасающихся одной стороной, и третий над ними

Обозначим за [latex]a[/latex] меньшую сторону листа бумаги, а за [latex]b[/latex] — большую. Если [latex]a[/latex] не больше [latex]\frac{b}{3}[/latex], то оптимальным расположением квадратов в прямоугольнике будет первый вариант, а наибольшей возможной стороной квадратов является меньшая сторона листа бумаги [latex]a[/latex]. В противном случае рассмотрим два варианта:

Если [latex]\frac{a}{2}<\frac{b}{3}[/latex], то квадраты будут располагаться в прямоугольнике первым способом, и ответом будет служить число [latex]\frac{a}{2}[/latex].
Иначе квадраты будут располагаться в прямоугольнике вторым способом, и ответом будет служить число [latex]\frac{b}{3}[/latex].

Таким образом, в случае [latex]a>\frac{b}{3}[/latex] ответом будет служить большее из двух чисел [latex]\frac{a}{2}[/latex] и [latex]\frac{b}{3}[/latex].
Минимальное из [latex]\max\left(\frac{b}{3},\frac{a}{2}\right)[/latex] и [latex]a[/latex] число и будет ответом.
Проверим нашу формулу:если [latex]a<\frac{b}{3}[/latex], то [latex] \max\left(\frac{b}{3},\frac{a}{2}\right)=\frac{b}{3} [/latex], и тогда [latex]\min\left(a,\max\left(\frac{b}{3},\frac{a}{2}\right)\right)=a[/latex]. Иначе [latex]\min\left(a,\max\left(\frac{b}{3},\frac{a}{2}\right)\right)=\max\left(\frac{b}{3},\frac{a}{2}\right)[/latex], что нам и требуется.

Ссылки

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

Related Images:

e-olymp 519. Сумма квадратов

16/11/2017 by Иван Василевский

Как лучше кодировать квадрат?

Условие задачи
Найти сумму квадратов двух чисел.

Входные данные
Два целых числа [latex]a[/latex] и [latex]b[/latex]. Числа не превышают [latex]10^9[/latex] по абсолютной величине.

Выходные данные
Выведите одно целое число [latex]a^2 + b^2.[/latex] Continue reading →

Related Images:

KM31. Бумажные многоугольники

02/10/2016 by Тимур Фирсов

Задача

Задача из журнала «Квант» №7 1970 г.
Квадратный лист бумаги разрезают по прямой на две части. Одну из полученных частей снова разрезают на две части, и так делают много раз. Какое наименьшее число разрезов [latex]r[/latex] нужно сделать, чтобы среди полученных частей оказалось [latex]n[/latex] [latex]k[/latex] -угольников?

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

Количество многоугольников [latex]n[/latex].
Количество углов многоугольника [latex]k[/latex].

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

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

Пример получения двух шестиугольников за 5 разрезов

Тесты

	Входные данные		Выходные данные
№	[latex]n[/latex]	[latex]k[/latex]	[latex]r[/latex]
1	100	20	1699
2	14	3	13
3	1	3	1
4	40	360	14279
5	2	6	5

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

#include <iostream>
using namespace std;
 
int main() {
    int r, n, k;
    cin>>n>>k;
    r=k>3? n*(k-3)-1 : n>1? n-1 : 1;
    cout<<r;
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int r, n, k;

cin>>n>>k;

r=k>3? n*(k-3)-1 : n>1? n-1 : 1;

cout<<r;

return 0;

}

Решение

При каждом разрезе количество кусков бумаги [latex]n[/latex] увеличивается на [latex]1[/latex]. Общее количество вершин [latex]k[/latex] будет увеличиваться в зависимости от места разреза. Таким образом при разрезе через две стороны общее количество вершин будет увеличиваться на [latex]4[/latex]. При разрезе через две вершины общее количество вершин увеличивается на [latex]2[/latex], а при разрезе через сторону и вершину — на [latex]3[/latex].

При [latex]k>3[/latex] сначала разделим лист на [latex]n[/latex] четырёхугольников при помощи разрезов через противоположные стороны. На это нам понадобиться [latex]n-1[/latex] разрезов. Затем можем, при помощи разрезов через соседние стороны, превращать каждый четырехугольник в [latex]k[/latex] — угольник, на что понадобиться [latex]k-4[/latex] разрезов.Выходит, что на получение [latex]n[/latex] [latex]k[/latex]- угольников нужно сделать не меньше [latex]n(k-4)+n-1[/latex] разрезов, значит [latex]r=n(k-3)-1[/latex].

Если же [latex]k=3[/latex], то нам нужно, наоборот, уменьшить количество вершин. Тогда первый разрез сделаем через две вершины квадрата — получаем два треугольника, затем каждым разрезом через вершину и сторону увеличиваем количество треугольников на [latex]1[/latex] пока не получим [latex]n[/latex]. В таком случае [latex]r= n-1 [/latex]. Исключение: если [latex]n=1[/latex], то [latex]r=1.[/latex]

Ссылки

Код программы.
Условие задачи (страница 47).

Related Images:

Mif 8

07/10/2015 by Настя Ивасенко

Задача

Условие взято отсюда

Четырёхугольник [latex]ABCD[/latex] задан на плоскости целочисленными координатами вершин. Определите тип четырёхугольника: квадрат, ромб, прямоугольник, параллелограмм, трапеция, произвольный четырёхугольник. Из характеристик указать наиболее частную.

Тесты

[latex]a_1[/latex] [latex]a_2[/latex]	[latex]b_1[/latex] [latex]b_2[/latex]	[latex]c_1[/latex][latex]c_2[/latex]	[latex]d_1[/latex] [latex]d_2[/latex]	Ответ
0 0	1 0	1 1	0 1	квадрат
0 -3	2 0	0 3	-2 0	ромб
0 0	4 0	4 1	1 4	прямоугольник
0 0	10 0	12 4	2 4	пaраллелограмм
0 0	2 0	1 1	0 1	трапеция
0 0	0 2	1 1	1 0	трапеция
-4 -5	-15 7	5 8	6 -7	произвольный
0 0	1 0	10 20	-5 7	произвольный

Код

#include <iostream>
using namespace std;
 
int main() {
	int a1, a2, b1, b2, c1, c2, d1, d2;
	double  AB, BC, CD, DA, AC, BD, A, B, C, D;
	cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2 >> d1 >> d2;
	AB= ((a1-b1)*(a1-b1)+(a2-b2)*(a2-b2)); //длина стороны во второй степени
	BC= ((b1-c1)*(b1-c1)+(b2-c2)*(b2-c2));
	CD= ((c1-d1)*(c1-d1)+(c2-d2)*(c2-d2));
	DA= ((d1-a1)*(d1-a1)+(d2-a2)*(d2-a2));
	AC= ((a1-c1)*(a1-c1)+(a2-c2)*(a2-c2)); //длина диагонали во второй степени
	BD= ((b1-d1)*(b1-d1)+(b2-d2)*(b2-d2));
	if(AB==CD && BC==DA) {
		if (AB==BC){
			if(AC==BD){
				cout << "квадрат";
			}
			else {
				cout << "ромб";
			}
		}
		else 
		if (AC==BD){
			cout<< "прямоугольник";
		}
		else{
			cout << "параллелограмм";
		}
	}
	else 
	if ( ((a1-b1)*(c2-d2)==(a2-b2)*(c1-d1)) || ((a1-d1)*(b2-c2)==(a2-d2)*(b1-c1)) ){
		cout << "трапеция";
	}
	else {
		cout << "произвольный";
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int a1, a2, b1, b2, c1, c2, d1, d2;

double AB, BC, CD, DA, AC, BD, A, B, C, D;

cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2 >> d1 >> d2;

AB= ((a1-b1)*(a1-b1)+(a2-b2)*(a2-b2)); //длина стороны во второй степени

BC= ((b1-c1)*(b1-c1)+(b2-c2)*(b2-c2));

CD= ((c1-d1)*(c1-d1)+(c2-d2)*(c2-d2));

DA= ((d1-a1)*(d1-a1)+(d2-a2)*(d2-a2));

AC= ((a1-c1)*(a1-c1)+(a2-c2)*(a2-c2)); //длина диагонали во второй степени

BD= ((b1-d1)*(b1-d1)+(b2-d2)*(b2-d2));

if(AB==CD && BC==DA) {

if (AB==BC){

if(AC==BD){

cout << "квадрат";

}

else {

cout << "ромб";

}

else

if (AC==BD){

cout<< "прямоугольник";

}

else{

cout << "параллелограмм";

}

else

if ( ((a1-b1)*(c2-d2)==(a2-b2)*(c1-d1)) || ((a1-d1)*(b2-c2)==(a2-d2)*(b1-c1)) ){

cout << "трапеция";

}

else {

cout << "произвольный";

}

return 0;

}

Решение

Для начала стоит найти длины всех сторон:

[latex]AB^{2}=((a1-b1)^{2}+(a2-b2)^{2})[/latex]. (аналогично для остальных сторон)

Затем можно найти длины диагоналей четырёхугольника

[latex]AC^{2}=((a1-c1)^{2}+(a2-c2)^{2})[/latex]. (аналогично для [latex]BD[/latex]).

Через условие задаем равность противоположных сторон [latex]AB=CD[/latex] и [latex]BC=DA[/latex]:

У ромба смежные стороны равны, но если у ромба диагонали равны, то это квадрат;
Если четырёхугольник не является квадратом, но диагонали равны, то это прямоугольник;
В противном случае — параллелограмм.

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

Код на ideone

Related Images:

Mif 17.4

04/10/2015 by Настя Ивасенко

Условие задачи (17.4)

Условие

Принадлежит ли точка [latex](x;y)[/latex] фигуре на рисунке? Пожалуйста повторите в своём отчёте рисунок, выполнив его в формате SVG.

Тесты

x	y	Ответ
4	3	yes
1	4	yes
2	2	no
6	2	no
-1	0	no

Решение

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

Можно заметить, что эти сумма координат этих точек находится в сегменте между [latex]5[/latex] и [latex]11[/latex]:

[latex]5\leq x+y\leq 11[/latex];

Их разность в сегменте от [latex]-3[/latex] до [latex]3[/latex]:

[latex]-3\leq x-y\leq 3[/latex];

Если сумма или разность данных координат больше или меньше заданых чисел, то точка не принадлежит ромбу.

Код

#include <iostream>
using namespace std;
 
int main() {
    double x, y;
    cin >> x >> y;
    if ((x+y>=5 && x+y<=11 && x-y>=-3 && x-y<=3)) {
        cout <<"yes";
    }
    else
    {
        cout << "no";
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

double x, y;

cin >> x >> y;

if ((x+y>=5 && x+y<=11 && x-y>=-3 && x-y<=3)) {

cout <<"yes";

}

else

{

cout << "no";

}

return 0;

}

Код на IDEONE

Related Images:

e-olymp 133. Квадрат и точки

14/09/2015 by Александр Коломеец

Квадрат и точки.

Постановка задачи

Какое наибольшее количество точек с целочисельными координатами на листке в клеточку можно накрыть квадратом со стороной N клеток?

Алгоритм решения

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

Тесты

Входные данные	Выходные данные
1	4
2	9
3	16
4	25

Реализация

ideone: ссылка
Засчитаное решение на e-olymp: ссылка

#include <iostream>
 
int main() {
    int l;
    std::cin >> l;
    std::cout << (l + 1) * (l + 1);
    return 0;
}

#include <iostream>

int main() {

int l;

std::cin >> l;

std::cout << (l + 1) * (l + 1);

return 0;

}