MLoops22

31/10/2015 by Молоканов Юрий

Условие

1491625364964811001211441
6919622525628932436140044
1484529576625676729784841
9009611024108911561225129

Тестирование

№	Входные данные	Выходные данные
1	1 1	1
2	7 1	1491625
3	10 2	1491625364 9648110012
4	1 3	1 4 9
5	1 6	1 4 9 1 6 2
6	5 5	14916 25364 96481 10012 11441
7	25 4	1491625364964811001211441 6919622525628932436140044 1484529576625676729784841 9009611024108911561225129

Код

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

// Возвращает длину числа
int GetLength(int a) {
	return (a==0?1:log10(a)+1);
}

// Возвращает левую часть числа до заданной цифры включительно
int LeftPart(int a, int n) {
	return a/pow(10, GetLength(a) - n);
}

// Возвращает правую часть числа после заданной цифры
int RightPart(int a, int n) {
	int p = pow(10, GetLength(a) - n);
	return a%p;
}

int main() {
	int n, m, i = 0, toPrint; // Столбцы, строки, счетчик очередного числа для возведения в квадрат, текущее значение для печати
	bool haveRest = false;	// Есть ли часть числа, "отрезанная" после переноса строки
	cin >> n >> m;
	int columnsLeft = n;	// Присваиваем переменной для оставшихся свободных столбцов значения общего количества столбцов
	while(m > 0) {
		if(columnsLeft == 0) {	// Если не осталось свободных столбцов
			m--;
			if(m > 0)
				cout << endl;
			columnsLeft = n;	// Восстанавливаем число оставшихся столбцов
			haveRest = false;	// "Отрезанной" части числа нет
		} else {	// Если есть свободные столбцы
			i = (haveRest?i:++i);
			toPrint = (haveRest?toPrint:i*i);	// Если "отрезанной" части числа нет, записываем в toPrint квадрат очередного числа
			if(GetLength(toPrint) <= columnsLeft) {	// Если хватает свободных столбцов для печати числа в toPrint
				cout << toPrint;
				columnsLeft -= GetLength(toPrint);	// Обновляем количество свободных столбцов
				haveRest = false;	// "Отрезанной" части числа нет
			} else {	// Если свободных столбцов не хватает для печати числа в toPrint целиком
				cout << LeftPart(toPrint, columnsLeft);	// Печатаем левую часть числа в toPrint, чтобы заполнить все оставшиеся свободные столбцы
				toPrint = RightPart(toPrint, columnsLeft);	// Присваиваем toPrint значение его ненапечатанной части
				m--;
				if(m > 0)
					cout << endl;
				columnsLeft = n;	// Восстанавливаем число оставшихся столбцов
				haveRest = true;	// "Отрезанная" часть числа есть
			}
		}
	}
	return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

// Возвращает длину числа

int GetLength(int a) {

return (a==0?1:log10(a)+1);

}

// Возвращает левую часть числа до заданной цифры включительно

int LeftPart(int a, int n) {

return a/pow(10, GetLength(a) - n);

}

// Возвращает правую часть числа после заданной цифры

int RightPart(int a, int n) {

int p = pow(10, GetLength(a) - n);

return a%p;

}

int main() {

int n, m, i = 0, toPrint; // Столбцы, строки, счетчик очередного числа для возведения в квадрат, текущее значение для печати

bool haveRest = false; // Есть ли часть числа, "отрезанная" после переноса строки

cin >> n >> m;

int columnsLeft = n; // Присваиваем переменной для оставшихся свободных столбцов значения общего количества столбцов

while(m > 0) {

if(columnsLeft == 0) { // Если не осталось свободных столбцов

m--;

if(m > 0)

cout << endl;

columnsLeft = n; // Восстанавливаем число оставшихся столбцов

haveRest = false; // "Отрезанной" части числа нет

} else { // Если есть свободные столбцы

i = (haveRest?i:++i);

toPrint = (haveRest?toPrint:i*i); // Если "отрезанной" части числа нет, записываем в toPrint квадрат очередного числа

if(GetLength(toPrint) <= columnsLeft) { // Если хватает свободных столбцов для печати числа в toPrint

cout << toPrint;

columnsLeft -= GetLength(toPrint); // Обновляем количество свободных столбцов

haveRest = false; // "Отрезанной" части числа нет

} else { // Если свободных столбцов не хватает для печати числа в toPrint целиком

cout << LeftPart(toPrint, columnsLeft); // Печатаем левую часть числа в toPrint, чтобы заполнить все оставшиеся свободные столбцы

toPrint = RightPart(toPrint, columnsLeft); // Присваиваем toPrint значение его ненапечатанной части

m--;

if(m > 0)

cout << endl;

columnsLeft = n; // Восстанавливаем число оставшихся столбцов

haveRest = true; // "Отрезанная" часть числа есть

}

return 0;

}

Решение

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

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

Опираясь на вышеперечисленное, опишем алгоритм работы цикла построения таблицы более подробно:

В первую очередь проверяется условие продолжения цикла. Цикл будет выполняться до тех пор, пока количество полностью напечатанных строк (то есть строк, длина которых равна заданному количеству столбцов) будет меньше требуемого количества строк в готовой таблице.
Определяется количество свободных столбцов в текущей строке. Если оно равно нулю, выполняется перевод на новую строку, количество полностью напечатанных строк увеличивается на [latex]1[/latex] и итерация цикла завершается.
Определяется последовательность цифр, печатаемая в текущей итерации цикла. Если с прошлой итерации в результате переноса строки осталась «отрезанная» часть числа, то в этой итерации будет выводиться она; иначе же будет выводиться квадрат очередного натурального числа.
Проверяется, сможет ли число, сформированное на предыдущем шаге, полностью уместиться в текущей строке. Если его длина меньше или равна количеству свободных столбцов, то оно выводится в поток и итерация цикла завершается; в противном случае выводится та его часть, которая может уместиться в строке, ненапечатанная часть сохраняется и будет выведена в следующей итерации (если выполнится условие продолжения цикла), количество полностью напечатанных строк увеличивается на [latex]1[/latex] и итерация цикла также завершается.

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

int i для хранения очередного натурального числа, квадрат которого нужно вычислить;
int toPrint для хранения числа, которое нужно будет выводить в очередной итерации цикла;
int columnsLeft для хранения числа свободных столбцов в текущей строке;
bool haveRest для обозначения наличия или отсутствия «отрезанной» в результате переноса строки части числа;
функция int GetLength(int a), возвращающая длину числа a;
функция int LeftPart(int a, int n), возвращающая левую часть числа a до n-той цифры включительно;
функция int RightPart(int a, int n), возвращающая правую часть числа a после n-той цифры.

До начала выполнения цикла присвоим переменной haveRest значение false («отрезанные» части чисел могут появится не раньше второй итерации), а переменной columnsLeft — считанное значение количества столбцов в таблице n.

Составим код цикла, следуя описанному выше алгоритму построения таблицы. Условием продолжения цикла будет наличие не напечатанных до конца строк m (в дальнейшем будем декрементировать m всякий раз при переносе строки):

while(m > 0)

1	while(m > 0)

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

if(columnsLeft == 0) {	// Если не осталось свободных столбцов
	m--;
	if(m > 0)
		cout << endl;
	columnsLeft = n;	// Восстанавливаем число оставшихся столбцов
	haveRest = false;	// "Отрезанной" части числа нет
}

if(columnsLeft == 0) { // Если не осталось свободных столбцов

m--;

if(m > 0)

cout << endl;

columnsLeft = n; // Восстанавливаем число оставшихся столбцов

haveRest = false; // "Отрезанной" части числа нет

}

Если же свободные столбцы есть, определяем число, которое будет печататься в этой итерации. В случае, если «отрезанная» часть отсутствует, переменной toPrint присваиваем значение квадрата очередного натурального числа, иначе оставляем ее без изменений ( toPrint получает значение ненапечатанной части числа в конце цикла, если таковая имеется):

i = (haveRest?i:++i);
toPrint = (haveRest?toPrint:i*i);	// Если "отрезанной" части числа нет, записываем в toPrint квадрат очередного числа

1 2	i = (haveRest?i:++i); toPrint = (haveRest?toPrint:i*i); // Если "отрезанной" части числа нет, записываем в toPrint квадрат очередного числа

Наконец, оценим, может ли число, хранящееся в toPrint, уместиться в текущей строке. Если может, то выводим его, обновляем число свободных столбцов в строке и указываем, что «отрезанной» части числа нет:

if(GetLength(toPrint) <= columnsLeft) {	// Если хватает свободных столбцов для печати числа в toPrint
	cout << toPrint;
	columnsLeft -= GetLength(toPrint);	// Обновляем количество свободных столбцов
	haveRest = false;	// "Отрезанной" части числа нет
}

if(GetLength(toPrint) <= columnsLeft) { // Если хватает свободных столбцов для печати числа в toPrint

cout << toPrint;

columnsLeft -= GetLength(toPrint); // Обновляем количество свободных столбцов

haveRest = false; // "Отрезанной" части числа нет

}

В противном случае печатаем ту часть числа, которая помещается в строке, после чего присваиваем переменной toPrint значение ненапечатанной части, выполняем перенос строки, восстанавливаем количество свободных столбцов и указываем, что имеется «отрезанная» часть числа. Таким образом, в следующей итерации (если выполнится условие продолжения цикла) выводиться будет не очередной квадрат, а правая часть числа, которая не уместилась в предыдущей строке.

else {	// Если свободных столбцов не хватает для печати числа в toPrint целиком
	cout << LeftPart(toPrint, columnsLeft);	// Печатаем левую часть числа в toPrint, чтобы заполнить все оставшиеся свободные столбцы
	toPrint = RightPart(toPrint, columnsLeft);	// Присваиваем toPrint значение его ненапечатанной части
	m--;
	if(m > 0)
		cout << endl;
	columnsLeft = n;	// Восстанавливаем число оставшихся столбцов
	haveRest = true;	// "Отрезанная" часть числа есть
}

else { // Если свободных столбцов не хватает для печати числа в toPrint целиком

cout << LeftPart(toPrint, columnsLeft); // Печатаем левую часть числа в toPrint, чтобы заполнить все оставшиеся свободные столбцы

toPrint = RightPart(toPrint, columnsLeft); // Присваиваем toPrint значение его ненапечатанной части

m--;

if(m > 0)

cout << endl;

columnsLeft = n; // Восстанавливаем число оставшихся столбцов

haveRest = true; // "Отрезанная" часть числа есть

}

Ссылки

Код программы на Ideone.com;

Последовательность в OEIS;

Список задач на циклы.

Related Images:

MLoops2

31/10/2015 by Алина Гончарова

Задача

Найти закономерность и написать программу, которая выводит аналогичную таблицу для любых чисел $n > 0$ (количество столбцов) и $m > 0$ (количество строк).

-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*
-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*
-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*
-*-*-*-*-*-*-*-*-*-*-*-*-
*-*-*-*-*-*-*-*-*-*-*-*-*

Решение

Для того, чтобы решить поставленную задачу, нужно сначала понять закономерность чередования символов — и * в таблице. Каждый символ имеет свой номер строки([latex]m[/latex]) и столбца([latex]n[/latex]), а чтобы определить их номера зададим счетчики [latex]i[/latex] и [latex]j[/latex]. Задача состоит из того, что нужно определить закономерность появления символа [latex]-[/latex], в остальных случаях нужно выводить символ [latex]*[/latex]. Символ [latex]-[/latex] чередуется с символом [latex]*[/latex], и поэтому можно увидеть, что этот символ [latex]-[/latex] ставится на место, при котором сумма номеров столбцов и строк делится нацело на 2. Решить данную задачу можно с помощью тернарной операции.

Код

#include <iostream>
using namespace std;

int main() {
	int m, n;
	cin >> m >> n;
	for (int i=1; i<n; i++){
		for (int j=1; j<m; j++){
			cout << ((i+j)%2==0? "-":"*");
		}
		cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int m, n;

cin >> m >> n;

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

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

cout << ((i+j)%2==0? "-":"*");

}

cout << endl;

}

return 0;

}

Тесты

Входные данные	10 10	8 5	25 8
Выходные данные	-----* ----- ----- ----- ----- ----- ----- ----- ----- ----*-	---- ---- ---- ---- ----	------------- ------------* ------------- ------------* ------------- ------------* ------------- ------------*

Задача взята отсюда.

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

Related Images:

Mloops 5

30/10/2015 by Антон Локтев

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

Найдите закономерность и напишите программу, которая выводит аналогичную таблицу для любых чисел [latex] n>0 [/latex] (количество столбцов) и [latex] m>0 [/latex] (количество строк): +++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*+++++*++ .

Задача находится здесь.

Тесты

№	n	m	Таблица
1	25	8	+++++++++++++++++++++ +++++++++++++++++++++ +++++++++++++++++++++ +++++++++++++++++++++ +++++++++++++++++++++ ++++++++++++++++++++* +++++++++++++++++++++ +++++++++++++++++++++
2	6	6	+++++* +++++ +++++ +++++ +++++ *+++++
3	2	5	++ ++ ++ ++ +*

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

Таблица, которую необходимо вывести на экран представляет собой определённую последовательность. Каждый символ таблицы имеет номера столбца и строки (нумерация от 0 до n или m не включительно). Для этого задаём счётчики [latex] i [/latex] и [latex] j [/latex] . Наша задача — определить закономерность появления символа [latex] \ast [/latex] в данной таблице, поскольку в иных случаях необходимо вывести символ [latex] + [/latex]. В первой строке «звёздочка» встречается в данной таблице в [latex] 6,12,18,24[/latex] столбцах. Во второй строке «звёздочка» находится в [latex] 5,11,17,23[/latex] столбцах. В последующих строках ситуация аналогичная. Можно заметить, что символ [latex] \ast [/latex] стоит на позициях, при которых сумма номера строки и номера столбца делится нацело на 6. Проверяем это условие с помощью тернарной операции:

cout << ((i+j-5)%6== 0? "*":"+");

1	cout << ((i+j-5)%6== 0? "*":"+");

от суммы номеров столбца и строки отнимаем число [latex] 5 [/latex], поскольку нам необходимо, чтобы первыми пятью символами последовательности были плюсы.

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

#include <iostream>
using namespace std;

int main() {
	int n,m;
	cin >> n >> m;
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			cout << ((i+j-5)%6== 0? "*":"+");
		}
	cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int n,m;

cin >> n >> m;

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

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

cout << ((i+j-5)%6== 0? "*":"+");

}

cout << endl;

}

return 0;

}

Ссылка на рабочий код программы находится здесь.

Related Images:

Интересная последовательность

22/09/2015 by Сплошнов Кирилл

Условие (OCPC-2015)

Дана последовательность из [latex]n[/latex] чисел: [latex]x_0[/latex], [latex]x_1[/latex], [latex]x_2, \ldots, x_{n-1}[/latex], где [latex]x_0[/latex] — кол-во чисел [latex]0[/latex] в данной последовательности, [latex]x_1[/latex] — кол-во чисел [latex]1[/latex], и так далее…

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

Число [latex]n[/latex] — количество членов последовательности.

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

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

Размышления над решением:

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

[latex]x_0 + x_1 + [/latex]…[latex] + x_{n-1} = n[/latex] (1)

Далее заметим, что [latex]x_0[/latex] не может равняться нулю (ведь записав туда [latex]0[/latex], мы сразу же увеличиваем кол-во нулей до одного). Тогда [latex]x_0[/latex] равняется другому числу [latex]k[/latex], положим, большему чем 2. Тогда, [latex]x_k = 1[/latex].

Далее, положив [latex]x_1 = 2[/latex] и [latex]x_2 = 1[/latex], получаем последовательность, не нуждающуюся в дальнейших преобразованиях, в чем легко убедиться. Для наглядности:

Член последовательности	[latex]x_0[/latex]	[latex]x_1[/latex]	[latex]x_2[/latex]	…	[latex]x_k[/latex]	…
Чему равен	k	2	1	0	1	0
Комментарий	[latex]k[/latex] будет найдено ниже	Количество чисел [latex]1[/latex] равно двум	Количество чисел [latex]2[/latex] равно одному	На этом промежутке только нули	[latex]k[/latex] больше двух	На этом промежутке только нули

Теперь вычислим [latex]k[/latex]. По формуле (1):

[latex]k + 2 + 1 + 1 = n[/latex]; [latex]k = n — 4[/latex]

(Примечание: При попытки подставить другие значения вместо [latex]x_1[/latex] или [latex]x_2[/latex] получится нестабильная последовательность, членам которой не получится присвоить значения согласно условию. Положив, например, [latex]x_1 = 3[/latex], нам придется увеличить кол-во единиц, что приведет к необходимости использовать другие числа последовательности, что в итоге обязательно приведет к нарушению необходимого условия (1) — сумма уже присвоенных ненулевых чисел попросту превысит количество ее оставшихся членов. Аналогично, если присвоить [latex]x_2 = 2[/latex], и уж тем более, при внесении более «крупных» изменений в последовательность. Таким образом, найденное решение является единственным.)

Очевидно, минимальное «рабочее» значение [latex]n[/latex] равно семи (при [latex]k = 2 + 1 = 3[/latex]).

Тесты (1) :

[latex]n[/latex]	[latex]x_0[/latex]	[latex]x_1[/latex]	[latex]x_2[/latex]	[latex]x_3[/latex]	[latex]x_4[/latex]	[latex]x_5[/latex]	[latex]x_6[/latex]	[latex]x_7[/latex]	[latex]x_8[/latex]	…
7	3	2	1	1	0	0	0
8	4	2	1	0	1	0	0	0
9	5	2	1	0	0	1	0	0	0
…	[latex]n — 4[/latex]	2	1	0	…	…	…	…	…	…

Для [latex]n[/latex] меньше семи, решение (или их отсутствие) было найдено подбором.

Тесты (2) :

[latex]n[/latex]	[latex]x_0[/latex]	[latex]x_1[/latex]	[latex]x_2[/latex]	[latex]x_3[/latex]	[latex]x_4[/latex]	[latex]x_5[/latex]
1	Решений нет
2	Решений нет
3	Решений нет
4	1 2	2 0	1 2	0 0
5	2	1	2	0	0
6	Решений нет

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

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

#include <iostream>
using namespace std;

int main() 
{
	int n;
	cin >> n;
	if (n < 4 || n == 6) // особые случаи (1)
		cout << "Решений нет" << endl;
	else if (n == 4) // особые случаи (2)
    {
        cout << "1 2 1 0" << endl;
        cout << "2 0 2 0" << endl;
    }
	else if (n == 5) // особый случай (3)
		cout << "2 1 2 0 0" << endl;
	else // алгоритм для общего случая
	{
		int number[n]; // создаем массив членов последовательности
		for (int i = 0; i < n; i++) // приравниваем все числа к нулю
			number[i] = 0;
		number[0] = n - 4; // выставляем значения для ненулевых членов
		number[1] = 2;
		number[2] = 1;
		number[n - 4] = 1;
		for (int i = 0; i < n; i++) // выводим по очереди элементы последовательности на экран
			cout << number[i] << " ";
		cout << endl; 
	}
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

int n;

cin >> n;

if (n < 4 || n == 6) // особые случаи (1)

cout << "Решений нет" << endl;

else if (n == 4) // особые случаи (2)

{

cout << "1 2 1 0" << endl;

cout << "2 0 2 0" << endl;

}

else if (n == 5) // особый случай (3)

cout << "2 1 2 0 0" << endl;

else // алгоритм для общего случая

{

int number[n]; // создаем массив членов последовательности

for (int i = 0; i < n; i++) // приравниваем все числа к нулю

number[i] = 0;

number[0] = n - 4; // выставляем значения для ненулевых членов

number[1] = 2;

number[2] = 1;

number[n - 4] = 1;

for (int i = 0; i < n; i++) // выводим по очереди элементы последовательности на экран

cout << number[i] << " ";

cout << endl;

}

return 0;

}

Также есть ссылка на рабочий код на Ideaone для желающих провести дополнительные тесты:

Ideaone.com

Related Images:

А136и

28/06/2015 by Танащук Григорій Русланович

Задача. Даны натуральное число n, действительные числа [latex]a_{1}, a_{2}, \dots, a_{n}[/latex] Вычислить [latex] \frac{a_{1}}{0!} + \frac{a_{2}}{1!} + \cdots + \frac{a_{n}}{(n-1)!} [/latex]

Тест

Число-n	Действительные числа	Результат
5	4 5 6 7 8	13,5
7	5 4 7 9 2 8 3	14,1542
3	6 9 3	16,5

Программа:

#include <iostream>
using namespace std;
 
int main() {
    int n; 
    double a;
    cin >> n;
    double s = 0.0;
    for (int  i = 0; i < n; i++){
        cin >> a;
        for(int j = 1; j<=i; j++){
            a/= j*1.0;
        }
        s+=a;
    }
    cout << s <<"\n";
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

double a;

cin >> n;

double s = 0.0;

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

cin >> a;

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

a/= j*1.0;

}

s+=a;

}

cout << s <<"\n";

return 0;

}

Вводим n, a (действительные числа);
Вычисляем минор;
Задаем массив;
Делим на факториал и суммируем;
Ссылка на программу

Related Images:

А1042

01/06/2015 by Швандт Максим Альбертович

Условие:

В данной последовательности действительных чисел [latex]a_{1},…,a_{20}[/latex] выбрать возрастающую подпоследовательность наибольшей длинны.

Тесты:

Число элементов в заданной последовательности	Заданная последовательность	Найденная подпоследовательность
20	1 44 3 66 2 6 55 2 4 9 50 3 4 12 45 8 15 5 18 48	3 6 9 12 15 18
20	1 9 17 25 90 91 92 13 18 23 28 100 75 50 45 44 43 42 41 40	1 9 17 25
20	155 100 80 83 86 89 -60 -40 -20 0 20 40 60 33 33 33 0 0 0 0	-60 -40 -20 0 20 40 60

Код:

#include <stdio.h>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <deque>

using namespace std;

// вспомогательные типы
typedef vector< double > tValues;
typedef map< double, bool > tSortedValues;
typedef vector< tValues > tSequences;

// возвращает true, если первый вектор (wheer) содержит второй (what)
bool containValues( tValues& where, tValues& what )
{
   if ( what.size() > 0 )
   {
      for( int i = 0; i < where.size(); i++ )
      {
         if ( where[ i ] == what[ 0 ] )
         {
            int k = i + 1;
            int j = 1;
            for(; j < what.size() && k < where.size() && where[ k ] == what[ j ]; j++, k++ );
            return ( j == what.size() );
         }
      }
   }
   
   return false;
}

// вспомогательная функция печати последовательности
void printSequence( tValues& seq )
{
   if ( seq.size() > 1 )
   {
      double diff = seq[ 1 ] - seq[ 0 ];
      cout << "sequence: size=" << seq.size() << ", diff=" << diff << ", values = { ";
      for( int i = 0; i < seq.size(); i++ )
      {
        cout << seq[ i ] << " ";
      }
      cout << "}\n";
   }
   else
   {
      cout << "NOT a sequence" << endl;
   }
}

int main(void)
{

   int n;
   cin >> n;
   if ( n <= 0 )
   {
      cout << "Input error: wrong length of the sequence" << endl;
      return 0;
   }   

   tValues sourceValues; // вектор для входных значений, в которых мы будем искать последовательность
   for( int i = 0; i < n; i++ ) // ввод входных значений
   {
      double val;
      cin >> val;
      sourceValues.push_back( val );
   }

   // нахождение всех возможные разностей между входными значениями
   tValues diffValues;// вектор для хранения всех возможные разностей между входными значениями
   for( int i = 0; i < sourceValues.size(); i++ )
   {
      tSortedValues sortedValues;
      for( int j = 0; j < sourceValues.size(); j++ )
      {
         if ( j != i )
         {
            double diff =
               ( i < j ) ?
                  sourceValues[ j ] - sourceValues[ i ] :
                  sourceValues[ i ] - sourceValues[ j ] ;
            if ( diff > 0 )
            {
               sortedValues[ diff ] = true;
            }
        }
      }
      for( tSortedValues::iterator it = sortedValues.begin(); it != sortedValues.end(); ++it )
      {
        diffValues.push_back( it->first );
      }
   }

   // главный цикл по входным значениям
   tSequences foundSequences;// вектор векторов, в котором будем помещать все найденные последовательности
   for( int srcValIdx = 0; srcValIdx < sourceValues.size(); srcValIdx++ )
   {
      double seedVal = sourceValues[ srcValIdx ]; // начальное значение для старта поиска последовательности
      // цикл по вектору разности
      for( int diffValIdx = 0; diffValIdx < diffValues.size(); diffValIdx++ )
      {
         double diffVal = diffValues[ diffValIdx ];
         double lastVal;
         tValues candidateSeq;
         candidateSeq.push_back( seedVal );

         // поиск последовательности влево от исходного значения
         lastVal = seedVal;
         for( int j = srcValIdx - 1; j >= 0; j-- )
         {
            double prevVal = sourceValues[ j ];
            if ( prevVal == lastVal - diffVal )
            {
               candidateSeq.insert( candidateSeq.begin(), prevVal );
               lastVal = prevVal;
            }
         }

         // поиск последовательности вправо от исходного значения
         lastVal = seedVal;
         for( int j = srcValIdx + 1; j < sourceValues.size(); j++ )
         {
            double nextVal = sourceValues[ j ];
            if ( nextVal == lastVal + diffVal )
            {
               candidateSeq.push_back( nextVal );
               lastVal = nextVal;
            }
         }
         
         if ( candidateSeq.size() > 2 ) // нейденную последовательность-кандидат помещаем в вектор найденных, если длинна больше двух
         {
            foundSequences.push_back( candidateSeq );
         }
      }
   }

   // удаляем последовательности, которые включают в себя другие
   //  Удалённые последовательности заменяются на пустышки
   for( int i = 0; i < foundSequences.size(); i++ )
   {
      if ( ! foundSequences[ i ].empty() )
      {
         for( int j = 0; j < foundSequences.size(); j++ )
         {
            if ( i != j
               && foundSequences[ i ].size() >= foundSequences[ j ].size() 
               && containValues( foundSequences[ i ], foundSequences[ j ] ) )
            {
               foundSequences[ j ].clear();
            }
         }
      }
   }

    // удаляем из вектора пустышки из прошлого шага
   {
      tSequences tmp;
      for( int i = 0; i < foundSequences.size(); i++ )
      {
         if ( ! foundSequences[ i ].empty() )
         {
            tmp.push_back( foundSequences[ i ] );
         }
      }
      foundSequences = tmp;
   }
   // ищем максимальную последовательность среди найденных
   int maxSize = -1;
   int maxIndex = -1;
   for( int i = 0; i < foundSequences.size(); i++ )
   {
      int size = foundSequences[ i ].size();
      if ( size > maxSize )
      {
         maxSize  = size;
         maxIndex = i;
      }
     // printSequence( foundSequences[ i ] ); // debug 
   }

   if ( maxIndex >= 0 )
   {
      cout << "max size sequence:\n";
      printSequence( foundSequences[ maxIndex ] ); 
   }

   return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

#include <stdio.h>

#include <iostream>

#include <map>

#include <string>

#include <vector>

#include <deque>

using namespace std;

// вспомогательные типы

typedef vector< double > tValues;

typedef map< double, bool > tSortedValues;

typedef vector< tValues > tSequences;

// возвращает true, если первый вектор (wheer) содержит второй (what)

bool containValues( tValues& where, tValues& what )

{

if ( what.size() > 0 )

{

for( int i = 0; i < where.size(); i++ )

{

if ( where[ i ] == what[ 0 ] )

{

int k = i + 1;

int j = 1;

for(; j < what.size() && k < where.size() && where[ k ] == what[ j ]; j++, k++ );

return ( j == what.size() );

}

return false;

}

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

void printSequence( tValues& seq )

{

if ( seq.size() > 1 )

{

double diff = seq[ 1 ] - seq[ 0 ];

cout << "sequence: size=" << seq.size() << ", diff=" << diff << ", values = { ";

for( int i = 0; i < seq.size(); i++ )

{

cout << seq[ i ] << " ";

}

cout << "}\n";

}

else

{

cout << "NOT a sequence" << endl;

}

int main(void)

{

int n;

cin >> n;

if ( n <= 0 )

{

cout << "Input error: wrong length of the sequence" << endl;

return 0;

}

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

for( int i = 0; i < n; i++ ) // ввод входных значений

{

double val;

cin >> val;

sourceValues.push_back( val );

}

// нахождение всех возможные разностей между входными значениями

tValues diffValues;// вектор для хранения всех возможные разностей между входными значениями

for( int i = 0; i < sourceValues.size(); i++ )

{

tSortedValues sortedValues;

for( int j = 0; j < sourceValues.size(); j++ )

{

if ( j != i )

{

double diff =

( i < j ) ?

sourceValues[ j ] - sourceValues[ i ] :

sourceValues[ i ] - sourceValues[ j ] ;

if ( diff > 0 )

{

sortedValues[ diff ] = true;

}

for( tSortedValues::iterator it = sortedValues.begin(); it != sortedValues.end(); ++it )

{

diffValues.push_back( it->first );

}

// главный цикл по входным значениям

tSequences foundSequences;// вектор векторов, в котором будем помещать все найденные последовательности

for( int srcValIdx = 0; srcValIdx < sourceValues.size(); srcValIdx++ )

{

double seedVal = sourceValues[ srcValIdx ]; // начальное значение для старта поиска последовательности

// цикл по вектору разности

for( int diffValIdx = 0; diffValIdx < diffValues.size(); diffValIdx++ )

{

double diffVal = diffValues[ diffValIdx ];

double lastVal;

tValues candidateSeq;

candidateSeq.push_back( seedVal );

// поиск последовательности влево от исходного значения

lastVal = seedVal;

for( int j = srcValIdx - 1; j >= 0; j-- )

{

double prevVal = sourceValues[ j ];

if ( prevVal == lastVal - diffVal )

{

candidateSeq.insert( candidateSeq.begin(), prevVal );

lastVal = prevVal;

}

// поиск последовательности вправо от исходного значения

lastVal = seedVal;

for( int j = srcValIdx + 1; j < sourceValues.size(); j++ )

{

double nextVal = sourceValues[ j ];

if ( nextVal == lastVal + diffVal )

{

candidateSeq.push_back( nextVal );

lastVal = nextVal;

}

if ( candidateSeq.size() > 2 ) // нейденную последовательность-кандидат помещаем в вектор найденных, если длинна больше двух

{

foundSequences.push_back( candidateSeq );

}

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

// Удалённые последовательности заменяются на пустышки

for( int i = 0; i < foundSequences.size(); i++ )

{

if ( ! foundSequences[ i ].empty() )

{

for( int j = 0; j < foundSequences.size(); j++ )

{

if ( i != j

&& foundSequences[ i ].size() >= foundSequences[ j ].size()

&& containValues( foundSequences[ i ], foundSequences[ j ] ) )

{

foundSequences[ j ].clear();

}

// удаляем из вектора пустышки из прошлого шага

{

tSequences tmp;

for( int i = 0; i < foundSequences.size(); i++ )

{

if ( ! foundSequences[ i ].empty() )

{

tmp.push_back( foundSequences[ i ] );

}

foundSequences = tmp;

}

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

int maxSize = -1;

int maxIndex = -1;

for( int i = 0; i < foundSequences.size(); i++ )

{

int size = foundSequences[ i ].size();

if ( size > maxSize )

{

maxSize = size;

maxIndex = i;

}

// printSequence( foundSequences[ i ] ); // debug

}

if ( maxIndex >= 0 )

{

cout << "max size sequence:\n";

printSequence( foundSequences[ maxIndex ] );

}

return 0;

}

План

План программы:

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

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

Программа реализована с использованием шаблонных классов стандартной библиотеки vector и map. Vector используется для хранения всех используемых последовательностей, включая разности. Map используется, как временный объект для сортировки и слияния приращений, которые в ходе поиска встречаются с часто повторяющимися значениями.

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

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

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

Ссылка на ideone.com : http://ideone.com/kf13Zv

Related Images:

Ю3.35

21/12/2014 by Янішевська Альона Русланівна

Задача. [latex]\arctan(x)=x-\frac{x^{3}}{3}+\frac{x^{5}}{5}-\cdots (-1)^{n}\frac{x^{2n+1}}{2n+1}+\cdots[/latex]

Численно убедиться в справедливости равенства, для чего для заданного значения аргумента x вычислить левую его часть и разложение, стоящее в правой части, с заданной погрешностью [latex]\varepsilon[/latex]. Испытать разложение на сходимость при разных значениях аргумента, оценить скорость сходимости, для чего вывести число итераций n (слагаемых или cомножителей), необходимых для достижения заданной точности.

Тесты:

x	[latex]\varepsilon[/latex]	left	right	n	Разность	Комментарий
1	0.3	0,785398	1	0	0,214602	Пройден
0.6	0.02	0.54042	0.528	1	0.0124195	Пройден
0.7	0.0002	0.610726	0.610631	7	9.52374е-05	Пройден
0.7	0.000002	0.610726	0.610728	12	1.67214е-06	Пройден
0.7	0.00000000001	0.610726	0.610726	28	8.34648е-12	Пройден

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

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

int main() {
	double x, eps, left, right, d, s;
	cin >> x >> eps;
	int n=0;
	left=atan(x);
	right=x;
	d=fabs(left-right);
	s=x;
	while(d>eps)
	{
		n++;
		s*=(-1)*x*x;
		right+=s/(2*n+1);
		d=fabs(left-right);
	}
	cout << "left=" << left << " right=" << right << " n=" << n << " d=" << d;
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

double x, eps, left, right, d, s;

cin >> x >> eps;

int n=0;

left=atan(x);

right=x;

d=fabs(left-right);

s=x;

while(d>eps)

{

n++;

s*=(-1)*x*x;

right+=s/(2*n+1);

d=fabs(left-right);

}

cout << "left=" << left << " right=" << right << " n=" << n << " d=" << d;

return 0;

}

В начале мы подставляем аргумент x в левую часть равенства и подсчитываем ее. Затем проверяем разность между правой частью и левой, если ее модуль меньше заданного [latex]\varepsilon[/latex], то выводим результат, а если нет, то в цикле while мы считаем последовательность до тех пор пока их разность не будет меньше [latex]\varepsilon[/latex]. Последовательность задается в цикле рекурентно, поэтому т.к. первый член последовательности будет равен x, то заведем переменную s, равную x, которая будет определять чему равен числитель дроби, домножая предыдущий на [latex](-1)x^{2}[/latex] . После этого программа выводит значение левой и правой части, их разницу и количество итераций для заданной погрешности.

Код можно проверить здесь.

Решение на Java:

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

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner  in = new Scanner(System.in);
    	double x, eps, left, right, d, s;
    	int n=0;
    	x = in.nextDouble();
    	eps = in.nextDouble();
	    left=Math.atan(x);
	    right=x;
	    d=Math.abs(left-right);
	    s=x;
		while(d>eps)
		{
			n++;
			s*=(-1)*x*x;
			right+=s/(2*n+1);
			d=Math.abs(left-right);
		}
		System.out.print("left="+left+" right="+right+" n="+n+" d="+d); 
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

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

{

Scanner in = new Scanner(System.in);

double x, eps, left, right, d, s;

int n=0;

x = in.nextDouble();

eps = in.nextDouble();

left=Math.atan(x);

right=x;

d=Math.abs(left-right);

s=x;

while(d>eps)

{

n++;

s*=(-1)*x*x;

right+=s/(2*n+1);

d=Math.abs(left-right);

}

System.out.print("left="+left+" right="+right+" n="+n+" d="+d);

}

Ссылка на решение.

Related Images:

А137е

28/11/2014 by Осецимський Анатолій Вадимович

Даны натуральные [latex] n[/latex], действительные [latex] a_{1},\ldots,a_{n}[/latex].

Вывести: [latex] a_1+1!, a_2 +2!, …, a_n+n![/latex].

	n	a1	a2	a3	a4
Input:	4	1	2	3	4	Output:	2.00	4.00	9.00	28.00
Input:	4	0.1	0.2	0.3	0.4	Output:	1.10	2.20	6.30	24.40

#include <iostream>
using namespace std;

int main() {
    int n;
    double a,fact=1.0;
    scanf("%d",&n);//читаем n
    for(int k=1;k<=n;k++)
    {
        scanf("%lf",&a);//читаем из потока k-ый элемент 
        fact*=k;//увеличиваем фаториал
        printf("%.2lf ",(a+fact));//выводим сумму цифры из потока и факториала
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

double a,fact=1.0;

scanf("%d",&n);//читаем n

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

{

scanf("%lf",&a);//читаем из потока k-ый элемент

fact*=k;//увеличиваем фаториал

printf("%.2lf ",(a+fact));//выводим сумму цифры из потока и факториала

}

return 0;

}

Описываем переменную факториала и переменную из потока типа [latex]double[/latex]. Запускаем цикл [latex]for[/latex], от [latex]1[/latex] до [latex]n[/latex]. Дальше в теле цикла описываем чтение элементов, увеличение факториала и вывод суммы цифр из потока и факториала.

Ссылка на программу.

Related Images:

A405

27/11/2014 by Сіренко Валерія Сергіївна

Задача

Даны натуральное число [latex]n[/latex], действительная квадратная матрица порядка [latex]n[/latex]. Построить последовательность [latex] b_1,..,b_n[/latex] из нулей и единиц, в которой [latex] b_i = 1[/latex] тогда и только тогда, когда в [latex]i[/latex] — строке матрицы есть хотя бы один отрицательный элемент.

Тест

при [latex]n = 3[/latex]

[latex]b_1[/latex]	[latex]b_2[/latex]	[latex]b_3[/latex]	результат
0	0	0	0 1 0
0	-1	0
0	0	0

при [latex]n = 4[/latex]

[latex]b_1[/latex]	[latex]b_2[/latex]	[latex]b_3[/latex]	[latex]b_4[/latex]	результат
0	0	-1	0	1 1 0 1
0	-4	0	0
0	0	0	0
-8	0	0	0

при [latex]n=3[/latex]

[latex]b_1[/latex]	[latex]b_2[/latex]	[latex]b_3[/latex]	результат
-0.75	0.98	4.67	1 0 1
4.89	0	3.75
-9.85	0	2.65

#include <iostream>
#include <math.h>
using namespace std;
 
int main() {
	int n;
	cin >> n;
	double z[n][n], b[n];
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			cin >> z[i][j];
		}
	}
	for (int i = 0; i < n; i++)
	{
		b[i] = 0;
		for(int j = 0; j < n; j++)
			if(z[i][j] < 0)
			{
				b[i] = 1;
				break;
			}
	}
	for (int i = 0; i < n; i++)
	{
		cout << b[i] << " ";
	}
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n;

cin >> n;

double z[n][n], b[n];

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

{

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

{

cin >> z[i][j];

}

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

{

b[i] = 0;

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

if(z[i][j] < 0)

{

b[i] = 1;

break;

}

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

{

cout << b[i] << " ";

}

return 0;

}

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

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int n=in.nextInt();
		double[] b = new double[n];
		double[][] z = new double[n][n];
		for(int i = 0; i < n; i++)
		{
			for(int j = 0; j < n; j++)
			{
				z[i][j] = in.nextDouble();
			}
		}
		for (int i = 0; i < n; i++)
		{
			b[i] = 0;
			for (int j = 0; j < n; j++)
			if(z[i][j] < 0)
			{
				b[i] = 1;
				break;
				}
			}
			for (int i = 0; i < n; i++)
			{
				System.out.printf("%.1f ",b[i]);
			}
		}
	}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

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

{

Scanner in = new Scanner(System.in);

int n=in.nextInt();

double[] b = new double[n];

double[][] z = new double[n][n];

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

{

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

{

z[i][j] = in.nextDouble();

}

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

{

b[i] = 0;

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

if(z[i][j] < 0)

{

b[i] = 1;

break;

}

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

{

System.out.printf("%.1f ",b[i]);

}

Ссылка на C++:http:http://ideone.com/KzTDgC

Ссылка на Java: http://ideone.com/EIZdZt

Решение:

Вводим квадратную матрицу [latex] z[n][n][/latex] порядка [latex]n[/latex].Далее в цикле описываем, что если :

if(z[i][j] < 0)

20	if(z[i][j] < 0)

то каждый элемент [latex]b_i = 1[/latex], в противном случае [latex]b_i = 0[/latex].Далее в input вводим количество элементов и соответствующие значения и получаем ответ.

Related Images:

А136з

19/11/2014 by Фесенко Катерина Володимирівна

Задача Вычислить: [latex]-\frac{a_1}{1!}+\frac{a_2}{2!}-…+\frac{(-1)^na_n}{n!}[/latex]

Тест

n	последовательность	sum(wolframalpha)
2	0 0	0
2	5 8	-1
3	5 8 12	-3
4	1 2 3 24	1
5	0 0 0 2 3	0, 058333

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

int main() {
	int n;
	cin >> n;
	int a[n];
	for (int i=0; i<n; i++) {
		cin >> a[i];
	}
	double sum=0;
	int f=1;
	for (int i=1; i<=n; i++) {
		f*=i;
		double sign = (i%2==0) ? 1 : -1;
		sum+=(sign*a[i-1])/f;
	}
	cout << sum << endl;
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n;

cin >> n;

int a[n];

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

cin >> a[i];

}

double sum=0;

int f=1;

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

f*=i;

double sign = (i%2==0) ? 1 : -1;

sum+=(sign*a[i-1])/f;

}

cout << sum << endl;

return 0;

}

Ссылка на программу:http://ideone.com/F0UyqY

Решение:
В этой задаче главное правильно расставить знаки, так как это повлияет на результат.Поэтому мы заводим переменную [latex]sign[/latex], которая будет следить за знаком. Далее проверяем чётность, если элемент делиться на 2 без остатка, то он получает знак [latex]+[/latex], в противном случае [latex]-[/latex]:

double sign = (i%2==0) ? 1 : -1;

16	double sign = (i%2==0) ? 1 : -1;

Описываем факториал:

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

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

f*=i;

Выполняем суммирование и делим на факториал:

sum+=(sign*a[i-1])/f;

17	sum+=(sign*a[i-1])/f;

Вводим в [latex]input[/latex] количество элементов ([latex]n[/latex]) и сами элементы.Получаем ответ.

Related Images:

A159

15/11/2014 by Карташов Денис Геннадійович

Задача:

Даны натуральное число n, действительные числа [latex]a_{1}, …, a_{n}[/latex] [latex]\left( n\geq 3\right)[/latex] .

Получить [latex]b_{1}, …, b_{n-2}[/latex], где [latex]b_{i} = a_{i + 1} + a_{i + 2}[/latex], [latex]i=1, 2 , … , n-2[/latex].

Таблица:

[latex]a_{1}, …, a_{n}[/latex]	[latex]b_{1}, …, b_{n-2}[/latex]	Комментарий
1 2 3 4 5 6 7	5 7 9 11 13	Пройден
1.235 2.457 2.543 4.457 4.543 6.457 6.543	5 7 9 11 13	Пройден
9 -12 17 -10 19 -8 21	5 7 9 11 13	Пройден
-21 26 -21 28 -19 30 -17 22 -15 24 -13 26	5 7 9 11 13 5 7 9 11 13	Пройден
21 -26 21 -28 19 -30 17 -22 15 -24 13 -26	-5 -7 -9 -11 -13 -5 -7 -9 -11 -13	Пройден

Исходный код:

#include <iostream>
using namespace std;

int main() {
	double a, c, d; // Объявление переменных.
	double S;     //
	cin >> c >> d;  // Ввод значений буферных переменных. Более "с" вообще использоваться не будет.
	while(cin >> a){ // Цикл ввода данных.
		S=a+d; // Создание элементов второй последовательности.
		d=a;   // Смена элементов.
		cout <<" "<< S <<" "; //Вывод элементов.
	}
	return 0;  Конец.
}

#include <iostream>

using namespace std;

int main() {

double a, c, d; // Объявление переменных.

double S; //

cin >> c >> d; // Ввод значений буферных переменных. Более "с" вообще использоваться не будет.

while(cin >> a){ // Цикл ввода данных.

S=a+d; // Создание элементов второй последовательности.

d=a; // Смена элементов.

cout <<" "<< S <<" "; //Вывод элементов.

}

return 0; Конец.

}

Работать будет и такая версия:

#include <iostream>
using namespace std;

int main() {
	double a, c, d; // Объявление переменных.
	cin >> c >> d;  // Ввод значений буферных переменных. Более "с" вообще использоваться не будет.
	while(cin >> a){ // Цикл ввода данных.
		cout <<" "<< a+d <<" "; //Вывод элементов.
		d=a;   // Смена элементов.
	}
	return 0;  Конец.
}

#include <iostream>

using namespace std;

int main() {

double a, c, d; // Объявление переменных.

cin >> c >> d; // Ввод значений буферных переменных. Более "с" вообще использоваться не будет.

while(cin >> a){ // Цикл ввода данных.

cout <<" "<< a+d <<" "; //Вывод элементов.

d=a; // Смена элементов.

}

return 0; Конец.

}

Код на Java

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


public class Main
{
	private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	
	public static void main (String[] args) throws java.lang.Exception
	{
		Double a = 0.0;
		Double b = 0.0;
		
		while(in.nextToken() != StreamTokenizer.TT_EOF){
			a = in.nval;
			out.print(a + b);
			out.print(" ");
			b = a;
		}
		out.flush();
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

public class Main

{

private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

private static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

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

{

Double a = 0.0;

Double b = 0.0;

while(in.nextToken() != StreamTokenizer.TT_EOF){

a = in.nval;

out.print(a + b);

out.print(" ");

b = a;

}

out.flush();

}

Описание:

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

Алгоритм:

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

Ссылка на Ideone.

Related Images:

A412г

11/11/2014 by Карташов Денис Геннадійович

Задача:

Даны две целочисленные квадратные матрицы порядка 6. Найти последовательность из нулей и единиц [latex]b_{1} , … , b_{6}[/latex] такую, что [latex]b_{i} = 1[/latex], когда:

г) количество отрицательных и неотрицательных элементов [latex] i [/latex]- строки первой матрицы совпадает соответственно с количеством отрицательных и неотрицательных элементов [latex] i[/latex]-строки второй матрицы.

Матрица [latex]A[/latex]	Матрица [latex]B[/latex]	Ожидаемый результат	Комментарий
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1	1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1	1 1 1 1 1 1	Тест пройден
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1	-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1	0 0 0 0 0 0	Тест пройден
0 2 2 3 4 4 1 3 3 4 5 5 2 4 4 5 6 6 3 5 5 6 7 7 4 6 6 7 8 8 5 7 7 8 9 9	0 2 2 3 4 4 -1 3 1 4 3 5 -2 4 0 5 2 6 -3 5 -1 6 1 7 -4 6 -2 7 0 8 -5 7 -3 8 -1 9	1 0 0 0 0 0	Тест пройден
0 2 2 3 4 4 1 3 3 -4 5 5 2 4 -4 5 6 6 3 -5 5 6 7 -7 4 6 -6 -7 8 8 5 -7 7 -8 9 -9	0 2 2 3 4 4 -1 3 1 4 3 5 -2 4 0 5 2 6 -3 5 -1 6 1 7 -4 6 -2 7 0 8 -5 7 -3 8 -1 9	1 1 1 1 1 1	Тест пройден

Исходный код:

#include <iostream>
using namespace std;

void input( int a[6][6]){                        //Решил осуществить ввод данных с помощью функции.
	for(int i=0; i<6; i++){                  // Экономит место, так как мне необходимо ввести данные в два массива.
		for(int j=0; j<6; j++){          
			cin >> a[i][j];
		}
	}
}
void EQ(int a[6][6], int b[6][6], int c[6]){                // Главная функция. Ставим два счетчика, которые будут увеличивать свое значение, как только встретят отрицательный элемент в строках массивов.
	for(int i=0; i<6; i++){
	        int t=0, g=0;
		for(int j=0; j<6; j++){          // Проверка i - той строки первого массива.
			if( a[i][j] < 0 ){
				t++;             // Увеличение первого счетчика.
			}
		}
		for(int j=0; j<6; j++){          // Проверка i - той строки второго массива.
			if( b[i][j] < 0 ){
				g++;             // Увеличение второго счетчика.
			}	
		}
		c[i]= t == g? 1 : 0;  // Условие: "Если значение первого счетчика равно значению второго, то записываем в результирующий массив единицу, иначе нуль."
	}
}

void output( int a[6]){                          // Функция для печати результирующей последовательности
	for(int i=0; i<6; i++){
		cout<< a[i] <<" ";
	}
}

int main() {
	int a[6][6], b[6][6];            // Объявление массивов.
    int c[6]; 
	input(a);                        // Применение функций.
	input(b);                        
	EQ(a, b, c); 
    output (c); 
	return 0; //Конец.
}

#include <iostream>

using namespace std;

void input( int a[6][6]){ //Решил осуществить ввод данных с помощью функции.

for(int i=0; i<6; i++){ // Экономит место, так как мне необходимо ввести данные в два массива.

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

cin >> a[i][j];

}

void EQ(int a[6][6], int b[6][6], int c[6]){ // Главная функция. Ставим два счетчика, которые будут увеличивать свое значение, как только встретят отрицательный элемент в строках массивов.

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

int t=0, g=0;

for(int j=0; j<6; j++){ // Проверка i - той строки первого массива.

if( a[i][j] < 0 ){

t++; // Увеличение первого счетчика.

}

for(int j=0; j<6; j++){ // Проверка i - той строки второго массива.

if( b[i][j] < 0 ){

g++; // Увеличение второго счетчика.

}

c[i]= t == g? 1 : 0; // Условие: "Если значение первого счетчика равно значению второго, то записываем в результирующий массив единицу, иначе нуль."

}

void output( int a[6]){ // Функция для печати результирующей последовательности

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

cout<< a[i] <<" ";

}

int main() {

int a[6][6], b[6][6]; // Объявление массивов.

int c[6];

input(a); // Применение функций.

input(b);

EQ(a, b, c);

output (c);

return 0; //Конец.

}

Код на Java

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


public class Main
{
	
	private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	
	public static int nextInt() throws IOException{
		in.nextToken();
		return (int)in.nval;
	}
	
	
	public static void read(int[][] a)  throws IOException{
		int n = a.length;
		int m = a[0].length;
		for(int i = 0;  i < n; i++){
			for(int j = 0; j < m; j++){
				a[i][j] = nextInt();
			}
		}
	}
	
	
	public static void print(int[] a){
		int m = a.length;
		for(int j = 0; j < m; j++){
			out.print(a[j]);
		}
		out.println();
	}
	
	
	public static void EQ(int[][] a, int[][] b, int[] c){ 
		for(int i = 0; i < a.length; i++){
			
			int t=0, g=0;
			
			for(int j=0; j < a.length; j++){
				if( a[i][j] < 0 ){
					t++;
				}
			}
			
			for(int j=0; j < b.length; j++){
				if( b[i][j] < 0 ){
					g++;
				}	
			}
			
			c[i] = t == g? 1 : 0;
		}
	}
	
	
	public static void main (String[] args) throws java.lang.Exception
	{
		int [][] a = new int[6][6], b = new int[6][6];
		int [] c = new int [6];
		read(a);
		read(b);
		EQ(a,b,c);
		print(c);
		out.flush();
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

public class Main

{

private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

private static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

public static int nextInt() throws IOException{

in.nextToken();

return (int)in.nval;

}

public static void read(int[][] a) throws IOException{

int n = a.length;

int m = a[0].length;

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

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

a[i][j] = nextInt();

}

public static void print(int[] a){

int m = a.length;

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

out.print(a[j]);

}

out.println();

}

public static void EQ(int[][] a, int[][] b, int[] c){

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

int t=0, g=0;

for(int j=0; j < a.length; j++){

if( a[i][j] < 0 ){

t++;

}

for(int j=0; j < b.length; j++){

if( b[i][j] < 0 ){

g++;

}

c[i] = t == g? 1 : 0;

}

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

{

int [][] a = new int[6][6], b = new int[6][6];

int [] c = new int [6];

read(a);

read(b);

EQ(a,b,c);

print(c);

out.flush();

}

Описание:

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

Алгоритм:

Создаем функцию для ввода данных.
1. Создаем первый цикл для перебора строк.
2. Создаем вложенный цикл для перебора каждого элемента массива и функцию ввода данных.
Создаем главную функцию.
1. Создаем цикл, перебирающий строки массивов.
2. Создаем два счетчика.
3. Создаем первый вложенный цикл, для перебора каждого элемента второго массива.
  - В случае обнаружения отрицательных элементов, увеличиваем счетчик.
4. Создаем первый вложенный цикл, для перебора каждого элемента второго массива.
  - В случае обнаружения отрицательных элементов, увеличиваем счетчик.
5. Объявляем условие вывода данных. Так как условие находится внутри главного цикла, то будет выведено по одному значению, которое характеризует каждую строку.
Создаем функцию для печати результата.
1. Один цикл для перебора каждого элемента одномерного массива.
В функции «int main ()»:
1. Вводим значения элементов первого массива.
2. Вводим значения элементов второго массива.
3. Применяем главную функцию к данным массивам.
4. Печатаем результат.
5. Окончание работы программы.

Ссылка на Ideone.

Функция пересчета отрицательных элементов в заданной строке заданного массива.

#include <iostream>
using namespace std;
 
void check(int **arr, int m, int n, int i){
	int k = 0;
	for(int j = 0; j < n; j++){
		if(arr[i][j] < 0){
			k++;
		}
	}
	return k;
}
int main() {
	int **a = new int*[3]; 
	for(int i=0; i<3; i++){
		a[i] = new int[3];
		for( int j=0; j<3; j++){
		cin >> a[i][j];
		}
	}
	check(a, 3, 3, 1);
	return 0;
}

#include <iostream>

using namespace std;

void check(int **arr, int m, int n, int i){

int k = 0;

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

if(arr[i][j] < 0){

k++;

}

return k;

}

int main() {

int **a = new int*[3];

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

a[i] = new int[3];

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

cin >> a[i][j];

}

check(a, 3, 3, 1);

return 0;

}

Рабочий образец.

Related Images:

А136д

09/11/2014 by Швандт Максим Альбертович

Задача: Даны натуральное число [latex]n[/latex], действительные числа [latex] a_{1},\ldots,a_{n} [/latex].

Вычислить:

[latex] a^{2}{1}+\ldots+a^{2}{n} [/latex];

Тесты:

n	a	result
0	1, 2	error: out of range
2	5, 8	89
3	6, 13, 4	221
4	1, 2	error: incomplete input
7	2, 4, 8, 16, 32, 64, 128	21844

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

#include <stdio.h>


int main() {

   // рабочие переменные
   int i, n;
   double r;
   
   // ввод количества элементов суммы
   if( scanf("%d", &n) <= 0 )
   {
      printf("error: missing n\n" );
      return 0;
   }
   
   // проверка количества элементов суммы
   if( n <= 0 )
   {
      printf("error: out of range: n=%d\n", n);
      return 0;
   }
   
   // ввод чисел " а "
   for( i = 0, r = 0; i < n; i++ )
   {
      double a = 0;
      
      if( scanf("%lf", &a ) <= 0 )
      {
         printf("error: incomplete input of value #%d\n", i);
     return 0;
      }  

      // основный цикл вычисления
      r += a * a; 
   }
   
   // вывод результата
   printf("result: %lf\n", r );
   
   return 0;
}

#include <stdio.h>

int main() {

// рабочие переменные

int i, n;

double r;

// ввод количества элементов суммы

if( scanf("%d", &n) <= 0 )

{

printf("error: missing n\n" );

return 0;

}

// проверка количества элементов суммы

if( n <= 0 )

{

printf("error: out of range: n=%d\n", n);

return 0;

}

// ввод чисел " а "

for( i = 0, r = 0; i < n; i++ )

{

double a = 0;

if( scanf("%lf", &a ) <= 0 )

{

printf("error: incomplete input of value #%d\n", i);

return 0;

}

// основный цикл вычисления

r += a * a;

}

// вывод результата

printf("result: %lf\n", r );

return 0;

}

Код прогрммы на языке Java:

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

class CountApp
{
   public static Integer scanInteger( Scanner in )
   {
       return ( ( in.hasNextInt() ) ? in.nextInt() : null );
   }

   public static Double scanDouble( Scanner in )
   {
       return ( ( in.hasNextDouble() ) ? in.nextDouble() : null );
   }
   
   
   public static void main( String[] args )
   {

      // рабочие переменные
      int i, n;
      double r;
      
      // ввод количества элементов суммы
      Scanner in = new Scanner(System.in);
      
      n = scanInteger( in );
      
      if( n <= 0 )
      {
          System.out.printf("error: missing n\n" );
         return;
      }
      
      // проверка количества элементов суммы
      if( n <= 0 )
      {
          System.out.printf("error: out of range: n=%d\n", n);
         return;
      }
      
      // ввод чисел " а "
      for( i = 0, r = 0; i < n; i++ )
      {
         double a = 0;
         
         a = scanDouble( in );
         
         if( a <= 0 )
         {
             System.out.printf("error: incomplete input of value #%d\n", i);
        return;
         }  
      
         // основный цикл вычисления
         r += a * a; 
      }
      
      in.close(); 
      
      // вывод результата
       System.out.printf("result: %f\n", r );
   }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class CountApp

{

public static Integer scanInteger( Scanner in )

{

return ( ( in.hasNextInt() ) ? in.nextInt() : null );

}

public static Double scanDouble( Scanner in )

{

return ( ( in.hasNextDouble() ) ? in.nextDouble() : null );

}

public static void main( String[] args )

{

// рабочие переменные

int i, n;

double r;

// ввод количества элементов суммы

Scanner in = new Scanner(System.in);

n = scanInteger( in );

if( n <= 0 )

{

System.out.printf("error: missing n\n" );

return;

}

// проверка количества элементов суммы

if( n <= 0 )

{

System.out.printf("error: out of range: n=%d\n", n);

return;

}

// ввод чисел " а "

for( i = 0, r = 0; i < n; i++ )

{

double a = 0;

a = scanDouble( in );

if( a <= 0 )

{

System.out.printf("error: incomplete input of value #%d\n", i);

return;

}

// основный цикл вычисления

r += a * a;

}

in.close();

// вывод результата

System.out.printf("result: %f\n", r );

}

Ссылка: https://ideone.com/x0q7r4

План программы:

Назначение рабочих переменных
Ввод количества элементов суммы
Проверка ввода n
Ввод чисел » а «
Цикл вычисления
Вывод результата

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

Ссылка на ideone.com: http://ideone.com/dxXr0Q

Related Images:

А136к

05/11/2014 by Стеблинський Ігор Віталійович

Задача. Даны натуральное число [latex]n[/latex], действительные числа [latex]a_{1}\ldots a_{n}[/latex].

Вычислить: [latex]2\left(a_{1}+\ldots+a_{n} \right)^2[/latex]

Тесты:

n	введенные	результат
3	1 2 3	72
4	0 0 0 0	0
4	-5 -7 -3 -1	512
4	0.5 2.5 -0.7 2.6	48.02
3	-64 -128 63	2

#include <iostream>
#include <cmath>
using namespace std;
 
int main() {
	double a, sum;
        int n;     
	cin >> n;
	sum =  0;
	for(int i = 0; i < n; i++)
  	{
		cin >> a;
		sum += a;
  	}
	cout << 2*sum*sum;
	return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main() {

double a, sum;

int n;

cin >> n;

sum = 0;

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

{

cin >> a;

sum += a;

}

cout << 2*sum*sum;

return 0;

}

Ссылка на код: http://ideone.com/Q0cUmW

import java.util.*;
import java.lang.*;
import java.io.*;
 
/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		double a, sum, b;
                int n; 
                Scanner in = new Scanner(System.in);
		n = in.nextInt();
		b =  0;
		for(int i = 0; i < n; i++){
			a = in.nextInt();
			b += a;
  		}
  		sum = 2*b*b;
		System.out.printf("%.6f ",sum);
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */

class Ideone

{

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

{

double a, sum, b;

int n;

Scanner in = new Scanner(System.in);

n = in.nextInt();

b = 0;

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

a = in.nextInt();

b += a;

}

sum = 2*b*b;

System.out.printf("%.6f ",sum);

}

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

Ход решения:

Заводим переменную [latex]a[/latex], счётчик [latex]sum[/latex] и количество чисел [latex]n[/latex]. Присваиваем счётчику [latex]sum [/latex] значение [latex]0 [/latex] . Далее делаем цикл до [latex]n[/latex] , а в нём прибавляем значение текущего [latex]a[/latex] к счётчику [latex]sum[/latex]. При выводе возводим наш счётчик с конечной суммой всех элементов во вторую степень и умножаем на [latex]2[/latex].

Related Images:

А98

03/11/2014 by Янішевська Альона Русланівна

Задача. Пусть [latex]a_{1}=b_{1}=1; a_{k}=3b_{k-1}+2a_{k-1}; b_{k}=2a_{k-1}+b_{k-1}[/latex], [latex]k=\overline{2, \infty }[/latex]. Дано натуральное [latex]n[/latex]. Найти [latex]\sum_{i=1}^{n}\frac{2^{k}}{(1+a_{k}^{2}+b_{k}^{2})k!}[/latex].

Тесты:

n	[latex]\sum_{i=1}^{n}\frac{2^{k}}{(1+a_{k}^{2}+b_{k}^{2})k!}[/latex]	Комментарий
2	0.0596538	Пройден
4	0.0597339	Пройден
20	0.059734	Пройден

Код:

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

int main() {
      int n, a=1, as=a, b=1;
      double S=0.0, u=2.0;
      cin >> n;
      for(int i=1, k=2; i<=n; i++, k++)
      {
          a=3*b+2*a;
          b=2*as+b;
          u*=(2.0/k);
          S+=u*(1.0/(1+a*a+b*b));
          as=a; //запоминание переменной а
      }
       printf("%7lf", S);
       return 0;
 }

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n, a=1, as=a, b=1;

double S=0.0, u=2.0;

cin >> n;

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

{

a=3*b+2*a;

b=2*as+b;

u*=(2.0/k);

S+=u*(1.0/(1+a*a+b*b));

as=a; //запоминание переменной а

}

printf("%7lf", S);

return 0;

}

Для решения данной задачи понадобилось ввести переменную [latex]n[/latex], которая показывает какое количество раз нужно повторить операцию сложения. В цикле for вычисляется сумма, по заданной формуле. Далее последовательность можно задать рекурентно: чтобы каждый раз не считать [latex]\frac{2^{k}}{k!}[/latex], мы заводим переменную u, равную изначально двум, потому что k начинается с 2, и u каждый раз мы будем домножать на [latex]\frac{2}{k}[/latex]. Далее остается лишь посчитать a и b (переменная [latex]as[/latex] запоминает переменную [latex]a[/latex] для последующего вычисления переменной [latex]b[/latex]) и поставить в формулу. Для проверки выполнения программы можно воспользоваться ссылкой.

Решение на Java:

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

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner  in = new Scanner(System.in);
		int n, a=1, as=a, b=1;
		double sum=0.0, u=2.0;
		n = in.nextInt();
		for(int i=1, k=2; i<=n; i++, k++)
      	{
      		a=3*b+2*a;
      		b=2*as+b;
      		u*=(2.0/k);
      		sum+=u*(1.0/(1+a*a+b*b));
      		as=a;
      	}
       System.out.printf(Locale.US, "%.8f", sum); 
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

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

{

Scanner in = new Scanner(System.in);

int n, a=1, as=a, b=1;

double sum=0.0, u=2.0;

n = in.nextInt();

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

{

a=3*b+2*a;

b=2*as+b;

u*=(2.0/k);

sum+=u*(1.0/(1+a*a+b*b));

as=a;

}

System.out.printf(Locale.US, "%.8f", sum);

}

Ссылка на решение.

Related Images:

А136в

03/11/2014 by Янішевська Альона Русланівна

Задача. Даны натуральное число [latex]n[/latex], действительные числа [latex]a_{1},…,a_{n}[/latex]. Вычислить: [latex]\left | a_{1} \right |+…+\left | a_{n} \right |[/latex].

Тесты:

[latex]n[/latex]	[latex]a_{1},…,a_{n}[/latex]	Результат	Комментарий
7	2 -1.1 4 -3.4 -6 1 2	19.5	Пройден
3	-6.73 2.01 5.99	14.73	Пройден

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

int main() {
	int n; 
	double a, S=0;
	cin >> n;
  	for(int i=1; i<=n; i++)
  	{
		cin >> a;
		S+=fabs(a);
  	}
	cout << S;
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n;

double a, S=0;

cin >> n;

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

{

cin >> a;

S+=fabs(a);

}

cout << S;

return 0;

}

Вводим количество элементов ([latex]n[/latex]). После этого в цикле for считываем сами элементы [latex]a_{1},…,a_{n}[/latex] и вычисляем сумму их модулей. Для проверки выполнения программы можно воспользоваться ссылкой.

Related Images:

А165а

02/11/2014 by Бровко Ілля

Задача

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

a) [latex]a_{1}+a_{2}+ \cdots +a_{n}[/latex];

Элементы последовательности	Сумма элементов до отрицательного числа.
3 4 6 -2 3 1	13
2 8 -1 2 3 4 5	10
1 0 5 0 0 -1 0 0 0	6
4.2 3.2 1 -5 1 5	8.4

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

Ниже представленная сама программа (C++).

#include <iostream>
using namespace std;
 
int main() 
{
	double sum=0; 				//Сумма элементов
	double a;
	while(cin >> a && a>=0)		//чтение данных с входного потока
	{
		sum+=a;
	}
	printf("Сумма членов последовательности до первого отрицательного элемента равна %5.3lf \n",sum);
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

double sum=0; //Сумма элементов

double a;

while(cin >> a && a>=0) //чтение данных с входного потока

{

sum+=a;

}

printf("Сумма членов последовательности до первого отрицательного элемента равна %5.3lf \n",sum);

return 0;

}

Код на Java:

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

class Brovko
{
	public static void main (String[] args) throws java.lang.Exception
{
	double sum=0, a; 	
	Scanner in = new Scanner(System.in);
	while(in.hasNext())
	{
		a = in.nextDouble();
		if (a<0)
		{
			break;
		}
		sum+=a;
	}
	System.out.format("Сумма членов последовательности до первого отрицательного элемента равна %5.1f \n",sum);
}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Brovko

{

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

{

double sum=0, a;

Scanner in = new Scanner(System.in);

while(in.hasNext())

{

a = in.nextDouble();

if (a<0)

{

break;

}

sum+=a;

}

System.out.format("Сумма членов последовательности до первого отрицательного элемента равна %5.1f \n",sum);

}

Так же вы можете воспользоваться ссылкой (C++)/ссылкой (Java), для ознакомления с программой.

Related Images:

А137д

30/10/2014 by Оніщенко Олександр

Задача:

Даны натуральное число [latex]n[/latex], действительные числа [latex]a_1, … , a_n[/latex] . Вычислить:

[latex]-a_1, a_2, -a_3, … , (-1)^na_n[/latex]

Тесты:

[latex]n[/latex]	[latex]a_1, … , a_n[/latex]	[latex]-a_1, a_2, -a_3, … , (-1)^na_n[/latex]	Комментарий
4	3 -2 -3 6	-3 -2 3 6	Пройден
5	40 -30 0 34.5 0.2	-40 -30 0 -34.5 0.2	Пройден
3	126 -486.95 -20.0985	-126 -486.95 20.0985	Пройден

Код:

#include <iostream>
using namespace std;

int main() {
	int n;//Натуральное число
	double a;//Действительное число
	cin >> n; //Вводим натуральное число
	for(int i=1; i <=n; i++)
	{
		cin >> a;
		if(i%2 != 0) // Если номер n числа a - парное число,
		{           // то умножаем a на -1
			a*= -1;
		}
		cout << a  <<  endl;// Выводим a
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;//Натуральное число

double a;//Действительное число

cin >> n; //Вводим натуральное число

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

{

cin >> a;

if(i%2 != 0) // Если номер n числа a - парное число,

{ // то умножаем a на -1

a*= -1;

}

cout << a << endl;// Выводим a

}

return 0;

}

Для начала вводим число [latex]n[/latex]. Задаем цикл для ввода ряда чисел [latex]a_1, … , a_n[/latex]. Если [latex]n[/latex] — парное число, умножаем введенное [latex]a[/latex] на [latex]-1[/latex]. Выводим результат.

Ссылка Ideone

Код Java

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

class Depo
{
	public static void main (String[] args) throws java.lang.Exception
	{
		double n, a;
		Scanner in = new Scanner(System.in);
		n=in.nextDouble();
		for(int i=1; i <=n; i++){
			a=in.nextDouble();
			if(i%2 != 0){
				a*=-1;
			}
			System.out.println(a);
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Depo

{

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

{

double n, a;

Scanner in = new Scanner(System.in);

n=in.nextDouble();

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

a=in.nextDouble();

if(i%2 != 0){

a*=-1;

}

System.out.println(a);

}

Ссылка на Ideone

Related Images:

A119(a)

20/10/2014 by Карташов Денис Геннадійович

Задача:

Вычислить бесконечную сумму с заданной точностью [latex]\varepsilon \left(\varepsilon > 0\right)[/latex]. Считать что требуемая точность достигнута, если несколько первых слагаемых и очередное слагаемое оказалось по модулю меньше, чем ε, это и все последующие слагаемые можно уже не учитывать.

[latex]\sum{\frac{1}{i^2}} [/latex]


[latex]\varepsilon[/latex]	Result	Комментарий
0.0000000000000045	1.644912487	Тест пройден
0.45	1.25	Тест пройден
0	Попробуйте…	Тест пройден
>1	1	Тест пройден

#include <iostream>
#include <iomanip>
using namespace std;
 
int main(){
	double Sum =0, e=100;      //Объявление переменных, которые обозначают член последовательности и сумму членов последовательности
	double E;           //Объявление переменной, которая обозначает точность, с которой мы будем находить сумму.
	cin >> E;           //Ввод значения точности
	if(E<=0){           //Проверка условия(точность не может быть равна нулю или быть отрицательным числом, иначе нас ждет бесконечный цикл)
		cout <<"Попробуйте ввести положительное число отличное от нуля!"<<endl;
		return 1;
	}
	else{
		for(int i = 1;e > E;i++){ //Главный цикл.
			e = 1.0/(i*i); //Вычисление члена последовательности
			Sum += e;           //Суммирование элементов
		}
	}
	cout << fixed <<setprecision(10) << Sum << endl;        //Вывод результата. P.S. Я все-таки нашел этот способ.
	return 0;        //Конец
}

#include <iostream>

#include <iomanip>

using namespace std;

int main(){

double Sum =0, e=100; //Объявление переменных, которые обозначают член последовательности и сумму членов последовательности

double E; //Объявление переменной, которая обозначает точность, с которой мы будем находить сумму.

cin >> E; //Ввод значения точности

if(E<=0){ //Проверка условия(точность не может быть равна нулю или быть отрицательным числом, иначе нас ждет бесконечный цикл)

cout <<"Попробуйте ввести положительное число отличное от нуля!"<<endl;

return 1;

}

else{

for(int i = 1;e > E;i++){ //Главный цикл.

e = 1.0/(i*i); //Вычисление члена последовательности

Sum += e; //Суммирование элементов

}

cout << fixed <<setprecision(10) << Sum << endl; //Вывод результата. P.S. Я все-таки нашел этот способ.

return 0; //Конец

}

Описание:

В задаче сказано посчитать сумму членов определенной последовательности с заданной точностью.

Алгоритм:

Объявление переменных, необходимых для обозначения члена последовательности, суммы членов последовательности и точности с которой будут проходить вычисления.
Ввод значения точности.
Проверка правильности ввода:
- Отрицательное или равное нулю [latex]\varepsilon[/latex] вызовет бесконечный цикл и как следствие — превышение лимита по времени.
Создание заведомо бесконечного цикла, который прерывается, как только член последовательности станет меньше, чем заданная точность.
Вывод результата и окончание работы.

Ссылка на Ideone.

Related Images:

Ю 3.14

21/09/2014 by Байков Дмитро

Задача

Проверить численно второй замечательный предел:[latex]\lim_{x\to\infty}\left(1+\frac{1}{n}\right)^n=e[/latex] , задавая n значения 1,2,3…При каком n исследуемое выражение отличается от e менее, чем на заданную погрешность [latex]\varepsilon[/latex]?

Тесты

[latex]\varepsilon[/latex]	n	Полученное e	e	Разность	Комментарий
1.1	1	2.0000000000	2.7182818284	0.7182818284	Пройден
0.005	271	2.7132834531	2.7182818284	0.0049983753	Пройден
0.0000000314	32890950	2.7182817970	2.7182818284	0.0000000313	Пройден
0	Погрешность равна 0, тогда e=2.7182818284, а n=бесконечность				Не пройден

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

import java.util.*;
import java.lang.*;
import java.io.*;
class Limit
{
	public static void main (String[] args) throws java.lang.Exception
	{
		double ee, dife;//Описание переменных для хранения входных данных.//
		Scanner in = new Scanner(System.in);
		double E = Math.abs(in.nextDouble());//Чтение из стандартного потока ввода.// 
		int n = 0; //Присвоение значения переменной (от которой зависит цикл).//
		if (Math.abs(E) == 0)
		{
			System.out.printf("Погрешность равна 0, тогда e=" + Math.E + ", а n=infinity");
		}
		else
		{
			do //Сам цикл программы//
			{	
				n++;
				ee = Math.pow (1 + 1 / (double)n, (double)n); //Вычисление значения последовательности при n=1,2,3,..//
				dife = Math.E - ee; //Вычисление разности полученного значения и константы//
			}
			while (Math.abs(dife) > E); //Конечный критерий, при котором цикл останавливается//
			//Вывод окончательных результатов на экран//
			System.out.printf("После n=" + n + " исследуемое выражение отличается от е менее, чем на " + Math.abs(E) + ", а именно на " + dife + "\n"); 
			System.out.printf("Значение последовательности при таком n=" + ee + ", e=" + Math.E);
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Limit

{

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

{

double ee, dife;//Описание переменных для хранения входных данных.//

Scanner in = new Scanner(System.in);

double E = Math.abs(in.nextDouble());//Чтение из стандартного потока ввода.//

int n = 0; //Присвоение значения переменной (от которой зависит цикл).//

if (Math.abs(E) == 0)

{

System.out.printf("Погрешность равна 0, тогда e=" + Math.E + ", а n=infinity");

}

else

{

do //Сам цикл программы//

{

n++;

ee = Math.pow (1 + 1 / (double)n, (double)n); //Вычисление значения последовательности при n=1,2,3,..//

dife = Math.E - ee; //Вычисление разности полученного значения и константы//

}

while (Math.abs(dife) > E); //Конечный критерий, при котором цикл останавливается//

//Вывод окончательных результатов на экран//

System.out.printf("После n=" + n + " исследуемое выражение отличается от е менее, чем на " + Math.abs(E) + ", а именно на " + dife + "\n");

System.out.printf("Значение последовательности при таком n=" + ee + ", e=" + Math.E);

}

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

Для этого в цикле высчитывалось значение формулы [latex](1+\frac{1}{n})^{n}[/latex] при [latex]n\to \infty[/latex] и находилась разность [latex]dife=e-(1+\frac{1}{n})^{n}[/latex]. Если[latex]dife>\varepsilon[/latex] , то цикл заканчивался и программа запоминала последнее значение n и после этого выводила его на экран.

Код на Java

import java.util.*;
import java.lang.*;
import java.io.*;
class Limit
{
	public static void main (String[] args) throws java.lang.Exception
	{
		double ee, dife;//Описание переменных для хранения входных данных.//
		Scanner in = new Scanner(System.in);
		double E = Math.abs(in.nextDouble());//Чтение из стандартного потока ввода.// 
		int n = 0; //Присвоение значения переменной (от которой зависит цикл).//
		if (Math.abs(E) == 0)
		{
			System.out.printf("Погрешность равна 0, тогда e=" + Math.E + ", а n=infinity");
		}
		else
		{
			do //Сам цикл программы//
			{	
				n++;
				ee = Math.pow (1 + 1 / (double)n, (double)n); //Вычисление значения последовательности при n=1,2,3,..//
				dife = Math.E - ee; //Вычисление разности полученного значения и константы//
			}
			while (Math.abs(dife) > E); //Конечный критерий, при котором цикл останавливается//
			//Вывод окончательных результатов на экран//
			System.out.printf("После n=" + n + " исследуемое выражение отличается от е менее, чем на " + Math.abs(E) + ", а именно на " + dife); 
			System.out.printf("Значение последовательности при таком n=" + ee + ", e=" + Math.E);
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Limit

{

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

{

double ee, dife;//Описание переменных для хранения входных данных.//

Scanner in = new Scanner(System.in);

double E = Math.abs(in.nextDouble());//Чтение из стандартного потока ввода.//

int n = 0; //Присвоение значения переменной (от которой зависит цикл).//

if (Math.abs(E) == 0)

{

System.out.printf("Погрешность равна 0, тогда e=" + Math.E + ", а n=infinity");

}

else

{

do //Сам цикл программы//

{

n++;

ee = Math.pow (1 + 1 / (double)n, (double)n); //Вычисление значения последовательности при n=1,2,3,..//

dife = Math.E - ee; //Вычисление разности полученного значения и константы//

}

while (Math.abs(dife) > E); //Конечный критерий, при котором цикл останавливается//

//Вывод окончательных результатов на экран//

System.out.printf("После n=" + n + " исследуемое выражение отличается от е менее, чем на " + Math.abs(E) + ", а именно на " + dife);

System.out.printf("Значение последовательности при таком n=" + ee + ", e=" + Math.E);

}

Условие

Тестирование

Код

Решение

Ссылки

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Задача:

Таблица:

Исходный код:

Описание:

Алгоритм:

Related Images:

Задача:

Матрица [latex]A[/latex]

Матрица [latex]B[/latex]

Ожидаемый результат

Комментарий

Исходный код:

Описание:

Алгоритм:

Функция пересчета отрицательных элементов в заданной строке заданного массива.

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Related Images:

Задача

Тесты

Related Images: