e-olymp 6125. Простая очередь

31/03/2016 by Антон Локтев

Задача

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

push n — Добавить в очередь число n (значение n задается после команды). Программа должна вывести ok.

pop — Удалить из очереди первый элемент. Программа должна вывести его значение.

front — Программа должна вывести значение первого элемента, не удаляя его из очереди.

size — Программа должна вывести количество элементов в очереди.

clear — Программа должна очистить очередь и вывести ok.

exit — Программа должна вывести bye и завершить работу.

Гарантируется, что набор входных команд удовлетворяет следующим требованиям: максимальное количество элементов в очереди в любой момент не превосходит 100, все команды pop и front корректны, то есть при их исполнении в очереди содержится хотя бы один элемент.

Данную задачу также можно найти здесь.

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

Описаны в условии. Смотрите также тесты, расположенные ниже.

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

Описаны в условии. Смотрите также тесты, расположенные ниже.

Тесты

№	Входные данные	Выходные данные
1	push 123 size push -5 pop exit	ok 1 ok 123 bye
2	push 1 push 2 front push 42 pop exit	ok ok 1 ok 1 bye
3	push 1 push 2 pop pop size exit	ok ok 1 2 0 bye

Код

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

struct queue{
    int storage[100000];
    int start;
    int finish;
    queue(){
        start = 0;
        finish = 0;
    }

    void push(int n){
        storage[finish] = n;
        finish++;
    }

    int pop(){
        int a = storage[start];
        start++;
        return a;
    }

    int front(){
        return storage[start];
    }

    int size(){
        return finish - start;
    }

    string clear(){
        finish = 0;
        start = 0;
        return "ok";
    }

    string exit(){
        return "bye";
    }
};

int main() {
    string a;
    queue x;
    while(cin >> a){
        if(a == "push"){
            int n;
            cin >> n;
            x.push(n);
            cout << "ok" << endl;
        }
        if(a == "pop"){
            cout << x.pop() << endl;
        }
        if(a == "front"){
            cout << x.front() << endl;
        }
        if(a == "size"){
            cout << x.size() << endl;
        }
        if(a == "clear"){
            cout << x.clear() << endl;
        }
        if(a == "exit"){
            cout << x.exit() << endl;
            return 0;
        }
    }
    return 0;
}

#include <iostream>

#include <string>

using namespace std;

struct queue{

int storage[100000];

int start;

int finish;

queue(){

start = 0;

finish = 0;

}

void push(int n){

storage[finish] = n;

finish++;

}

int pop(){

int a = storage[start];

start++;

return a;

}

int front(){

return storage[start];

}

int size(){

return finish - start;

}

string clear(){

finish = 0;

start = 0;

return "ok";

}

string exit(){

return "bye";

}

};

int main() {

string a;

queue x;

while(cin >> a){

if(a == "push"){

int n;

cin >> n;

x.push(n);

cout << "ok" << endl;

}

if(a == "pop"){

cout << x.pop() << endl;

}

if(a == "front"){

cout << x.front() << endl;

}

if(a == "size"){

cout << x.size() << endl;

}

if(a == "clear"){

cout << x.clear() << endl;

}

if(a == "exit"){

cout << x.exit() << endl;

return 0;

}

return 0;

}

Ход решения

Реализуем абстрактный тип данных очередь, который отвечает принципу FIFO («первый вошёл – первый вышел») с помощью массива. Очередь имеет начало и конец, на которые указывают соответственно start и finish. Изначально очередь является пустой, поэтому start = 0, finish = 0. При добавлении нового элемента в очередь записываем его в конец. finish при этом увеличиваем на единицу. Извлекаемый же элемент берём в начале очереди, после чего start++. Если необходимо получить значение начала очереди, не извлекая его, воспользуемся функцией front(), возвращающей значение первого элемента. Для получения размера очереди используем функцию size(), которая возвращает разницу между концом и началом очереди. Если очередь нужно очистить, то приравниваем finish и start к нулю.

Ссылка на засчитанное решение находится здесь.

Код на сайте ideone.com находится здесь.

Related Images:

А282б

16/03/2016 by Антон Локтев

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

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

Данную задачу можно найти здесь.

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

Последовательность действительных чисел [latex]a_{1}[/latex], [latex]a_{2}[/latex], [latex]\ldots[/latex], [latex]a_{2n}[/latex].

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

Последовательность действительных чисел [latex]a_{1}[/latex], [latex]a_{2n}[/latex], [latex]a_{2}[/latex], [latex]a_{2n-1}[/latex], [latex]a_{3}[/latex], [latex]\ldots[/latex], [latex]a_{n}[/latex], [latex]a_{n+1}[/latex] .

Тесты

№	Входные данные	Выходные данные
1	1 2 3 4 5 6	1 6 2 5 3 4
2	0 0 0 0 0 1	0 1 0 0 0 0
3	3 12 42 -6 15 0 0 0 501 20 20 20	3 20 12 20 42 20 -6 501 15 0 0 0
4	42 0 17 -2.6 -54 41888 0.25 13 1.3333 -284.73	42 -284.73 0 1.3333 17 13 -2.6 0.25 -54 41888
5	0 1 -1 0 1 -1 97 113 -7.777 0 48 -69	0 -69 1 48 -1 0 0 -7.777 1 113 -1 97

Код

#include <iostream>
#include <vector>
using namespace std;
 
int main() {
    vector <double> sequence, result_sequence;
    double term_of_sequence;
    while (cin >> term_of_sequence){
        sequence.push_back(term_of_sequence);
    }
    for (int i = 0; i < sequence.size() / 2; i++){
        result_sequence.push_back(sequence[i]);
        result_sequence.push_back(sequence[sequence.size() - 1 - i]);
    }
    for (int i = 0; i < result_sequence.size(); i++){
        cout << result_sequence[i] << " ";
    }
    return 0;
}

#include <iostream>

#include <vector>

using namespace std;

int main() {

vector <double> sequence, result_sequence;

double term_of_sequence;

while (cin >> term_of_sequence){

sequence.push_back(term_of_sequence);

}

for (int i = 0; i < sequence.size() / 2; i++){

result_sequence.push_back(sequence[i]);

result_sequence.push_back(sequence[sequence.size() - 1 - i]);

}

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

cout << result_sequence[i] << " ";

}

return 0;

}

Код на ideone можно найти здесь.

Ход решения

Считываем все числа из входного потока и записываем их в вектор исходной последовательности sequence. Результатом работы нашей программы должна быть новая последовательность действительных чисел result_sequence, которая задаётся по следующему правилу: первый член новой последовательности совпадает с первым членом исходной, второй член новой последовательности является последним членом исходной, третий – второй член исходной и так далее до исчерпания чисел. Иными словами, новая последовательность из [latex]2n[/latex] чисел на нечётных номерах имеет члены исходной последовательности (от первого и до [latex]n[/latex]-го включительно), чётным же номерам новой последовательности соответствуют члены исходной с номерами от [latex]n+1[/latex] до [latex]2n[/latex] включительно, записанные в обратном порядке.

Related Images:

e-olymp 1080. Анаграмматическое расстояние

21/12/2015 by Антон Локтев

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

Два слова называются анаграмматически одинаковыми, если из букв одного слова можно получить другое слово. Например, occurs является анаграммой для слова succor; и наоборот, dear не является анаграммой слова dared (так как буква d встречается дважды в dared, и только один раз в dear). Наиболее известной английской анаграммой являются слова dog и god.

Анаграмматическим расстоянием двух слов называется минимальное количество букв, которые нужно удалить, чтобы в результате два слова стали анаграмматически одинаковыми. Например, для слов sleep и leap, нужно удалить как минимум три буквы — две из sleep и одну из leap — чтобы остались анаграмматически одинаковые слова (в указанном случае lep). А для слов dog и cat, в которых нет одинаковых букв, анаграмматическое расстояние равно [latex]6[/latex], так как нужно удалить все буквы (любое слово, в том числе и пустая строка, являются анаграммой само к себе).

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

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

В первой строке задано положительное целое число [latex]N[/latex] (не превышающее [latex]60000[/latex]), указывающее количество тестовых примеров. Каждый тестовый пример состоит из двух слов, возможно пустых, каждое из которых записано в отдельной строке (всего [latex]2N[/latex]последующих строк).

Все слова, имеющие не нулевую длину, сформированы из строчных букв английского алфавита (abcdefghijklmnopqrstuvwxyz). Самым длинным словом является pneumonoultramicroscopicsilicovolcanoconiosis.

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

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

Ссылка на задачу находится здесь.

Тесты

№	Входные данные	Выходные данные
1	4 crocus succor dares seared empty smell lemon	Case #1: 0 Case #2: 1 Case #3: 5 Case #4: 4
2	1	Case #1: 0
3	5 lol lolipop primate mathematics kangaroo kilimanjaro sister sisters android andromeda	Case #1: 4 Case #2: 8 Case #3: 7 Case #4: 1 Case #5: 4

Код (cstring)

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

const short maxSize = 46;

int main() {
	int n, matchingLetters;
	cin >> n;
	cin.ignore();
	char *word_1 = new char[maxSize]; 
	char *word_2 = new char[maxSize];
	for (int i = 0; i < n; i++) {
		 matchingLetters = 0;
		 cin.getline(word_1, maxSize);
		 cin.getline(word_2, maxSize);
		 for (int j = 0; j < strlen(word_1); j++) {
		 	  for (int k = 0; k < strlen(word_2); k++)  {
		 	  	   if (word_1[j] == word_2[k]) {
		 	  	   	   word_2[k] = '#';
		 	  	       matchingLetters++;
		 	  	       break;
		 	  	   }
		 	  }
		 }
		 cout << "Case #" << i + 1 << ":  " << strlen(word_1) + strlen(word_2) - 2 * matchingLetters << endl;
	}
	return 0;
}

#include <cstring>

#include <iostream>

using namespace std;

const short maxSize = 46;

int main() {

int n, matchingLetters;

cin >> n;

cin.ignore();

char *word_1 = new char[maxSize];

char *word_2 = new char[maxSize];

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

matchingLetters = 0;

cin.getline(word_1, maxSize);

cin.getline(word_2, maxSize);

for (int j = 0; j < strlen(word_1); j++) {

for (int k = 0; k < strlen(word_2); k++) {

if (word_1[j] == word_2[k]) {

word_2[k] = '#';

matchingLetters++;

break;

}

cout << "Case #" << i + 1 << ": " << strlen(word_1) + strlen(word_2) - 2 * matchingLetters << endl;

}

return 0;

}

Код на ideone можно найти здесь.

Ход решения

Наша задача состоит в определении количества символов в двух строках, которые необходимо удалить для того, чтобы слова считались анаграммами. Используем после ввода числа примеров [latex]n[/latex] функцию cin.ignore(), для игнорирования перехода на новую строку, а затем считываем по парам слова. Последовательно проходим все буквы слова в первой строке с помощью цикла for. Если находим эту букву в слове второй строки, увеличиваем счётчик совпадающих букв. Совпадающую букву во второй строке заменяем на символ #, дабы избежать повторных проверок одной и той же буквы в случае её неоднократного появления в первой строке. Общее количество букв в двух строках равняется сумме длин первой и второй строк. Таким образом, чтобы получить анаграмматическое расстояние необходимо вывести:

strlen(word_1) + strlen(word_2) - 2 * matchingLetters

26	strlen(word_1) + strlen(word_2) - 2 * matchingLetters

Умножение matchingLetters на [latex]2[/latex] возникает вследствие того, что (по факту) нужно зачёркивать символы в двух строках.

Стоит отметить, что в задаче не требуется реализовывать поиск символа самостоятельно. Можно воспользоваться уже встроенной функцией для работы со строками strchr(), которая вернёт нам указатель на искомый символ. Если символ не будет найден, функция вернёт NULL. Тогда наш код приобретает следующий вид:

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

const short maxSize = 46;

int main() {
	int n, matchingLetters;
	cin >> n;
	cin.ignore();
	char *word_1 = new char[maxSize]; 
	char *word_2 = new char[maxSize];
	for (int i = 0; i < n; i++) {
		 matchingLetters = 0;
		 cin.getline(word_1, maxSize);
		 cin.getline(word_2, maxSize);
		 for (int j = 0; j < strlen(word_1); j++) {
		 	  if (strchr(word_2, word_1[j])) {
		 	  	   *strchr(word_2, word_1[j]) = '#';
		 	  	   matchingLetters++;
		 	  }
		 }
		 cout << "Case #" << i + 1 << ":  " << strlen(word_1) + strlen(word_2) - 2 * matchingLetters << endl;
	}
	return 0;
}

#include <cstring>

#include <iostream>

using namespace std;

const short maxSize = 46;

int main() {

int n, matchingLetters;

cin >> n;

cin.ignore();

char *word_1 = new char[maxSize];

char *word_2 = new char[maxSize];

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

matchingLetters = 0;

cin.getline(word_1, maxSize);

cin.getline(word_2, maxSize);

for (int j = 0; j < strlen(word_1); j++) {

if (strchr(word_2, word_1[j])) {

*strchr(word_2, word_1[j]) = '#';

matchingLetters++;

}

cout << "Case #" << i + 1 << ": " << strlen(word_1) + strlen(word_2) - 2 * matchingLetters << endl;

}

return 0;

}

Код на ideone можно найти здесь.

Код (string)

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

int main() {
	int n, matchingLetters;
	cin >> n;
	cin.ignore();
	string word_1, word_2;
	for (int i = 0; i < n; i++) {
		 matchingLetters = 0;
		 getline(cin, word_1);
		 getline(cin, word_2);
		 for (int j = 0; j < word_1.size(); j++) {
		 	  if (word_2.find(word_1[j]) != string::npos) {
		 	  	  word_2[word_2.find(word_1[j])] = '#';
		 	  	  matchingLetters++;
		 	  }
		 }
		 cout << "Case #" << i + 1 << ":  " << word_1.size() + word_2.size() - 2 * matchingLetters << endl;
	}
	return 0;
}

#include <string>

#include <iostream>

using namespace std;

int main() {

int n, matchingLetters;

cin >> n;

cin.ignore();

string word_1, word_2;

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

matchingLetters = 0;

getline(cin, word_1);

getline(cin, word_2);

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

if (word_2.find(word_1[j]) != string::npos) {

word_2[word_2.find(word_1[j])] = '#';

matchingLetters++;

}

cout << "Case #" << i + 1 << ": " << word_1.size() + word_2.size() - 2 * matchingLetters << endl;

}

return 0;

}

В случае решения данной задачи с помощью класса string используем функцию find() для поиска заданного символа в строке.

Код на ideone можно найти здесь.

Ссылка на засчитанное решение.

Related Images:

MLoop19

28/11/2015 by Антон Локтев

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

Вычислите с заданной точностью [latex]\varepsilon[/latex]сумму ряда [latex]\sum\limits_{i=1}^{\infty}{\frac{\sqrt{i+1}}{ie^i}} [/latex].

Задачу также можно найти здесь.

Тесты

№	Точность [latex]\varepsilon[/latex]	Сумма ряда
1	0.1	0.637464
2	0.001	0.685288
3	0.0001	0.685782
4	0.000001	0.685848

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

Поскольку в данной задаче использование рекуррентной формулы приведет только к накоплению погрешности, будем считать каждое слагаемое суммы непосредственно, пока не достигнем заданной точности. Для этого зададим начальное значение переменной exponent = M_E для [latex]i=1[/latex] , а также для первого члена ряда а = sqrt(2)/ exponent. Тогда для каждого значения счетчика нам нужного всего лишь накапливать степень экспоненты и вычислять текущий член ряда по формуле [latex]\frac{\sqrt{i+1}}{i\cdot{e}^{i}} [/latex] , накапливая сумму, пока не достигнем заданной точности эпсилон.

Проверить правильность найденной суммы можно с помощью сайта WolframAlpha.

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

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

int main(){
	double exponent = M_E, a = sqrt(2)/exponent, sum = 0, E;
	cin >> E; 
	for (int i = 1; (a = sqrt(i+1)/(i * exponent)) >= E; i++){
		exponent *= M_E;
		sum += a;
	}
	cout << sum;
	return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main(){

double exponent = M_E, a = sqrt(2)/exponent, sum = 0, E;

cin >> E;

for (int i = 1; (a = sqrt(i+1)/(i * exponent)) >= E; i++){

exponent *= M_E;

sum += a;

}

cout << sum;

return 0;

}

Код программы на сайте ideone.

Related Images:

e-olymp 141. Минимальная сумма цифр

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

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

Сколько натуральных чисел из промежутка [latex][M,N][/latex] имеют наименьшую сумму цифр ?

Задачу также можно найти здесь.

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

Во входном файле два числа [latex]M[/latex] и [latex]N[/latex] ( [latex]1\le M\le N\le 1000000[/latex] ) .

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

В выходной файл нужно записать ответ — одно число.

Тесты

№	M	N	Вывод
1	1	100	3
2	2	17	1
3	32	1024	2
4	1	1000000	7
5	10	10	1

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

#include <iostream>
using namespace std;

int sumOfDigits(int a){
	int sum = 0;
	while (a > 0){
		sum += a%10;
		a /= 10;
	}
	return sum;
}

int main() {
	int m, n, sumMin, counter = 1;
	cin >> m >> n;
	sumMin = sumOfDigits(m);
	for(int i = m + 1; i <= n; i++){
		if (sumOfDigits(i) < sumMin){
			sumMin = sumOfDigits(i);
			counter = 1;
		}
		else if (sumOfDigits(i) == sumMin)   
		    counter++;
	}
	cout << counter;
	return 0;
}

#include <iostream>

using namespace std;

int sumOfDigits(int a){

int sum = 0;

while (a > 0){

sum += a%10;

a /= 10;

}

return sum;

}

int main() {

int m, n, sumMin, counter = 1;

cin >> m >> n;

sumMin = sumOfDigits(m);

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

if (sumOfDigits(i) < sumMin){

sumMin = sumOfDigits(i);

counter = 1;

}

else if (sumOfDigits(i) == sumMin)

counter++;

}

cout << counter;

return 0;

}

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

Для решения данной задачи зададим функцию, которая возвращает сумму чисел вводимого нами числа. После ввода границ необходимого промежутка присваиваем минимальную сумму (sumMin) сумме цифр первого числа [latex] M [/latex]. Теперь задаём цикл со счётчиком [latex] i [/latex] от [latex] M + 1 [/latex] до [latex]\le N[/latex]. В случае, когда сумма чисел счётчика меньше сумме цифр числа [latex] M [/latex], присваиваем ей (сумме цифр счётчика i) минимальную сумму цифр и выводим единицу. В противном случае увеличиваем счётчик на единицу и выводим полученный результат. Выводимое число и будет количеством натуральных чисел на промежутке, имеющих наименьшую сумму цифр.

Код программы можно найти здесь.

Ссылка на полностью засчитанное решение на сайте e-olymp.

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:

Mif 17.5

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

Условие

Принадлежит ли точка [latex] \left( x,y \right) [/latex] фигуре на рисунке?

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

Координаты точки [latex]\left(x,y\right)[/latex] на плоскости.

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

Если точка принадлежит фигуре, вывести «Принадлежит» (без кавычек), в противном случае — «Не принадлежит».

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

Тесты

№	x	y	Вывод
1	1	-1	Принадлежит
2	0	0	Принадлежит
3	0	4	Принадлежит
4	5	0	Принадлежит
5	0	4.00001	Не принадлежит
6	-3	5	Не принадлежит
7	2	3	Принадлежит

Решение

Фигура в задаче представлена в виде двух четвертей окружностей, лежащих в I и IV четвертях с радиусами [latex] R1 [/latex] и [latex] R2 [/latex] , которые равны соответственно [latex] 4 [/latex] и [latex] 5 [/latex]. Центры окружностей находятся в начале координатных осей. Сразу после ввода координат точки выполняем проверку принадлежности фигуре, а именно: координата [latex]X\ge0[/latex] ? В случае отрицательного ответа программа выведет сообщение «Не принадлежит». Одновременно со знаком [latex]X[/latex] выполняется проверка с помощью формулы, полученной из уравнения окружности: [latex]{\left(x-{X}_{c}\right)}^{2}+{\left(y-{Y}_{c}\right)}^{2}\le{R}^{2}[/latex], где [latex]X_{c}[/latex] и [latex]Y_{c}[/latex] — координаты центра окружности. Если координаты точки проходят данную проверку для соответствующего радиуса, который зависит от знака [latex]Y[/latex], то точка принадлежит фигуре, в противном случае выведется сообщение «Не принадлежит».

Код

#include <iostream>
using namespace std;

int main(){
	double y,Yc,x,Xc,R1,R2;
	Xc = 0; // координаты центров окружностей
	Yc = 0;
	R1 = 4; 
	R2 = 5;
	cin >> x >> y; 
	cout << ((x >= 0 && ((y > 0 && ((y - Yc)*(y - Yc) + (x - Xc)*(x - Xc)) <= R1*R1) ||
			            (y <= 0 && ((y - Yc)*(y - Yc) + (x - Xc)*(x - Xc)) <= R2*R2)))? "Принадлежит" : "Не принадлежит");
	return 0;
}

#include <iostream>

using namespace std;

int main(){

double y,Yc,x,Xc,R1,R2;

Xc = 0; // координаты центров окружностей

Yc = 0;

R1 = 4;

R2 = 5;

cin >> x >> y;

cout << ((x >= 0 && ((y > 0 && ((y - Yc)*(y - Yc) + (x - Xc)*(x - Xc)) <= R1*R1) ||

(y <= 0 && ((y - Yc)*(y - Yc) + (x - Xc)*(x - Xc)) <= R2*R2)))? "Принадлежит" : "Не принадлежит");

return 0;

}

Код на сайте ideone.com находится здесь.

Related Images:

ML 9

23/09/2015 by Антон Локтев

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

Условие:

Определить периметр правильного [latex] m [/latex]-угольника, вписанного в окружность радиуса [latex] R [/latex].

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

Количество сторон правильного многоугольника [latex] m [/latex] и радиус [latex] R [/latex] описанной около него окружности.

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

Единственное число — периметр заданного многоугольника.

Тесты:

№	m	R	P
1	3	4	20.7846
2	6	5	30
3	8	13	79.5982
4	27	20	125.38

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

#include <iostream>
#include <cmath>
using namespace std;
 
int main(){ 
	double m,R;
	cin >> m >> R;
	cout << 2*R*sin(M_PI/m)*m;
    return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

int main(){

double m,R;

cin >> m >> R;

cout << 2*R*sin(M_PI/m)*m;

return 0;

}

Код на сайте ideone.com можно получить здесь.

Убедиться в корректности формулы с помощью онлайн-калькулятора можно на этом сайте.

Решение:

Для решения данной задачи воспользуемся формулой для нахождения длины стороны правильного многоугольника с помощью радиуса описанной окружности: [latex]a=2\cdot R\cdot\sin{\frac{\pi}{m}}[/latex] , где [latex]R[/latex] — радиус описанной окружности, а [latex]m[/latex] — количество сторон правильного многоугольника. В задаче необходимо найти периметр, т.е. общую длину всех сторон: [latex]P=a\cdot m[/latex] . Таким образом, объединив формулы, получаем конечную формулу для нахождения периметра правильного многоугольника: [latex]P=\left(2\cdot R\cdot\sin{\frac{\pi}{m}}\right)\cdot m[/latex] , значение которой и необходимо вывести.

Источник формул : wikipedia.

Related Images:

e-olymp 923. Время года

14/09/2015 by Антон Локтев

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

Условие:

Определить название времени года по заданному номеру месяца, используя составные условия.

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

Одно число — номер месяца.

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

Для весенних месяцев вывести Spring, для летних — Summer, для осенних — Autumn и для зимних — Winter.

Тесты

№	Входные данные	Выходные данные
1	1	Winter
2	4	Spring
3	6	Summer
4	10	Autumn

#include <iostream>
using namespace std;
int main(){
	int a;
	cin >> a;
	cout << ((a % 12) < 3 ? "Winter" : (a % 12) < 6 ? "Spring" : (a % 12) < 9 ? "Summer" : "Autumn");
	return 0;
}

#include <iostream>

using namespace std;

int main(){

int a;

cin >> a;

cout << ((a % 12) < 3 ? "Winter" : (a % 12) < 6 ? "Spring" : (a % 12) < 9 ? "Summer" : "Autumn");

return 0;

}

Ссылку на полностью засчитанное решение на сайте e-olymp можно найти здесь.

Ссылка на ideone.

Решение:

Для решения данной задачи необходимо использовать переменную с целочисленным значением, которое соответствует порядковому номера месяца (от 1 до 12 включительно). Вводим переменную с помощью оператора [latex] cin [/latex]. Выводим, какому времени года принадлежит введённый нами месяц, используя тернарную операцию и поочерёдно проверяя, какому из условий (различные остатки от деления на 12) удовлетворяет переменная. Если остаток от деления номера месяца будет [latex]<3[/latex], то программа выведет сообщение «Winter». По аналогии проверяем остальные возможные варианты: если остаток от деления [latex]<6[/latex], [latex]<9[/latex], то появится сообщение «Spring» или «Summer» соответственно. В ином случае месяц будет осенним, а программа выведет сообщение «Autumn».