Category Archives: 7. Строки c-string

Задачи на использование char* — c-строк заканчивающихся символом с кодом 0 и/или массивов символов char[]

Попробуйте решить такую задачу:

Заяц-неудачник
Поле чудес
Реформа (Reform)
Кубики — 3 — используйте функцию сортировки, хоть это и не лучшее решение

Для приближения наших навыков к требованиям собеседований при приеме на работу выполните следующую короткую инструкцию:

Зарегистрируйтесь на сайте подготовки к собеседованиям или войдите в свой аккаунт. Будет лучше, если Вы сделаете это используя уже имеющийся аккаунт на Facebook. Для этого есть соответствующая кнопка внизу окна регистрации (sign up).
Перейдите по ссылке в раздел работы со строками. Если перейти не удалось, значит Вы ещё не выполнили предыдущий пункт инструкции.
Познакомьтесь со всеми материалами и решите все предлагаемые задачи.

e-olymp 2162. Палиндром

19/12/2015 by Кудымовская Вика

Задача. Палиндром

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

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

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

Дана строка [latex]S[/latex], [latex]|S| \leq 255[/latex], состоящая из строчных латинских букв и пробелов. Под [latex]|S|[/latex] подразумевается длина строки.

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

Требуется вывести «YES«, если текст является палиндромом, «NO» если не является.

Также условие задачи можно посмотреть здесь.

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

№	Входные данные	Выходные данные
1.	palindrom	NO
2.	a roza upala na lapu azora	YES
3.	my gym	YES
4.	character	NO

Реализация (с использованием c-string)

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

int main()
{
	const int startSize = 256;
	char s[startSize];
	char s_1[startSize];
	cin.getline(s, 256);
	int j = 0;
	for (int i = 0; i < startSize; i++)
	{
		if (s[i] == ' ') continue; 
		//учитываем, что пробел при чтении никак не произносится
		s_1[j] = s[i];
		j++;
	}
	int resSize = strlen(s_1);
	char * s_2 = new char[resSize + 1];
	for (int i = 0; i < resSize; i++)
	{
		s_2[i] = s_1[resSize - 1 - i];
	}
	s_2[resSize] = '\0';
	if (!strcmp(s_1, s_2))
	{
		cout << "YES\n";
	}
	else
	{
		cout << "NO\n";
	}
	return 0;
}

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main()

{

const int startSize = 256;

char s[startSize];

char s_1[startSize];

cin.getline(s, 256);

int j = 0;

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

{

if (s[i] == ' ') continue;

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

s_1[j] = s[i];

j++;

}

int resSize = strlen(s_1);

char * s_2 = new char[resSize + 1];

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

{

s_2[i] = s_1[resSize - 1 - i];

}

s_2[resSize] = '\0';

if (!strcmp(s_1, s_2))

{

cout << "YES\n";

}

else

{

cout << "NO\n";

}

return 0;

}

Алгоритм решения (c-string)

С помощью функции [latex]strcmp()[/latex] сравниваем символы строк [latex] s_1[/latex] и [latex]s_2[/latex], предварительно учтя тот факт, что пробел при чтении никак не произносится. Если они идентичны, введенный текст одинаково читается слева направо и справа налево, то есть является палиндромом. В противном случае, текст палиндромом не является. Важно отметить, что функция [latex]strcmp()[/latex] учитывает регистр введенных символов, согласно условию мы должны использовать строчные латинские буквы.

Для запроса на выполнение следует перейти по ссылке.

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

Реализация (с использованием string)

#include <iostream>
#include <string>
using namespace std;
 
int main() {
	string s;
    char c;
    while (cin >> c)
    {
        if (c != ' ') 
        	s.push_back(c);
    }
    if (s.empty())
    {
        cout << "YES";
        return 0;
    }
    bool palindrom = true;
    for (int i = 0; i <= s.length()/2; i++)
    {
        if (s.at(i) != s.at(s.length()-1-i))
        {
            palindrom = false;
            break;
        }
    }
    cout << (palindrom ? "YES" : "NO");
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main() {

string s;

char c;

while (cin >> c)

{

if (c != ' ')

s.push_back(c);

}

if (s.empty())

{

cout << "YES";

return 0;

}

bool palindrom = true;

for (int i = 0; i <= s.length()/2; i++)

{

if (s.at(i) != s.at(s.length()-1-i))

{

palindrom = false;

break;

}

cout << (palindrom ? "YES" : "NO");

return 0;

}

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

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

Для запроса на выполнение следует перейти по ссылке.

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

Related Images:

e-olymp 2803 МаркЕрованные кубики

17/12/2015 by Холодков Юрий

Задача

У Витека есть набор кубиков, на котором изображены английские буквы, причём как маленькие, так и большие. Недавно мама подарила ему ещё и набор кубиков с цифрами, в результате чего Витек научился быстро считать в пределах 10-ти. А вот папа имел неосторожность подарить ему набор разноцветных маркеров, после чего Витек начал экспериментировать с кубиками с цифрами: он зарисовывал очередную цифру и на её месте рисовал цифру на единицу большую. Так как он прекрасно понимал, что цифры 10 не существует, он вместо числа 10 всегда писал цифру 0.

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

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

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

Единственная строка, состоящая из описанных выше символов. Длина строки не превышает 255 символов.

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

Единственная строка – результат работы Вашей программы.

Тесты

Входные данные	Выходные данные
abc1234567890ABC	abc2345678901ABC
00000000	11111111
546476756	657587867

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

Проверяем, является ли элемент строки числом. Если это 9, заменяем ее на 1, иначе увеличиваем значение символа на 1.

#include <iostream>
using namespace std;

int main() {
	string str;
	getline(cin, str);
	for(int i = 0; i < str.length(); i++){
		if(str[i]>='0' && str[i]<'9'){
			str[i]++;
		}
		else if(str[i]=='9') str[i]='0';
	}
	cout << str;
	return 0;
}

#include <iostream>

using namespace std;

int main() {

string str;

getline(cin, str);

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

if(str[i]>='0' && str[i]<'9'){

str[i]++;

}

else if(str[i]=='9') str[i]='0';

}

cout << str;

return 0;

}

Ссылка на задачу на е-олимпе

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

Ссылка на среду с кодом

Решение через c-like string

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

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

int main() {
	int n = 256;
	char a[n];
	cin.getline(a,n);
	for(int i = 0; i < strlen(a); i++){
		a[i]-='0';
		if (a[i]>=0 && a[i]<9){
			a[i]+=1;
		}
		else if(a[i]==9) a[i]=0;
		a[i]+='0';
	}
	for(int i=0;i<strlen(a);i++){
		cout << a[i];
	}
	return 0;
}

#include <iostream>

#include <string.h>

using namespace std;

int main() {

int n = 256;

char a[n];

cin.getline(a,n);

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

a[i]-='0';

if (a[i]>=0 && a[i]<9){

a[i]+=1;

}

else if(a[i]==9) a[i]=0;

a[i]+='0';

}

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

cout << a[i];

}

return 0;

}

Cсылка на засчитанное решение с помощью c-like string

Ссылка на код в среде ideone

Related Images:

e-olymp 2164. Шифр Юлия

06/12/2015 by Андрей Яроцкий

Задача. Юлий Цезарь использовал свой способ шифрования текста. Каждая буква заменялась на следующую по алфавиту через [latex]k[/latex] позиций по кругу. Необходимо по заданной шифровке определить исходный текст.

Входные данные: В первой строке дана шифровка, состоящая из не более чем 255 заглавных латинских букв. Во второй строке число [latex]k (1[/latex] [latex]\leq[/latex] [latex]k[/latex] [latex]\leq[/latex] [latex]10)[/latex].

Выходные данные: Требуется вывести результат расшифровки.

Тесты:

№

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

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

XPSE

WORD

ZABC

WXYZ

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

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

int main() {
	const int MAX_SIZE = 256; // 256 - максимальное кол-во букв по условию + нулевой символ
	char *cipher = new char [MAX_SIZE]; 
	cin.getline (cipher,MAX_SIZE);
	int k;
	cin >> k;
	for(int i = 0; i < strlen(cipher); i++){  // Цикл дешифровки выполняется до последней буквы
		if(cipher[i] >= 'A' + k) cipher[i] -= k;
		else cipher[i] = 'Z' - (k - (cipher[i] - '@')); //cipher[i] - '@' расстояние между i-ым символом и символом 'A', где '@' - символ идущий перед символом 'A'
		/* Если полученный символ принадлежит к заглавным латинским буквам, ставим его на место зашифрованного
		   Если нет, то возвращаемся к символу "Z" и отступаем от него на k минус уже пройденное кол-во символов */
	}
	cout << cipher;
	return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

int main() {

const int MAX_SIZE = 256; // 256 - максимальное кол-во букв по условию + нулевой символ

char *cipher = new char [MAX_SIZE];

cin.getline (cipher,MAX_SIZE);

int k;

cin >> k;

for(int i = 0; i < strlen(cipher); i++){ // Цикл дешифровки выполняется до последней буквы

if(cipher[i] >= 'A' + k) cipher[i] -= k;

else cipher[i] = 'Z' - (k - (cipher[i] - '@')); //cipher[i] - '@' расстояние между i-ым символом и символом 'A', где '@' - символ идущий перед символом 'A'

/* Если полученный символ принадлежит к заглавным латинским буквам, ставим его на место зашифрованного

Если нет, то возвращаемся к символу "Z" и отступаем от него на k минус уже пройденное кол-во символов */

}

cout << cipher;

return 0;

}

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

Каждая буква строки является элементом массива [latex]cipher[/latex]. Чтобы расшифровать строку нужно от значения [latex]i[/latex]-го элемента массива отнять [latex]k[/latex], тем самым сдвинуть символ на [latex]k[/latex] единиц по алфавиту, и заменить первоначальный символ на полученный результат. В случае если разница символа [latex]i[/latex]-го элемента и числа [latex]k[/latex] не входит в множество заглавных латинских букв, требуется от символа «Z» отнять оставшееся кол-во шагов [latex]k[/latex] (то есть не считая те которые уже были пройдены от изначального символа символа до крайнего символа «A»), и заменить первоначальный символ на полученный результат. Можно не беспокоиться о том, что символ вернется к «Z» более чем один раз так как условие исключает этот вариант ([latex]k<=10[/latex] при 26-ти символах латинского алфавита).

Используя цикл, повторяющийся столько же, сколько символов в строке [latex]cipher[/latex], требуется применить описанный алгоритм к каждому элементу массива. По окончанию работы цикл, вывести строку cipher, содержащую уже расшифрованные символы.

Код программы с типом данных string:

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

int main() {
	string cipher;
	getline(cin,cipher);
	int k;
	const int ABC_SIZE = 26; // Количество символов латинского алфавита
	cin >> k;
	string alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	for(int i = 0; i < cipher.length(); i++){
	    int find = cipher[i] - 'A';
	    if(find - k < 0) cipher.at(i) = alp.at(ABC_SIZE - (k - find));
	    else cipher.at(i) = alp.at(find-k);
	}
	cout << cipher;
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main() {

string cipher;

getline(cin,cipher);

int k;

const int ABC_SIZE = 26; // Количество символов латинского алфавита

cin >> k;

string alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

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

int find = cipher[i] - 'A';

if(find - k < 0) cipher.at(i) = alp.at(ABC_SIZE - (k - find));

else cipher.at(i) = alp.at(find-k);

}

cout << cipher;

return 0;

}

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

Чтобы расшифровать слово, находящееся в строке [latex]cipher[/latex], необходимо заменить каждую букву данной строки на букву, находящуюся на [latex](find — k)[/latex] позиции строки [latex]alp[/latex], где [latex]alp[/latex] — строка, содержащая латинский алфавит, а [latex]find[/latex] — позиция заменяемой буквы в алфавите. В случае если разница [latex]find[/latex] и [latex]k[/latex] меньше нуля, заменяем букву строки [latex]cipher[/latex] на букву, находящуюся на [latex](26 — (k — find))[/latex] позиции строки [latex]alp[/latex], то-есть не считая то количество позиций которые уже были пройдены от изначального символа символа до первого символа строки [latex]alp[/latex]. Можно не беспокоиться о том, что символ вернется к к концу алфавита более чем один раз так как условие исключает этот вариант ([latex]k<=10[/latex] при 26-ти символах латинского алфавита).

Related Images:

e-olymp 901.Количество операций

03/12/2015 by Станислав Коциевский

Задача.

Определить общее количество операций сложения (+), вычитания (—) и умножения (*) в заданном арифметическом выражении.

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

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

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

Единственное число — количество указанных операций.

Тесты:

входящая строка	результат первой программы	результат второй программы	результат третей программы
-5+20-a+2*c	4	4	4
20+40-a	2	2	2
-2+2+2+2-a46-2*5-	8	8	8
2+6*6	2	2	2

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

Первый способ. Потоковая обработка символов.

#include 
using namespace std;
 
bool f (char x)
{
	return ((x<='9') || (x>='a' && x<='z') || (x>='A' && x<='Z')); //Проверяем является ли символ частью числа или переменной.
}
 
int main()
{
	char a,b,c;
	int n=0;
	a=getchar();
	b=getchar();
	while (EOF!=(c=getchar()))
	{
		if (f(a)&&f(c)&&(b=='*' || b=='-' || b=='+'))
		{
			n++;
		}
		a=b;
		b=c;
	}
	cout<<n;
	return 0;
}

#include

using namespace std;

bool f (char x)

{

return ((x<='9') || (x>='a' && x<='z') || (x>='A' && x<='Z')); //Проверяем является ли символ частью числа или переменной.

}

int main()

{

char a,b,c;

int n=0;

a=getchar();

b=getchar();

while (EOF!=(c=getchar()))

{

if (f(a)&&f(c)&&(b=='*' || b=='-' || b=='+'))

{

n++;

}

a=b;

b=c;

}

cout<<n;

return 0;

}

Второй способ. c-string.

#include <iostream>
#include <cstring>
using namespace std;
 
bool f (char x)
{
	return ((x<='9') || (x>='a' && x<='z') || (x>='A' && x<='Z')); //Проверяем является ли символ частью числа или переменной.
}
 
int main()
{
	short int k = 0;
	char s[250];
	while (cin>>s[k])
	{
		k++;
	}
	
	char * c = strpbrk (s+1, "+-*");
	short int n = 0;
	while (c!=NULL)
	{
		if (f(s[c-1 - s]) && f(s[c+1-s])&&(c-s!=k-1))
		{
			n++;
		}
		s[c-s] = ' ';
		c = strpbrk (s+1, "+-*");
	}
	cout<<n;
	return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

bool f (char x)

{

return ((x<='9') || (x>='a' && x<='z') || (x>='A' && x<='Z')); //Проверяем является ли символ частью числа или переменной.

}

int main()

{

short int k = 0;

char s[250];

while (cin>>s[k])

{

k++;

}

char * c = strpbrk (s+1, "+-*");

short int n = 0;

while (c!=NULL)

{

if (f(s[c-1 - s]) && f(s[c+1-s])&&(c-s!=k-1))

{

n++;

}

s[c-s] = ' ';

c = strpbrk (s+1, "+-*");

}

cout<<n;

return 0;

}

Третий способ. Класс string.

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

bool f (char x)
{
	return ((x<='9') || (x>='a' && x<='z') || (x>='A' && x<='Z')); //Проверяем является ли символ частью числа или переменной.
}
int NOP (string s, char c) //функция, читающая, сколько раз символ c встречается в строке s
{
	int n=0;
	
	if (s.find_first_of(c) == s.find_last_of(c)) // проверяем, больше ли вхождений символа с в троку, чем 1
	{
		if (s.find_first_of(c)<s.size() && s.find_first_of(c)>0)
			return 1;
		else
			return 0;
	}
	
	size_t i=s.find_first_of(c); //находим первое вхождение символа с и проверяем, не в наале ли он строки. Это делается отдельно, чтобы не выходить за пределы строки.
	if (i!=0)
		if (f(s[i-1])&&f(s[i+1]))
			n++;
	s.at(i) = '_';
	
	size_t q=s.find_last_of(c); //Аналогично, находим последнее вхождение символа с
	if (q == s.size()-1)
		if (f(s[i-1])&&f(s[i+1]))
			n--;
	
	while (i<q)
	{
		i=s.find_first_of(c);
		s.at(i) = '_';
		if (f(s[i-1])&&f(s[i+1]))
			n++;
	}
	return n;
}

int main()
{
	string s;
	getline(cin,s);
	cout<<NOP(s,'+')+NOP(s,'-')+NOP(s,'*');
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

bool f (char x)

{

return ((x<='9') || (x>='a' && x<='z') || (x>='A' && x<='Z')); //Проверяем является ли символ частью числа или переменной.

}

int NOP (string s, char c) //функция, читающая, сколько раз символ c встречается в строке s

{

int n=0;

if (s.find_first_of(c) == s.find_last_of(c)) // проверяем, больше ли вхождений символа с в троку, чем 1

{

if (s.find_first_of(c)<s.size() && s.find_first_of(c)>0)

return 1;

else

return 0;

}

size_t i=s.find_first_of(c); //находим первое вхождение символа с и проверяем, не в наале ли он строки. Это делается отдельно, чтобы не выходить за пределы строки.

if (i!=0)

if (f(s[i-1])&&f(s[i+1]))

n++;

s.at(i) = '_';

size_t q=s.find_last_of(c); //Аналогично, находим последнее вхождение символа с

if (q == s.size()-1)

if (f(s[i-1])&&f(s[i+1]))

n--;

while (i<q)

{

i=s.find_first_of(c);

s.at(i) = '_';

if (f(s[i-1])&&f(s[i+1]))

n++;

}

return n;

}

int main()

{

string s;

getline(cin,s);

cout<<NOP(s,'+')+NOP(s,'-')+NOP(s,'*');

return 0;

}

Решение.

Чтобы подсчитать количество операций, указанных в условии, необходимо подсчитать символы которые соответствуют этим операциям и находятся между переменными или числами. проверять только предыдущий и следующий символ на то, является ли он буквой (значит, он является частью переменной или переменная) или цифрой (значит, он является частью числа или числом). В первой программе это осуществляется потоковой обработкой символов с запоминанием последующего и предыдущего, во второй — созданием массива символов c-string и использованием функции strpbrk, в третей — созданием объекта класса string и использованием функций find_first_of, find_last_of.

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

Ссылка на условие задачи

Ссылки на зачитанные решения:

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

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

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

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

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

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

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

Related Images:

e-olymp 329. Количество слов

30/11/2015 by Молоканов Юрий

Условие

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

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

№	Входные данные	Выходные данные
1	Hello, world!	2
2	War is Peace. Freedom is Slavery. Ignorance is Strength.	9
3	— «4», «8», <15>; (16), {23}, [42]!?	6
4	A flock of sparrows – some of them juveniles – alighted and sang.	11
5	A mean Earth solar day is approximately 24 hours, whereas a mean Martian ‘sol’ is 24 hours, 39 minutes, and 35.244 seconds.	22
6	Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.	19

Код

Реализация с помощью посимвольного считывания

#include <iostream>
using namespace std;

// Проверяет, принадлежит ли символ алфавиту
bool AllowedSign(char x) {
	return ((x >= '0' && x <= '9') || (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z'))?1:0;
}

int main() {
	char x;
	int count = 0;	// Счетчик слов в предложении
	bool wordBegin = true;	// Будет ли следующий считанный символ, принадлежащий алфавиту, началом нового слова
	while(EOF != (x = getchar())) { 
		if(AllowedSign(x) && wordBegin) {	// Если текущий символ принадлежит алфавиту и ожидается новое слово
			count++;
			wordBegin = false;	// Указываем, что последующие находимые символы алфавита не будут началом слова
		} else if(x == ' ')	// Если текущий символ - пробел
			wordBegin = true;	// Указываем для следующей итерации, что текущее слово "закончилось" и ожидается новое
	}
	cout << count;
	return 0;
}

#include <iostream>

using namespace std;

// Проверяет, принадлежит ли символ алфавиту

bool AllowedSign(char x) {

return ((x >= '0' && x <= '9') || (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z'))?1:0;

}

int main() {

char x;

int count = 0; // Счетчик слов в предложении

bool wordBegin = true; // Будет ли следующий считанный символ, принадлежащий алфавиту, началом нового слова

while(EOF != (x = getchar())) {

if(AllowedSign(x) && wordBegin) { // Если текущий символ принадлежит алфавиту и ожидается новое слово

count++;

wordBegin = false; // Указываем, что последующие находимые символы алфавита не будут началом слова

} else if(x == ' ') // Если текущий символ - пробел

wordBegin = true; // Указываем для следующей итерации, что текущее слово "закончилось" и ожидается новое

}

cout << count;

return 0;

}

Реализация с помощью строк c-string

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

// Проверяет, принадлежит ли символ алфавиту
bool AllowedSign(char x) {
	return ((x >= '0' && x <= '9') || (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z'))?1:0;
}

int main() {
	const int size = 500;
	int count = 0;	// Счетчик слов в предложении
	char word[size];
	while(cin >> word) {
		bool isWord = false;	// По умолчанию считаем, что считанная последовательность символов словом не является
		for(int i = 0; i < strlen(word) && !isWord; i++)	// Проверяем символы массива, пока не дойдем до его конца или не убедимся, что считанная последовательность ялвяется словом
			if(AllowedSign(word[i])) {	// Если текущий символ принадлежит алфавиту
				count++;
				isWord = true;	// Указываем, что последовательность является словом
			}
	}
	cout << count;
	return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

// Проверяет, принадлежит ли символ алфавиту

bool AllowedSign(char x) {

return ((x >= '0' && x <= '9') || (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z'))?1:0;

}

int main() {

const int size = 500;

int count = 0; // Счетчик слов в предложении

char word[size];

while(cin >> word) {

bool isWord = false; // По умолчанию считаем, что считанная последовательность символов словом не является

for(int i = 0; i < strlen(word) && !isWord; i++) // Проверяем символы массива, пока не дойдем до его конца или не убедимся, что считанная последовательность ялвяется словом

if(AllowedSign(word[i])) { // Если текущий символ принадлежит алфавиту

count++;

isWord = true; // Указываем, что последовательность является словом

}

cout << count;

return 0;

}

Решение

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

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

Теперь перейдем к практическому решению задачи.

Реализация с помощью посимвольного считывания

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

Для решения задачи этим методом воспользуемся функцией bool AllowedSign(char x), возвращающей значение true, если переданный ей символ принадлежит алфавиту неизвестного языка, и объявим логическую переменную wordBegin, определяющую, будет ли следующий считанный символ алфавита началом нового слова, и присвоим ей до начала выполнения цикла посимвольного считывания значение true. Сам цикл будет выполняться до тех пор, пока не будет прочитан весь входной поток:

bool wordBegin = true;
while(EOF != (x = getchar()))

1 2	bool wordBegin = true; while(EOF != (x = getchar()))

При этом на каждой его итерации будут возможны, в зависимости от текущего символа и значения переменной wordBegin, следующие два варианта действий. Если считанный символ принадлежит алфавиту и при этом ожидается новое слово ( wordBegin = true), инкрементируем счетчик слов count и присваиваем wordBegin значение false. С этого момента и до тех пор, пока не будет достигнут конец слова, все последующие считываемые символы алфавита не будут влиять на счетчик:

if(AllowedSign(x) && wordBegin) {
	count++;
	wordBegin = false;
}

if(AllowedSign(x) && wordBegin) {

count++;

wordBegin = false;

}

Если же считанный символ — пробел, присваиваем wordBegin значение true. Достигнут конец текущего слова, и теперь следующий алфавитный символ, если он встретится в потоке, приведет к инкрементированию счетчика слов, так как будет принадлежать уже другому слову:

else if(x == ' ')
	wordBegin = true;

1 2	else if(x == ' ') wordBegin = true;

Как видно, неалфавитные символы (знаки препинания) игнорируются и на подсчет слов никак не влияют. Наконец, после того, как будет прочитан весь входной поток, выводится значение счетчика слов count, что и есть ответом на поставленный вопрос задачи:

cout << count;

1	cout << count;

Реализация с помощью строк c-string

Как и в предыдущем варианте решения, воспользуемся функцией AllowedSign, определяющей принадлежность символа алфавиту, а также объявим переменную bool isWord, отвечающую за то, является ли проверяемая последовательность символов словом неизвестного языка. Тогда суть метода будет заключаться в считывании из входного потока последовательностей символов и проверке того, являются ли они словами. В основе метода лежит цикл, считывающий из входного потока «потенциальные слова» до тех пор, пока это возможно:

while(cin >> word)

1	while(cin >> word)

После считывания последовательности символов присваиваем переменной isWord значение false, изначально считая, что эта последовательность словом не является:

bool isWord = false;

1	bool isWord = false;

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

for(int i = 0; i < strlen(word) && !isWord; i++)
	if(AllowedSign(word[i])) {
		count++;
		isWord = true;
	}

for(int i = 0; i < strlen(word) && !isWord; i++)

if(AllowedSign(word[i])) {

count++;

isWord = true;

}

Наконец, как и в первом случае, выводим количество найденных слов:

cout << count;

1	cout << count;

Ссылки

Условие задачи на E-Olymp;

Коды программ на Ideone.com: посимвольное считывание, строки c-string;

Подтверждение решения на E-Olymp.

Related Images:

e-olymp 7. Римские числа

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

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

e-olymp 7. Римские числа

Посчитать сумму двух натуральных чисел A и B, записанных в римской системе счисления. Ответ также записать в римской системе счисления.
M = 1000, D = 500, C = 100, L = 50, X = 10, V = 5, I = 1. Все числа – не превышают 2000.

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

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

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

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

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

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

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

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

Вспомогательные числа
В римской системе счисления	В десятичной системе счисления
1	I
4	IV
5	V
9	IX
10	X
40	XL
50	L
90	XC
100	C
400	CD
500	D
900	CM
1000	M

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

Тесты

Входные данные	Выходные данные
I+I	II
IV+VIII	XII
MM+CXC	MMCXC
CXCIX+I	CC

Реализация

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

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

int parse(char digit) {
	int result;
	switch(digit) {
		case 'I': result = 1; break;
		case 'V': result = 5; break;
		case 'X': result = 10; break;
		case 'L': result = 50; break;
		case 'C': result = 100; break;
		case 'D': result = 500; break;
		case 'M': result = 1000; break;
		default: result = 0;
	}
	return result;
}

int parse(char *number) {
	int result = 0, previous = parse(number[0]), current;
	for(int i = 1; (current = parse(number[i])) != 0; i++) {
		result += previous < current ? -previous : previous;
		previous = current;
	}
	result += previous;
	return result;
}

void print(int number) {
	char result[1000]{'\0'};
	const int values[] = { 1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000 };
	const char *symbols[] = { "I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M" };
	int counter = sizeof(symbols) / sizeof(symbols[0]) - 1 // last array element
	while(counter >= 0) {
		while(number >= values[counter]) {
			number -= values[counter];
			strcat(result, symbols[counter]);
		}
		counter--;
	}
	cout << result << endl;
}

int main() {
	char line[1000];
	cin >> line;
	char *a = strtok(line, "+");
	char *b = strtok(NULL, "");
	print(parse(a) + parse(b));
	return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

int parse(char digit) {

int result;

switch(digit) {

case 'I': result = 1; break;

case 'V': result = 5; break;

case 'X': result = 10; break;

case 'L': result = 50; break;

case 'C': result = 100; break;

case 'D': result = 500; break;

case 'M': result = 1000; break;

default: result = 0;

}

return result;

}

int parse(char *number) {

int result = 0, previous = parse(number[0]), current;

for(int i = 1; (current = parse(number[i])) != 0; i++) {

result += previous < current ? -previous : previous;

previous = current;

}

result += previous;

return result;

}

void print(int number) {

char result[1000]{'\0'};

const int values[] = { 1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000 };

const char *symbols[] = { "I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M" };

int counter = sizeof(symbols) / sizeof(symbols[0]) - 1 // last array element

while(counter >= 0) {

while(number >= values[counter]) {

number -= values[counter];

strcat(result, symbols[counter]);

}

counter--;

}

cout << result << endl;

}

int main() {

char line[1000];

cin >> line;

char *a = strtok(line, "+");

char *b = strtok(NULL, "");

print(parse(a) + parse(b));

return 0;

}

Related Images:

e-olymp 378. Таинственная записка

27/11/2015 by Таня Корнилова

Задача e-olymp 378.

Условие

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

Закодированное сообщение: HPC PJVYMIY

Декодированное сообщение: ACM CONTEST

В этом примере выполнены следующие замены: H=A, P=C, C=M, J=O, V=N, Y=T, M=E и I=S.

Чтобы не заниматься кодированием и декодированием вручную, подруги просят Вас написать программу. Помогите девочкам!

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

В первой строке входного файла записано закодированное сообщение. Вторая строка — 26 латинских букв верхнего регистра, представляющих собой код для соответствующего символа алфавита: первый символ дает код для A, второй для B и так далее. Используются только буквы верхнего регистра. В закодированном сообщении могут появиться пробелы, которые должны быть сохранены в выходной строке.

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

В выходной файл вывести одну строку, в которой содержится расшифрованное сообщение.

Тесты

Входные данные	Выходные данные
HPC PJVYMIY BLMRGJIASOPZEFDCKWYHUNXQTV	ACM CONTEST
FDY GAI BG UKMY KIMHOTSQYRLCUZPAGWJNBVDXEF	THE SKY IS BLUE
LJBSLJL IJWWDEJ KCFAGWRZMEXDNUYHVBOIJLSTPQ	DECODED MESSAGE

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

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

        //функция, которая определяет номер введённого символа в данном массиве
        int find(const char* str, char c) {
        	for(int i = 0; str[i] != '\0'; i++) {
        		if(str[i] == c) {
        			return i;
        		}
        	}
        	return -1;//если в введённой строке есть пробелы
        }
     
        int main() {
        	int n = 27, k = 1024;
        	const char *a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        	char b[k];
        	char c[n];
        	cin.getline(b, k);
        	cin.getline(c, n);
        	for(int i = 0; b[i] != '\0'; i++) {
        		int index = find(a, b[i]);
        		if(index != -1) {
        			cout << c[index];
        		} else {
        			cout << b[i];
        		}
        	}
        	return 0;
        }

#include <iostream>

#include <cstring>

using namespace std;

//функция, которая определяет номер введённого символа в данном массиве

int find(const char* str, char c) {

for(int i = 0; str[i] != '\0'; i++) {

if(str[i] == c) {

return i;

}

return -1;//если в введённой строке есть пробелы

}

int main() {

int n = 27, k = 1024;

const char *a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char b[k];

char c[n];

cin.getline(b, k);

cin.getline(c, n);

for(int i = 0; b[i] != '\0'; i++) {

int index = find(a, b[i]);

if(index != -1) {

cout << c[index];

} else {

cout << b[i];

}

return 0;

}

Для запроса на выполнение нажать здесь.

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

Код программы с использованнием класса «string»

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

int main() {
	string b, c;
	getline(cin, b);
	getline(cin, c);
	for(int i = 0; i < b.length(); i++) {
		cout << (b[i] - 'A' < 0? ' ': c[b[i] - 'A']);
	}
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main() {

string b, c;

getline(cin, b);

getline(cin, c);

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

cout << (b[i] - 'A' < 0? ' ': c[b[i] - 'A']);

}

return 0;

}

Для запроса на выполнение нажать здесь.

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

Решение

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

Related Images:

e-olymp 494. Гласные

22/11/2015 by Настя Филипчук

К гласным буквам в латинском алфавите относятся буквы A, E, I, O, U и Y. Остальные буквы считаются согласными. Напишите программу, считающую количество гласных букв в тексте.

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

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

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

В выходной файл вывести одно целое число – количество гласных во входном тексте.

Код

#include <iostream>
#include <stdio.h>
#include <cstring>
using namespace std;
int main (){
	int length,i,j,kol=0; 
	char vowel []="AEIOUY"; 
	char text [100]; 
	gets (text); //функция считывает все введённые символы с пробелами до тех пор, пока не будет нажата клавиша Enter 
	length=strlen (text); 
	for (j=0; j<=5; j++){
		for (i=0; i<=length; i++)
			if (text[i]==vowel[j])//сравниваем введённые элементы с заданными значениями строки
				kol=kol+1;
	}
	cout << kol << endl;
	return 0;
}

#include <iostream>

#include <stdio.h>

#include <cstring>

using namespace std;

int main (){

int length,i,j,kol=0;

char vowel []="AEIOUY";

char text [100];

gets (text); //функция считывает все введённые символы с пробелами до тех пор, пока не будет нажата клавиша Enter

length=strlen (text);

for (j=0; j<=5; j++){

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

if (text[i]==vowel[j])//сравниваем введённые элементы с заданными значениями строки

kol=kol+1;

}

cout << kol << endl;

return 0;

}

Код с функцией strpbrk()

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

int main ()
{
	int counter=0;
	char text[100];
	char vowel[] = "AEOUIY";
	char * pch;
	cin.getline(text,100);
	pch = strpbrk (text, vowel);
	while (pch != NULL) // пока есть гласные буквы
	{
		pch = strpbrk (pch+1,vowel); // поиск гласных букв
		counter++;
	}
	cout << counter;
	return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

int main ()

{

int counter=0;

char text[100];

char vowel[] = "AEOUIY";

char * pch;

cin.getline(text,100);

pch = strpbrk (text, vowel);

while (pch != NULL) // пока есть гласные буквы

{

pch = strpbrk (pch+1,vowel); // поиск гласных букв

counter++;

}

cout << counter;

return 0;

}

Решение

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

Реализация с использованием string

#include <iostream>
#include <string>
using namespace std;
 
int main() {
	int counter=0;
	string text; //инициализируем строку
	getline (cin,text); //извлекает строки из входного потока
	string vowel="AEOUIY"; 
	size_t found=text.find_first_of(vowel); //Поиск по строке text для первого символа, который соответствует любому элементу строки vowel
	while (found!=-1) 
	{
		counter++;
		found=text.find_first_of(vowel,found+1);
	}
	cout << counter << endl;
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main() {

int counter=0;

string text; //инициализируем строку

getline (cin,text); //извлекает строки из входного потока

string vowel="AEOUIY";

size_t found=text.find_first_of(vowel); //Поиск по строке text для первого символа, который соответствует любому элементу строки vowel

while (found!=-1)

{

counter++;

found=text.find_first_of(vowel,found+1);

}

cout << counter << endl;

return 0;

}

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

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

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

№	Входные данные	Выходные данные
1	COBBRA	2
2	REE BA	3
3	U GFD	1

Ссылки

Условие задачи можно найти на сайте e-olymp;
Засчитанное решение;
Решение задачи cфункцией strpbrk() на ideone.com;
Решение задачи с использованием string;

Related Images:

e-olymp 330. Слово-чемпион

19/11/2015 by Таран Таня

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

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

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

Предложение на неизвестном языке.

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

Номер слова-чемпиона.

Тесты

Предложение	Номер слова-чемпиона
Oo, it aaa is not bb.	3
Tummut, suuruu 18!	1
Qrtew asd x, pol 123 xcv.	3
Antaa, qor — aapapaa for Saippuakivikauppias kappak!	6
A b C d E f G h	1
NoPalindrome	0
123321 oro 1234554321?	3

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

Алгоритм

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

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

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

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

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

const int registerShift = 'A' - 'a'; // Сдвиг от верхнего регистра к нижнему по таблице ASCII

// Функция, для определения, является ли текущий символ "буквой" в контексте данной задачи
bool IsAllowedSymbol(char symbol) {
	return ((symbol >= '1' && symbol <= '9') || (symbol >= 'a' && symbol <= 'z') || (symbol >= 'A' && symbol <= 'Z')) ? true : false;
}

// Функция, для определения, является ли текущее слово палиндромом
bool IsPalindrom(char *word, int begin, int end) {
	return (end <= begin) ? true : (word[begin] != word[end]) ? false : IsPalindrom(word, ++begin, --end);
}

// Функция, которая переводит все слово в нижний регистр
void ToLowerCase(char *word) {
	 for (int i = 0; i < strlen(word); i++) {
	 	  if (word[i] >= 'A' && word[i] <= 'Z')
	 	      word[i] -= registerShift;
	 }
}

int main() {
	char word[1001];
	int wordSize, maxSize = 0, indexOfPalindrom = 0;
    for (int i = 1; cin >> word; i++) {
    	 ToLowerCase(word); // Перевод слова в нижний регистр 
    	 if (!IsAllowedSymbol(word[strlen(word) - 1]))
    	     word[strlen(word) - 1] = '\0'; // Не учитывать последний символ слова, если это не "буква" (т. е. знак препинания)
    	 wordSize = strlen(word);
    	 if (wordSize > maxSize) {
	         if (IsPalindrom(word, 0, wordSize - 1)) {
	         	 maxSize = wordSize;
	             indexOfPalindrom = i;	    
	         } // Храним новый максимум и индекс текущего наибольшего палиндрома, если он был найден
	     }
    } // Чтение по словам до конца предложения
	cout << indexOfPalindrom;
    return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

const int registerShift = 'A' - 'a'; // Сдвиг от верхнего регистра к нижнему по таблице ASCII

// Функция, для определения, является ли текущий символ "буквой" в контексте данной задачи

bool IsAllowedSymbol(char symbol) {

return ((symbol >= '1' && symbol <= '9') || (symbol >= 'a' && symbol <= 'z') || (symbol >= 'A' && symbol <= 'Z')) ? true : false;

}

// Функция, для определения, является ли текущее слово палиндромом

bool IsPalindrom(char *word, int begin, int end) {

return (end <= begin) ? true : (word[begin] != word[end]) ? false : IsPalindrom(word, ++begin, --end);

}

// Функция, которая переводит все слово в нижний регистр

void ToLowerCase(char *word) {

for (int i = 0; i < strlen(word); i++) {

if (word[i] >= 'A' && word[i] <= 'Z')

word[i] -= registerShift;

}

int main() {

char word[1001];

int wordSize, maxSize = 0, indexOfPalindrom = 0;

for (int i = 1; cin >> word; i++) {

ToLowerCase(word); // Перевод слова в нижний регистр

if (!IsAllowedSymbol(word[strlen(word) - 1]))

word[strlen(word) - 1] = '\0'; // Не учитывать последний символ слова, если это не "буква" (т. е. знак препинания)

wordSize = strlen(word);

if (wordSize > maxSize) {

if (IsPalindrom(word, 0, wordSize - 1)) {

maxSize = wordSize;

indexOfPalindrom = i;

} // Храним новый максимум и индекс текущего наибольшего палиндрома, если он был найден

}

} // Чтение по словам до конца предложения

cout << indexOfPalindrom;

return 0;

}

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

Засчитанное решение

Related Images:

А1043

21/05/2015 by Фесенко Катерина Володимирівна

Задача

Построить все правильные скобочные выражения длины 10, то есть, которые содержат по 5 левых и по 5 правых скобок.

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

#include <iostream>
#include <string>
using namespace std;
 
void f(int x, string s){
	if(s.size() == 10){cout << s << endl; return;}
	if(x>0){f(x-1,s+")");}
	if(10-s.size() > x){f(x+1,s+"(");}
}
 
int main() {
	f(0,"");
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

void f(int x, string s){

if(s.size() == 10){cout << s << endl; return;}

if(x>0){f(x-1,s+")");}

if(10-s.size() > x){f(x+1,s+"(");}

}

int main() {

f(0,"");

return 0;

}

Посмотреть программу можно здесь

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

import java.util.*;
import java.lang.*;
import java.io.*;
class Ideone {
	public static void f (int x, String s) {
		if(s.length() == 10) {
			System.out.println(s) ;
			return;
		}
		if(x>0) f(x-1,s+")");
		if(10-s.length() > x) f(x+1,s+"(");
	}
	public static void main (String[] args) {
		f(0, "");
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone {

public static void f (int x, String s) {

if(s.length() == 10) {

System.out.println(s) ;

return;

}

if(x>0) f(x-1,s+")");

if(10-s.length() > x) f(x+1,s+"(");

}

public static void main (String[] args) {

f(0, "");

}

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

Решение:

В переменной [latex]x[/latex] мы будем хранить количество открытых ([latex]»(«[/latex]) скобок. Далее проверяем условие, что если [latex]x>0[/latex], то можем поставить закрывающую ([latex]»)»[/latex]) скобку. Идем дальше, смотрим сколько свободных мест осталось и если мест осталось столько же, сколько открывающих, то все остальные закрывающие.

Related Images:

AA19

05/03/2015 by Іванов Вячеслав Володимирович

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

Алгоритм решения: Если строка не начинается с троеточия, последовательно заменять все его вхождения.

Тесты

Input	Output
the more I code … better my coding becomes	the more I code the better my coding becomes
…what am I supposed to do?	…what am I supposed to do?
abc………	abcabcabc

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

1. C, c-string,

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[]){
    if(argc){   //если при вызове функции ей были переданы аргументы
        unsigned i, size = 0;
        for(i = 1; i < argc; i++)
            size += strlen(argv[i]);
         char* s = (char*) malloc(size + 1);    //выделение памяти под строку
        
        for(i = 1; i < argc; i++)  //заполнение строки
            strcat(s, argv[i]);
            
        char replacer[3] = {s[0], s[1], s[2]};  //первые три символа строки
        
        char *pch;      //указатель на адрес первого вхождения подстроки
        //если строка содержит хотя бы одно троеточие и не начинается с него
        while((pch = strstr(s, "...")) - s < strlen(s) && pch - s ≥ 3) 
            strncpy(pch, replacer, 3);
        printf("%s\n", s);
    }
    return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main(int argc, char* argv[]){

if(argc){ //если при вызове функции ей были переданы аргументы

unsigned i, size = 0;

for(i = 1; i < argc; i++)

size += strlen(argv[i]);

char* s = (char*) malloc(size + 1); //выделение памяти под строку

for(i = 1; i < argc; i++) //заполнение строки

strcat(s, argv[i]);

char replacer[3] = {s[0], s[1], s[2]}; //первые три символа строки

char *pch; //указатель на адрес первого вхождения подстроки

//если строка содержит хотя бы одно троеточие и не начинается с него

while((pch = strstr(s, "...")) - s < strlen(s) && pch - s ≥ 3)

strncpy(pch, replacer, 3);

printf("%s\n", s);

}

return 0;

}

2. C++, string

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char* argv[]){
    if(argc){
        string s; 
        for(int i = 1; i < argc; i++)
            s += argv[i];
            
        unsigned found = -1;			//позиция вхождения подстроки
        string replacer = s.substr(0, 3);	//первые три символа строки
        //если строка содержит хотя бы одно троеточие и не начинается с него
        while((found = s.find("...")) < s.size() && found ≥ 3)
            s.replace(found, 3, replacer);
        cout << s << endl;
    }
    return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main(int argc, char* argv[]){

if(argc){

string s;

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

s += argv[i];

unsigned found = -1; //позиция вхождения подстроки

string replacer = s.substr(0, 3); //первые три символа строки

//если строка содержит хотя бы одно троеточие и не начинается с него

while((found = s.find("...")) < s.size() && found ≥ 3)

s.replace(found, 3, replacer);

cout << s << endl;

}

return 0;

}

Related Images:

А816

21/12/2014 by Царев Николай Александрович

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

Тесты*:

Инфиксная форма	Постфиксная форма	Инфиксная форма	Постфиксная форма
3+4	3 4 +	3+4*2/(1-5)^2	3 4 2 * 1 5 — 2 ^ / +
(5-4)+2	5 4 — 2 +	(1+2)*4+3	1 2 + 4 * 3 +
2(3+4)5	2 3 4 + * 5 *	78^6-3+9^(2-1)	78 6 ^ 3 — 9 2 1 — ^ +

*тесты взяты из примеров Абрамова, примеры из Википедии и немного собственных тестов.

Несколько оговорок по поводу программы:

1. Я расширил множество допустимых операторов добавив туда возведение в степень

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

3. В реализации программы через массив символов я предположил что вводимое выражение не будет превышать 50 символов. ( то есть, если учитывать пробелы, то финальная строка не будет превышать 100 символов)

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

Вообще постфиксная запись еще называется Обратной Польской Нотацией ( ОПН). За алгоритмом преобразования выражений из инфиксной ( привычной нам формы записи) в ОНП можно обратится к Википедии.

Алгоритм

Пока есть ещё символы для чтения:

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

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

Если символ является оператором о1, тогда:

1) пока приоритет o1 меньше либо равен приоритету оператора, находящегося на вершине стека выталкиваем верхние элементы стека в выходную строку;

2) помещаем оператор o1 в стек.

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

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

Реализация через <string>

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

int main() {
	string str,stack;       
	char word, word_last;
	while(cin>>word){   
		if((word>=48)&&(word<=57)){ //если символ это число
			if((word_last>=48)&&(word_last<=57)){ // Проверка, является ли предыдущий символ - числом
				str+=word; //Если да , то просто добавляем его, тем самым не разрушая число
			}
			else{
				str+=' '; // В противном  случае добавляем пробел и добавляем символ в главную строку
				str+=word;
				}
			}
			
		if(((word>=42)&&(word<=47))||(word==94)){ //если символ это операнд
			if(word=='*'){  //Замена умножения
				word='.';
				}
			if(word=='-'){ //Замена минуса
				word=',';
				}
			if(stack.empty()){ //  Если стэк пустой - то просто кладем символ в стэк
				stack+=word;
				}
			else{	 // Если стэк не пуст
				if((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){ // Если  верхний элемент стэка имеет больший приоритет 
					while((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){ //выталкиваем все элементы из стэка
						str+=' ';														//До тех пор, пока приоритет верхнего элемента не будет
						str+=stack.back();													//ниже входящего символа
						stack.pop_back();
					}
					stack+=word;
				}
				else{ // если же верхний элемент ниже приоритетом - то просто кладем символ в стэк
					stack+=word;
				}
			}
		}
		if(word=='('){ //Если символ - открывающая скобка
			stack+=word;  //добавляем ее в стэк
		}
		if(word==')'){    //Если встречающийся символ - закрывающая скобка
			while(stack.back()!='('){ // пока в стеке не встретится открывающая скобка 
				str+=' ';        // выталкиваем в главную строку  все символы
				str+=stack.back();
				stack.pop_back();
			}
		 stack.pop_back(); //Удаляем открывающую скобку из стека
		}
		
	word_last=word; //Присваиваем значение текущего символа для проверки в последующем цикле
	
		/*cout << "Numb:" << i++ << endl; // Распечатка пошаговых действий
		cout << "Word:  |" << word << endl;
		cout <<"STR:| "  << str <<"|  SRA:|" << stack << endl;*/
	}
	while(!stack.empty()){ //При окончании строки выталкиваем все символы из стека
		str+=' ';
		str+=stack.back();
		stack.pop_back();
}

	for( int i=0; i<str.length();i++){ // Проходим циклом финальную строку для возврата требуемых символов
		if(str[i]=='.')
			str[i]='*';
		if(str[i]==',')
			str[i]='-';
		}
		
	cout <<"ИТОГ:     ___  " <<  str << endl;
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

int main() {

string str,stack;

char word, word_last;

while(cin>>word){

if((word>=48)&&(word<=57)){ //если символ это число

if((word_last>=48)&&(word_last<=57)){ // Проверка, является ли предыдущий символ - числом

str+=word; //Если да , то просто добавляем его, тем самым не разрушая число

}

else{

str+=' '; // В противном случае добавляем пробел и добавляем символ в главную строку

str+=word;

}

if(((word>=42)&&(word<=47))||(word==94)){ //если символ это операнд

if(word=='*'){ //Замена умножения

word='.';

}

if(word=='-'){ //Замена минуса

word=',';

}

if(stack.empty()){ // Если стэк пустой - то просто кладем символ в стэк

stack+=word;

}

else{ // Если стэк не пуст

if((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){ // Если верхний элемент стэка имеет больший приоритет

while((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){ //выталкиваем все элементы из стэка

str+=' '; //До тех пор, пока приоритет верхнего элемента не будет

str+=stack.back(); //ниже входящего символа

stack.pop_back();

}

stack+=word;

}

else{ // если же верхний элемент ниже приоритетом - то просто кладем символ в стэк

stack+=word;

}

if(word=='('){ //Если символ - открывающая скобка

stack+=word; //добавляем ее в стэк

}

if(word==')'){ //Если встречающийся символ - закрывающая скобка

while(stack.back()!='('){ // пока в стеке не встретится открывающая скобка

str+=' '; // выталкиваем в главную строку все символы

str+=stack.back();

stack.pop_back();

}

stack.pop_back(); //Удаляем открывающую скобку из стека

}

word_last=word; //Присваиваем значение текущего символа для проверки в последующем цикле

/*cout << "Numb:" << i++ << endl; // Распечатка пошаговых действий

cout << "Word: |" << word << endl;

cout <<"STR:| " << str <<"| SRA:|" << stack << endl;*/

}

while(!stack.empty()){ //При окончании строки выталкиваем все символы из стека

str+=' ';

str+=stack.back();

stack.pop_back();

}

for( int i=0; i<str.length();i++){ // Проходим циклом финальную строку для возврата требуемых символов

if(str[i]=='.')

str[i]='*';

if(str[i]==',')

str[i]='-';

}

cout <<"ИТОГ: ___ " << str << endl;

return 0;

}

ССЫЛКА

Моменты которые следовало бы объяснить:

1) Зачем мы проверяем, является ли предыдущий символ числом, если данный тоже число?

Эта проверка помогает нам определить, сколько цифр имело наше число. Без данной проверки, например, выражение: [latex]34*2-1[/latex] будет иметь вид не [latex]34 2 * 1 — [/latex] , а [latex]3 4 2 * 1 — [/latex]. В этом случае возникает двоякость при чтении выражения. Преобразовывая обратно можно предположить, что исходное выражение было [latex]3*42-1[/latex].

2) Зачем мы делаем замену символам умножения и вычитания, в случае когда читаемый символ это оператор?

Причина состоит в том, что нам требуется правильно контролировать приоритеты операций. Если распечатать номера символов то мы увидим следующее:

numb: 40  (  numb: 41  )
numb: 42  *  numb: 43  +
numb: 44  ,  numb: 45  - 
numb: 46  .  numb: 47  /

numb: 40 ( numb: 41 )

numb: 42 * numb: 43 +

numb: 44 , numb: 45 -

numb: 46 . numb: 47 /

А по своему приоритету, операции сортируются так:

 Приоритеты:
 • ^    высокий 
 • * /  средний 
 • + -  низкий  
 • ( )  самый низкий

Приоритеты:

• ^ высокий

• * / средний

• + - низкий

• ( ) самый низкий

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

В общем, детали реализации состоят в том, что к строке stack мы обращаемся через функции, как к стеку символов. В общем — программа просто реализует описанный выше алгоритм.

Реализация через массив char

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

int main() {
	char str[100]; //строку меняем на массив символов
	vector<char> stack; // строку меняем на вектор символов
	char word, word_last;
	int n=0, i=0; // переменные для помещения элементов в массив и пошаговой распечатки
	while(cin>>word){   
		if((word>=48)&&(word<=57)){ //если символ это число
			if((word_last>=48)&&(word_last<=57)){ // Проверка, является ли предыдущий символ - числом
				str[n++]=word; //Если да , то просто добавляем его, тем самым не разрушая число
			}
			else{
				str[n++]=' '; // В противном  случае добавляем пробел и добавляем символ в главную строку
				str[n++]=word;
				}
			}
			
		if(((word>=42)&&(word<=47))||(word==94)){ //если символ это операнд
			if(word=='*'){  //Замена умножения
				word='.';
				}
			if(word=='-'){ //Замена минуса
				word=',';
				}
			if(stack.empty()){ //  Если стэк пустой - то просто кладем символ в стэк
				stack.push_back(word);
				}
			else{	 // Если стэк не пуст
				if((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){ 
					while((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){ 
						str[n++]=' ';			// Если  верхний элемент стэка имеет больший приоритет 					
						str[n++]=stack.back();	//выталкиваем все элементы из стэка							
						stack.pop_back();    	//lо тех пор, пока приоритет верхнего элемента не будет
					}							//ниже входящего символа
					stack.push_back(word);
				}
				else{ // если же верхний элемент ниже приоритетом - то просто кладем символ в стэк
					stack.push_back(word);
				}
			}
		}
		
		if(word=='('){ //Если символ - открывающая скобка
			stack.push_back(word);  //добавляем ее в стэк
		}
		
		if(word==')'){    //Если встречающийся символ - закрывающая скобка
			while(stack.back()!='('){ // пока в стэке не встретится открывающая скобка 
				str[n++]=' ';        // выталкиваем в главную строку  все символы
				str[n++]=stack.back();
				stack.pop_back();
			}
		 stack.pop_back(); //Удаляем открывающую скобку из стека
		}
		
	word_last=word; //Присваиваем значение текущего символа для проверки в последующем цикле
	
		//cout << "Numb:" << i++ << endl; // Распечатка пошаговых действий
		//cout << "Word:  |" << word << endl;
	}
	while(!stack.empty()){ //При окончании строки выталкиваем все символы из стека
		str[n++]=' ';
		str[n++]=stack.back();
		stack.pop_back();
}
	str[n]='';
	int len=strlen(str);
	for( int i=0; str[i]!='';i++){ // Проходим циклом финальную строку для возврата требуемых символов
		if(str[i]=='.')
			str[i]='*';
		if(str[i]==',')
			str[i]='-';
		}
		
	cout <<"ИТОГ:     ___  " <<  endl;
	for(int i=0; str[i]!=''; i++){
		cout << str[i];
	}
	cout << endl;
	return 0;
}

#include <iostream>

#include <vector>

using namespace std;

int main() {

char str[100]; //строку меняем на массив символов

vector<char> stack; // строку меняем на вектор символов

char word, word_last;

int n=0, i=0; // переменные для помещения элементов в массив и пошаговой распечатки

while(cin>>word){

if((word>=48)&&(word<=57)){ //если символ это число

if((word_last>=48)&&(word_last<=57)){ // Проверка, является ли предыдущий символ - числом

str[n++]=word; //Если да , то просто добавляем его, тем самым не разрушая число

}

else{

str[n++]=' '; // В противном случае добавляем пробел и добавляем символ в главную строку

str[n++]=word;

}

if(((word>=42)&&(word<=47))||(word==94)){ //если символ это операнд

if(word=='*'){ //Замена умножения

word='.';

}

if(word=='-'){ //Замена минуса

word=',';

}

if(stack.empty()){ // Если стэк пустой - то просто кладем символ в стэк

stack.push_back(word);

}

else{ // Если стэк не пуст

if((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){

while((stack.back()>=word)||(stack.back()==word-1)||(stack.back()==word+1)){

str[n++]=' '; // Если верхний элемент стэка имеет больший приоритет

str[n++]=stack.back(); //выталкиваем все элементы из стэка

stack.pop_back(); //lо тех пор, пока приоритет верхнего элемента не будет

} //ниже входящего символа

stack.push_back(word);

}

else{ // если же верхний элемент ниже приоритетом - то просто кладем символ в стэк

stack.push_back(word);

}

if(word=='('){ //Если символ - открывающая скобка

stack.push_back(word); //добавляем ее в стэк

}

if(word==')'){ //Если встречающийся символ - закрывающая скобка

while(stack.back()!='('){ // пока в стэке не встретится открывающая скобка

str[n++]=' '; // выталкиваем в главную строку все символы

str[n++]=stack.back();

stack.pop_back();

}

stack.pop_back(); //Удаляем открывающую скобку из стека

}

word_last=word; //Присваиваем значение текущего символа для проверки в последующем цикле

//cout << "Numb:" << i++ << endl; // Распечатка пошаговых действий

//cout << "Word: |" << word << endl;

}

while(!stack.empty()){ //При окончании строки выталкиваем все символы из стека

str[n++]=' ';

str[n++]=stack.back();

stack.pop_back();

}

str[n]='';

int len=strlen(str);

for( int i=0; str[i]!='';i++){ // Проходим циклом финальную строку для возврата требуемых символов

if(str[i]=='.')

str[i]='*';

if(str[i]==',')

str[i]='-';

}

cout <<"ИТОГ: ___ " << endl;

for(int i=0; str[i]!=''; i++){

cout << str[i];

}

cout << endl;

return 0;

}

ССЫЛКА

В общем, реализация не особо отличается от предыдущей. Алгоритм тот же, детали и идеи те же. Разница лишь в используемых инструментах. Теперь, вместо строки типа string мы используем массив символов. И как следствие, нам требуется ввести переменную ( в нашей программе — n) которая будет контролировать номер ячейки в которую будет присваиваться символ. Так же, после все обработки, требуется вставить дополнительно символ окончания строки ». После этого можно обращаться и форматировать строку, по нашей надобности.

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

Related Images:

Ю12.29

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

Задача: Скобки. Текст ( например, арифметическое выражение) содержит многократно вложенные круглые скобки. Исправить его, оставив скобки первого уровня круглыми, второго — заменить на квадратные, третьего и последующих — на фигурные. Убедиться в корректности использования скобок.

Тесты:

Введенная строка	Выведенная строка
ln(sin((a+b)c-d))	ln{sin[(a+b)c-d]}
ln(sin((a+b)c-d))+ln(sin((a+b)c-d))	ln{sin[(a+b)c-d]}+ln{sin[(a+b)c-d]}
cos((a-b)c)	cos[(a-b)c]

Код string

#include <string>
#include <iostream>

using namespace std;

int main()
{
	string s;
	cin >> s;
	int l = 0;
	int maxl = 0;
	for( int i = 0 ; i < s.length() ; i++ )
	{
		if( s[i] == '(' )
		{
			s[i] = '{';
			l++;
			if( l > maxl )
			{
				maxl = l;
			}
		}
		if( s[i] == ')' )
		{
			s[i] = '}';
			l--;
		}
	}
	for( int i=0 ; i < s.length() ; i++ )
	{
		
		if( s[i] == '{' )
		{
			l++;
			if( l == maxl ) s[i] = '(';
			if( l == maxl-1 ) s[i] = '[';
		}
		if( s[i] == '}' )
		{
			if( l == maxl ) s[i] = ')';
			if( l == maxl-1 ) s[i] = ']';
			l--;
		}
	}
	cout << s << endl;
}

#include <string>

#include <iostream>

using namespace std;

int main()

{

string s;

cin >> s;

int l = 0;

int maxl = 0;

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

{

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

{

s[i] = '{';

l++;

if( l > maxl )

{

maxl = l;

}

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

{

s[i] = '}';

l--;

}

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

{

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

{

l++;

if( l == maxl ) s[i] = '(';

if( l == maxl-1 ) s[i] = '[';

}

if( s[i] == '}' )

{

if( l == maxl ) s[i] = ')';

if( l == maxl-1 ) s[i] = ']';

l--;

}

cout << s << endl;

}

Код c-string

#include <cstring>
#include <iostream>

using namespace std;

int main()
{
	char s[100];
	cin >> s;
	int l = 0;
	int maxl = 0;
	for( int i=0 ; i < strlen(s); i++ )
	{
		if( s[i] == '(' )
		{
			s[i] = '{';
			l++;
			if( l > maxl )
			{
				maxl = l;
			}
		}
		if( s[i] == ')' )
		{
			s[i] = '}';
			l--;
		}
	}
	for( int i=0 ; i < strlen(s); i++ )
	{
		
		if( s[i] == '{' )
		{
			l++;
			if( l == maxl ) s[i] = '(';
			if( l == maxl-1 ) s[i] = '[';
		}
		if( s[i] == '}' )
		{
			if( l == maxl ) s[i] = ')';
			if( l == maxl-1 ) s[i] = ']';
			l--;
		}
	}
	cout << s << endl;
}

#include <cstring>

#include <iostream>

using namespace std;

int main()

{

char s[100];

cin >> s;

int l = 0;

int maxl = 0;

for( int i=0 ; i < strlen(s); i++ )

{

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

{

s[i] = '{';

l++;

if( l > maxl )

{

maxl = l;

}

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

{

s[i] = '}';

l--;

}

for( int i=0 ; i < strlen(s); i++ )

{

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

{

l++;

if( l == maxl ) s[i] = '(';

if( l == maxl-1 ) s[i] = '[';

}

if( s[i] == '}' )

{

if( l == maxl ) s[i] = ')';

if( l == maxl-1 ) s[i] = ']';

l--;

}

cout << s << endl;

}

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

string

c-string

Ход решения:

Вводим строку. Задаем две переменные: l — уровень вложенности скобок и maxl — максимальный уровень вложенности скобок. Делаем цикл в котором заменяем все ‘(‘ , ‘)’ скобки на ‘{‘ , ‘}’. Делаем второй цикл в котором меняем скобки, которые являются последними по уровню вложенности на ‘(‘, ‘)’ и скобки, стоящие на уровень ниже меняем на ‘[‘, ‘]’, все остальные скобки оставляем без изменений.

Related Images:

А812ж

20/12/2014 by Ковальський Олександр Дмитрович

Задача.

Дан текст, каждый символ которого может быть малой буквой, цифрой или одним из знаков +, -, *. Группой букв будем называть такую совокупность последовательно расположенных букв, которой непосредственно не предшествует и за которой непосредственно не следует буква. Аналогично определим группу цифр и группу знаков.

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

Тесты.

Ввод	Вывод
1aa2bb+-c2cc—**22	22
11aa2bb+-c2cc—**22	11
1aa2bb+-c23cc—**22	23
111aa2bb+-c2cc—**22	111
1aa2bb+-c234cc—**22	234
1aa221bb+-c234cc—**22	221

Код программы (string):

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

int main() 
	{
		string s;
		cin>>s;
		int k=0,n=0,a;
		for(int i=0;i<s.length()+1;i++)
			{
				if(n<k) n=k;
				if(isdigit(s[i])) k=k+1;
				else k=0;
			}
		for(int i=s.length();i>=-1;i--)
			{
				if(k==n) a=i+1;
				if(isdigit(s[i])) k=k+1;
				else k=0;
			}
		for(int i=a;i<a+n;i++)
			{
				cout<<s[i];
			}
		return 0;
	}

#include <iostream>

#include <string>

using namespace std;

int main()

{

string s;

cin>>s;

int k=0,n=0,a;

for(int i=0;i<s.length()+1;i++)

{

if(n<k) n=k;

if(isdigit(s[i])) k=k+1;

else k=0;

}

for(int i=s.length();i>=-1;i--)

{

if(k==n) a=i+1;

if(isdigit(s[i])) k=k+1;

else k=0;

}

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

{

cout<<s[i];

}

return 0;

}

Код программы (cstring):

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

int main() 
	{
		char *s;
		s=new char[100];
		cin>>s;
		int k=0,n=0,a;
		for(int i=0;i<strlen(s)+1;i++)
			{
				if(n<k) n=k;
				if(isdigit(s[i])) k=k+1;
				else k=0;
			}
		for(int i=strlen(s);i>=-1;i--)
			{
				if(k==n) a=i+1;
				if(isdigit(s[i])) k=k+1;
				else k=0;
			}
		for(int i=a;i<a+n;i++)
			{
				cout<<s[i];
			}
		return 0;
	}

#include <iostream>

#include <cstring>

using namespace std;

int main()

{

char *s;

s=new char[100];

cin>>s;

int k=0,n=0,a;

for(int i=0;i<strlen(s)+1;i++)

{

if(n<k) n=k;

if(isdigit(s[i])) k=k+1;

else k=0;

}

for(int i=strlen(s);i>=-1;i--)

{

if(k==n) a=i+1;

if(isdigit(s[i])) k=k+1;

else k=0;

}

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

{

cout<<s[i];

}

return 0;

}

Решение.

Вводим строку в переменную s. В первом цикле ищем наибольшую группу записывая значение в переменную n. В следующем цикле ищем номер первого символа в группе записывая значение в переменную a. В третьем цикле выводим символы с номерами с a-го по a+n.

Related Images:

Ю12.34

20/12/2014 by Недомовний Владислав

Задача.

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

Тесты.

Ввод	Вывод	Комментарий
programming	a in on go no an man am or arm air ring ago pain grin rain mom main among roar grip pair rip map nor aim iron program pin ma moan groan gang gain rag pig piano ramp gin ram rig	Пройден
polymorphism	is his him my so or room sir ship lip slip mom shop simply pop rip poor pool sip oil holy hip limp hop prop spy loom	Пройден

В качестве словаря используется список 2500 наиболее употребительных английских слов (составлен Александром Васильевым).

Код(string).

#include <iostream>
using namespace std;

int main() {
	string word; //описание строк для хранения исходного слова и слов из словаря
	cin >> word;
	string dict;
	bool b1,b2; //описание вспомогательных переменных
	string temp;
	while (cin >> dict)
	{
		temp=word;
		b1=true; 
		for (size_t j=0;j<dict.length();j++) // проверяем или все символы из dict содержатся в temp
		{
			b2=false;
			for (size_t i=0;i<temp.length();i++)
			{
				if(dict[j]==temp[i])
				{
					b2=true;
					temp[i]='.';
					break;
				}
			}
			if (!b2)
			{
				b1=false;
				break;
			}
		}
		if (b1) cout << dict << " ";
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

string word; //описание строк для хранения исходного слова и слов из словаря

cin >> word;

string dict;

bool b1,b2; //описание вспомогательных переменных

string temp;

while (cin >> dict)

{

temp=word;

b1=true;

for (size_t j=0;j<dict.length();j++) // проверяем или все символы из dict содержатся в temp

{

b2=false;

for (size_t i=0;i<temp.length();i++)

{

if(dict[j]==temp[i])

{

b2=true;

temp[i]='.';

break;

}

if (!b2)

{

b1=false;

break;

}

if (b1) cout << dict << " ";

}

return 0;

}

Используем ввод как условие цикла while. Вводим вспомогательную строку temp, в которую записываем исходное слово. Символы строки temp, которые совпадают с символами данного слова из словаря, заменяем на точки (подходят любые символы, кроме английских букв), учитывая, таким образом, кратность вхождения. Также для проверки вводим логические переменные b1(содержатся ли все символы из строки dict в temp?) и b2(содержится ли j-ый символ из dict в temp?).

Данный код на ideone.

Код(c-string).

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

int main() {
	char word[100]; //описание символьных массивов для хранения исходного слова и слов из словаря
	cin >> word;
	char dict[100];
	bool b1,b2; //описание вспомогательных переменных
	char temp[strlen(word)];
	for (size_t i=0;word[i]!='';i++)
	{
		temp[i]=word[i];
	}
	while (cin >> dict)
	{
		strcpy(temp,word);
		b1=true;
		for (size_t j=0;dict[j]!='';j++) // проверяем или все символы из dict содержатся в temp
		{
			b2=false;
			for (size_t i=0;temp[i]!='';i++)
			{
				if(dict[j]==temp[i])
				{
					b2=true;
					temp[i]='.';
					break;
				}
			}
			if (!b2)
			{
				b1=false;
				break;
			}
		}
		if (b1) cout << dict << " ";
	}
	return 0;
}

#include <iostream>

#include <cstring>

using namespace std;

int main() {

char word[100]; //описание символьных массивов для хранения исходного слова и слов из словаря

cin >> word;

char dict[100];

bool b1,b2; //описание вспомогательных переменных

char temp[strlen(word)];

for (size_t i=0;word[i]!='';i++)

{

temp[i]=word[i];

}

while (cin >> dict)

{

strcpy(temp,word);

b1=true;

for (size_t j=0;dict[j]!='';j++) // проверяем или все символы из dict содержатся в temp

{

b2=false;

for (size_t i=0;temp[i]!='';i++)

{

if(dict[j]==temp[i])

{

b2=true;

temp[i]='.';

break;

}

if (!b2)

{

b1=false;

break;

}

if (b1) cout << dict << " ";

}

return 0;

}

Решение аналогично.

Данный код на ideone.

Related Images:

Ю12.13

20/12/2014 by Денисова Ольга

Задача

Морзянка. Вводимый с клавиатуры или из файла текст перевести в последовательность точек и тире с помощью азбуки Морзе. Результат можно иллюстрировать звуком.

Тесты:

Текст	Результат	Комментарий
SOS	…—…	пройден
A true SOS !!!	.- -…- — .-. ..- . -…- … — … -…- —..— —..— —..— -…-	пройден

Код:

#include <iostream>
#include <string>
#include <map>
#include <cctype>
using namespace std;
 
map <char, string> morze = {
    	{ 'a', ".-"},
    	{ 'b', "-..."},
    	{ 'w', ".--"},
    	{ 'g', "--."},
    	{ 'd', "-.."},
    	{ 'e', "."},
    	{ 'v', "...-"},
    	{ 'z', "--.."},
    	{ 'i', ".."},
    	{ 'j', ".---"},
    	{ 'k', "-.-"},
    	{ 'l', ".-.."},
    	{ 'm', "--"},
    	{ 'n', "-."},
    	{ 'o', "---"},
    	{ 'p', ".--."},
    	{ 'r', ".-."},
    	{ 's', "..."},
    	{ 't', "-"},
    	{ 'u', "..-"},
    	{ 'f', "..-."},
    	{ 'h', "...."},
    	{ 'c', "-.-."},
    	{ 'q', "--.-"},
    	{ 'y', "-.--"},
    	{ 'x', "-..-"},
    	{ '1', ".----"},
    	{ '2', "..---"},
    	{ '3', "...--"},
    	{ '4', "....-"},
    	{ '5', "....."},
    	{ '6', "-...."},
    	{ '7', "--..."},
    	{ '8', "---.."},
    	{ '9', "----."},
    	{ '0', "-----"},
    	{ '.', "......"},
    	{ ',', ".-.-.-"},
    	{ ':', "---..."},
    	{ ';', "-.-.-."},
    	{ '(', "-.--.-"},
    	{ ')', "-.--.-"},
    	{ '"', ".-..-."},
    	{ '-', "-....-"},
    	{ '/', "-..-."},
    	{ '?', "..--.."},
    	{ '!', "--..--"},
    	{ ' ', "-...-"},
    	{ '@', ".--.-."},
};
 
int main() {
	string text;
 
	while(cin >> text) {
	    for(int i = 0; i < text.length(); i++) {
	    	text[i] = tolower(text[i]);
	    	cout << morze.find( text[i] )->second <<"  ";
	    }
	    cout << morze.find(' ')->second << "  ";
	}
 
	return 0;
}

#include <iostream>

#include <string>

#include <map>

#include <cctype>

using namespace std;

map <char, string> morze = {

{ 'a', ".-"},

{ 'b', "-..."},

{ 'w', ".--"},

{ 'g', "--."},

{ 'd', "-.."},

{ 'e', "."},

{ 'v', "...-"},

{ 'z', "--.."},

{ 'i', ".."},

{ 'j', ".---"},

{ 'k', "-.-"},

{ 'l', ".-.."},

{ 'm', "--"},

{ 'n', "-."},

{ 'o', "---"},

{ 'p', ".--."},

{ 'r', ".-."},

{ 's', "..."},

{ 't', "-"},

{ 'u', "..-"},

{ 'f', "..-."},

{ 'h', "...."},

{ 'c', "-.-."},

{ 'q', "--.-"},

{ 'y', "-.--"},

{ 'x', "-..-"},

{ '1', ".----"},

{ '2', "..---"},

{ '3', "...--"},

{ '4', "....-"},

{ '5', "....."},

{ '6', "-...."},

{ '7', "--..."},

{ '8', "---.."},

{ '9', "----."},

{ '0', "-----"},

{ '.', "......"},

{ ',', ".-.-.-"},

{ ':', "---..."},

{ ';', "-.-.-."},

{ '(', "-.--.-"},

{ ')', "-.--.-"},

{ '"', ".-..-."},

{ '-', "-....-"},

{ '/', "-..-."},

{ '?', "..--.."},

{ '!', "--..--"},

{ ' ', "-...-"},

{ '@', ".--.-."},

};

int main() {

string text;

while(cin >> text) {

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

text[i] = tolower(text[i]);

cout << morze.find( text[i] )->second <<" ";

}

cout << morze.find(' ')->second << " ";

}

return 0;

}

Я создала ассоциативный массив через map, и связала буквы («ключ«) и соответствующие им значения в азбуке Морзе («значение«). Чтобы не заполнять его еще и большими буквами, во вводимом тексте уменьшаю буквы с помощью функции tolower .

Решение через c-string :

#include <iostream>
#include <cstring>
#include <stdio.h>
#include <cctype>
using namespace std;
 
int main() {
	char text[254]="";
	char mrz[10] ;
 
	if ( fgets( text, sizeof(text), stdin ) == NULL ) {
		cout << "Произошла ошибка или был прочитан EOF\n";
    }
    else {
	    for(int i = 0; i < strlen(text); i++) {
	    	text[i]=tolower(text[i]);
	        switch (text[i]){
		         case 'a': sprintf(mrz,".-"); break;
		         case 'b': sprintf(mrz,"-..."); break;
		         case 'w': sprintf(mrz,".--"); break;
		         case 'g': sprintf(mrz,"--."); break;
		         case 'd': sprintf(mrz,"-.."); break;
		         case 'e': sprintf(mrz,"."); break;
		         case 'v': sprintf(mrz,"...-"); break;
		         case 'z': sprintf(mrz,"--.."); break;
		         case 'i': sprintf(mrz,".."); break;
		         case 'j': sprintf(mrz,".---"); break;
		         case 'k': sprintf(mrz,"-.-"); break;
		         case 'l': sprintf(mrz,".-.."); break;
		         case 'm': sprintf(mrz,"--"); break;
		         case 'n': sprintf(mrz,"-."); break;
		         case 'o': sprintf(mrz,"---"); break;
		         case 'p': sprintf(mrz,".--."); break;
		         case 'r': sprintf(mrz,".-."); break;
		         case 's': sprintf(mrz,"..."); break;
		         case 't': sprintf(mrz,"-"); break;
		         case 'u': sprintf(mrz,"..-"); break;
		         case 'f': sprintf(mrz,"..-."); break;
		         case 'h': sprintf(mrz,"...."); break;
		         case 'c': sprintf(mrz,"-.-."); break;
		         case 'q': sprintf(mrz,"--.-"); break;
		         case 'y': sprintf(mrz,"-.--"); break;
		         case 'x': sprintf(mrz,"-..-"); break;
		         case '1': sprintf(mrz,".----"); break;
		         case '2': sprintf(mrz,"..---"); break;
		         case '3': sprintf(mrz,"...--"); break;
		         case '4': sprintf(mrz,"....-"); break;
		         case '5': sprintf(mrz,"....."); break;
		         case '6': sprintf(mrz,"-...."); break;
		         case '7': sprintf(mrz,"--..."); break;
		         case '8': sprintf(mrz,"---.."); break;
		         case '9': sprintf(mrz,"----."); break;
		         case '0': sprintf(mrz,"-----"); break;
		         case '.': sprintf(mrz,"......"); break;
		         case ',': sprintf(mrz,".-.-.-"); break;
		         case ':': sprintf(mrz,"---..."); break;
		         case ';': sprintf(mrz,"-.-.-."); break;
		         case '(': sprintf(mrz,"-.--.-"); break;
		         case ')': sprintf(mrz,"-.--.-"); break;
		         case '"': sprintf(mrz,".-..-."); break;
		         case '-': sprintf(mrz,"-....-"); break;
		         case '/': sprintf(mrz,"-..-."); break;
		         case '?': sprintf(mrz,"..--.."); break;
		         case '!': sprintf(mrz,"--..--"); break;
		         case ' ': sprintf(mrz,"-...-"); break;
		         case '@': sprintf(mrz,".--.-."); break;
		         default: sprintf(mrz,""); break;
	        }
        cout << "   "<< mrz;
    	}
    cout << endl;
    }
 
 return 0;
}

#include <iostream>

#include <cstring>

#include <stdio.h>

#include <cctype>

using namespace std;

int main() {

char text[254]="";

char mrz[10] ;

if ( fgets( text, sizeof(text), stdin ) == NULL ) {

cout << "Произошла ошибка или был прочитан EOF\n";

}

else {

for(int i = 0; i < strlen(text); i++) {

text[i]=tolower(text[i]);

switch (text[i]){

case 'a': sprintf(mrz,".-"); break;

case 'b': sprintf(mrz,"-..."); break;

case 'w': sprintf(mrz,".--"); break;

case 'g': sprintf(mrz,"--."); break;

case 'd': sprintf(mrz,"-.."); break;

case 'e': sprintf(mrz,"."); break;

case 'v': sprintf(mrz,"...-"); break;

case 'z': sprintf(mrz,"--.."); break;

case 'i': sprintf(mrz,".."); break;

case 'j': sprintf(mrz,".---"); break;

case 'k': sprintf(mrz,"-.-"); break;

case 'l': sprintf(mrz,".-.."); break;

case 'm': sprintf(mrz,"--"); break;

case 'n': sprintf(mrz,"-."); break;

case 'o': sprintf(mrz,"---"); break;

case 'p': sprintf(mrz,".--."); break;

case 'r': sprintf(mrz,".-."); break;

case 's': sprintf(mrz,"..."); break;

case 't': sprintf(mrz,"-"); break;

case 'u': sprintf(mrz,"..-"); break;

case 'f': sprintf(mrz,"..-."); break;

case 'h': sprintf(mrz,"...."); break;

case 'c': sprintf(mrz,"-.-."); break;

case 'q': sprintf(mrz,"--.-"); break;

case 'y': sprintf(mrz,"-.--"); break;

case 'x': sprintf(mrz,"-..-"); break;

case '1': sprintf(mrz,".----"); break;

case '2': sprintf(mrz,"..---"); break;

case '3': sprintf(mrz,"...--"); break;

case '4': sprintf(mrz,"....-"); break;

case '5': sprintf(mrz,"....."); break;

case '6': sprintf(mrz,"-...."); break;

case '7': sprintf(mrz,"--..."); break;

case '8': sprintf(mrz,"---.."); break;

case '9': sprintf(mrz,"----."); break;

case '0': sprintf(mrz,"-----"); break;

case '.': sprintf(mrz,"......"); break;

case ',': sprintf(mrz,".-.-.-"); break;

case ':': sprintf(mrz,"---..."); break;

case ';': sprintf(mrz,"-.-.-."); break;

case '(': sprintf(mrz,"-.--.-"); break;

case ')': sprintf(mrz,"-.--.-"); break;

case '"': sprintf(mrz,".-..-."); break;

case '-': sprintf(mrz,"-....-"); break;

case '/': sprintf(mrz,"-..-."); break;

case '?': sprintf(mrz,"..--.."); break;

case '!': sprintf(mrz,"--..--"); break;

case ' ': sprintf(mrz,"-...-"); break;

case '@': sprintf(mrz,".--.-."); break;

default: sprintf(mrz,""); break;

}

cout << " "<< mrz;

}

cout << endl;

}

return 0;

}

Ссылки:

string

c-string.

Решение на Java:

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

class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader (System. in) ) ;	
		char rsim;
		
		Map<String, String> morze = new HashMap<String, String>();
		morze.put( "a", ".-");
		morze.put( "b", "-...");
		morze.put( "w", ".--");
		morze.put( "g", "--.");
		morze.put( "d", "-..");
		morze.put( "e", ".");
		morze.put( "v", "...-");
		morze.put( "z", "--..");
		morze.put( "i", "..");
		morze.put( "j", ".---");
		morze.put( "k", "-.-");
		morze.put( "l", ".-..");
		morze.put( "m", "--");
		morze.put( "n", "-.");
		morze.put( "o", "---");
		morze.put( "p", ".--.");
		morze.put( "r", ".-.");
		morze.put( "s", "...");
		morze.put( "t", "-");
		morze.put( "u", "..-");
		morze.put( "f", "..-.");
		morze.put( "h", "....");
		morze.put( "c", "-.-.");
		morze.put( "q", "--.-");
		morze.put( "y", "-.--");
		morze.put( "x", "-..-");
		morze.put( "1", ".----");
		morze.put( "2", "..---");
		morze.put( "3", "...--");
		morze.put( "4", "....-");
		morze.put( "5", ".....");
		morze.put( "6", "-....");
		morze.put( "7", "--...");
		morze.put( "8", "---..");
		morze.put( "9", "----.");
		morze.put( "0", "-----");
		morze.put( ".", "......");
		morze.put( ",", ".-.-.-");
		morze.put( ":", "---...");
		morze.put( ";", "-.-.-.");
		morze.put( "(", "-.--.-");
		morze.put( ")", "-.--.-");
		morze.put( "\"", ".-..-.");
		morze.put( "-", "-....-");
		morze.put( "/", "-..-.");
		morze.put( "?", "..--..");
		morze.put( "!", "--..--");
		morze.put( " ", "-...-");
		morze.put( "@", ".--.-.");
		
		while( (int)(rsim = (char) br.read()) != 65535 ) 
		{
			String sim=String.valueOf(Character.toLowerCase(rsim));
			System.out.printf(" %s",morze.get(sim) );
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

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

{

BufferedReader br = new BufferedReader(new InputStreamReader (System. in) ) ;

char rsim;

Map<String, String> morze = new HashMap<String, String>();

morze.put( "a", ".-");

morze.put( "b", "-...");

morze.put( "w", ".--");

morze.put( "g", "--.");

morze.put( "d", "-..");

morze.put( "e", ".");

morze.put( "v", "...-");

morze.put( "z", "--..");

morze.put( "i", "..");

morze.put( "j", ".---");

morze.put( "k", "-.-");

morze.put( "l", ".-..");

morze.put( "m", "--");

morze.put( "n", "-.");

morze.put( "o", "---");

morze.put( "p", ".--.");

morze.put( "r", ".-.");

morze.put( "s", "...");

morze.put( "t", "-");

morze.put( "u", "..-");

morze.put( "f", "..-.");

morze.put( "h", "....");

morze.put( "c", "-.-.");

morze.put( "q", "--.-");

morze.put( "y", "-.--");

morze.put( "x", "-..-");

morze.put( "1", ".----");

morze.put( "2", "..---");

morze.put( "3", "...--");

morze.put( "4", "....-");

morze.put( "5", ".....");

morze.put( "6", "-....");

morze.put( "7", "--...");

morze.put( "8", "---..");

morze.put( "9", "----.");

morze.put( "0", "-----");

morze.put( ".", "......");

morze.put( ",", ".-.-.-");

morze.put( ":", "---...");

morze.put( ";", "-.-.-.");

morze.put( "(", "-.--.-");

morze.put( ")", "-.--.-");

morze.put( "\"", ".-..-.");

morze.put( "-", "-....-");

morze.put( "/", "-..-.");

morze.put( "?", "..--..");

morze.put( "!", "--..--");

morze.put( " ", "-...-");

morze.put( "@", ".--.-.");

while( (int)(rsim = (char) br.read()) != 65535 )

{

String sim=String.valueOf(Character.toLowerCase(rsim));

System.out.printf(" %s",morze.get(sim) );

}

Related Images:

М3

26/11/2014 by Ілларіонова Марія Валеріївна

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

q	A	B	A+B	Комментарий.
10	126740	546.967	127286.967	Тест пройден.
8	2360	7521	12101	Тест пройден.
2	1011001	1101	100110	Тест пройден.
3	1210.012	1112.1	10022.112	Тест пройден.
10	4356.98	67.975	4424.955	Тест пройден.

Код программы (string):

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

unsigned int dot_position (const string &a, const string &b) {
	unsigned int dota=0, dotb=0;
	for (unsigned int i=0; a[i]; i++) {
		if (a[i]=='.') dota=i;
	}
	if (dota==0) dota=a.length();
	for (unsigned int i=0; b[i]; i++) {
		if (b[i]=='.') dotb=i;
	}
	if (dotb==0) dotb=b.length();
	return max (dota, dotb);
}

unsigned int length_before_dot (const string &a) {
	unsigned int i=0;
	for (; a[i]; i++) {
		if (a[i]=='.') break;
	}
	return i;
}

int length_after_dot (const string &a) {
	return a.length()-length_before_dot(a)-1;
}

int main() {
	const int d='0';
	int q;
	cin >> q;
	string a, b, c;
	cin >> a >> b;
	if (length_after_dot(a)<0) a.insert(a.length(),"."); // Если число без точки, то условно ставим её.
	if (length_after_dot(b)<0) b.insert(b.length(),".");
	if (length_after_dot(a)>length_after_dot(b)) {
		for (unsigned int i=a.length()-1; i>length_before_dot(a)+length_after_dot(b); i--) {
			c.insert(c.begin(),a[i]);
		}
	}
	else if (length_after_dot(a)<length_after_dot(b)) {
		for (unsigned int i=b.length()-1; i>length_before_dot(b)+length_after_dot(a); i--) {
			c.insert(c.begin(),b[i]);
		}
	}
	if (length_before_dot(a)<dot_position(a,b)) {
		a.insert(0,dot_position(a,b)-length_before_dot(a),'0');
	}
	else if (length_before_dot(b)<dot_position(a,b)) {
		b.insert(0,dot_position(a,b)-length_before_dot(b),'0');
	}
	int p=0;
	for (int i=min(a.length(),b.length())-1; i>=0; i--) {
		string k;
		if (a[i]=='.') {
			c.insert(0,"."); --i;
		}
		if (a[i]+b[i]-2*d+p-q<0) {
			k=to_string(a[i]+b[i]-2*d+p);
			p=0;
		}
		else {
			k=to_string(a[i]+b[i]-2*d+p-q);
			p=1;
		}
		c.insert(0,k);
	}
	if (p==1) { 
		c.insert(0,"1");
	}
	if (c.back()=='.') c.pop_back();
	cout << c << endl;
	return 0;
}

#include <iostream>

#include <string>

using namespace std;

unsigned int dot_position (const string &a, const string &b) {

unsigned int dota=0, dotb=0;

for (unsigned int i=0; a[i]; i++) {

if (a[i]=='.') dota=i;

}

if (dota==0) dota=a.length();

for (unsigned int i=0; b[i]; i++) {

if (b[i]=='.') dotb=i;

}

if (dotb==0) dotb=b.length();

return max (dota, dotb);

}

unsigned int length_before_dot (const string &a) {

unsigned int i=0;

for (; a[i]; i++) {

if (a[i]=='.') break;

}

return i;

}

int length_after_dot (const string &a) {

return a.length()-length_before_dot(a)-1;

}

int main() {

const int d='0';

int q;

cin >> q;

string a, b, c;

cin >> a >> b;

if (length_after_dot(a)<0) a.insert(a.length(),"."); // Если число без точки, то условно ставим её.

if (length_after_dot(b)<0) b.insert(b.length(),".");

if (length_after_dot(a)>length_after_dot(b)) {

for (unsigned int i=a.length()-1; i>length_before_dot(a)+length_after_dot(b); i--) {

c.insert(c.begin(),a[i]);

}

else if (length_after_dot(a)<length_after_dot(b)) {

for (unsigned int i=b.length()-1; i>length_before_dot(b)+length_after_dot(a); i--) {

c.insert(c.begin(),b[i]);

}

if (length_before_dot(a)<dot_position(a,b)) {

a.insert(0,dot_position(a,b)-length_before_dot(a),'0');

}

else if (length_before_dot(b)<dot_position(a,b)) {

b.insert(0,dot_position(a,b)-length_before_dot(b),'0');

}

int p=0;

for (int i=min(a.length(),b.length())-1; i>=0; i--) {

string k;

if (a[i]=='.') {

c.insert(0,"."); --i;

}

if (a[i]+b[i]-2*d+p-q<0) {

k=to_string(a[i]+b[i]-2*d+p);

p=0;

}

else {

k=to_string(a[i]+b[i]-2*d+p-q);

p=1;

}

c.insert(0,k);

}

if (p==1) {

c.insert(0,"1");

}

if (c.back()=='.') c.pop_back();

cout << c << endl;

return 0;

}

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

Функция dot_position. Эта функция находит места точек в обеих строках, а если таковых нет, то им присваивается значение длины строки. Возвращает функция наибольшую по значению позицию точки.

Функции length_before_dot и length_after_dot возвращают количество цифр до и после точки соответственно.

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

После этого программа готова вычислить сумму двух чисел. Сложность реализации алгоритма сложения состояла лишь в том, что записать в строку элемент типа int — невозможно, а следовательно, его нужно было преобразовать в строку. Для этого потребовалась функция to_string() из класса <string>. Но при этом элементы a[i] и b[i] воспринимались как коды символов, поэтому каждый из них нужно было уменьшить на ‘0’.

Ещё одна сложность — это десятки, которые мы держим «в уме», а в моём случае — во вспомогательной переменной p.

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

Код программы (cstring):

#include <iostream>
#include <cstring>
#include <stdio.h>
using namespace std;
 
unsigned int dot_position (const char *a, const char *b) {
	unsigned int dota=0, dotb=0;
	for (unsigned int i=0; a[i]; i++) {
		if (a[i]=='.') dota=i;
	}
	if (dota==0) dota=strlen(a);
	for (unsigned int i=0; b[i]; i++) {
		if (b[i]=='.') dotb=i;
	}
	if (dotb==0) dotb=strlen(b);
	return max (dota, dotb);
}
 
unsigned int length_before_dot (const char *a) {
	unsigned int i=0;
	for (; a[i]; i++) {
		if (a[i]=='.') break;
	}
	return i;
}
 
int length_after_dot (const char *a) {
	return strlen(a)-length_before_dot(a)-1;
}
 
void insert (char *a, size_t position, char c) {
	for (unsigned int i=strlen(a); i>position; i--) {
		a[i]=a[i-1];
	}	
	a[position]=c;
}
 
 
int main() {
	const int d='0';
	int q;
	cin >> q;
	char *a;
	a = new char [100];
	char *b;
	b = new char [100];
	char *c;
	c = new char [101];
	cin >> a >> b;
	if (length_after_dot(a)<0) insert(a,strlen(a),'.'); // Если число без точки, то условно ставим её.
	if (length_after_dot(b)<0) insert(b,strlen(b),'.');
	if (length_after_dot(a)>length_after_dot(b)) {
		for (unsigned int i=strlen(a)-1; i>length_before_dot(a)+length_after_dot(b); i--) {
			insert(c,0,a[i]);
		}
	}
	else if (length_after_dot(a)<length_after_dot(b)) {
		for (unsigned int i=strlen(b)-1; i>length_before_dot(b)+length_after_dot(a); i--) {
			insert(c,0,b[i]);
		}
	}
	if (length_before_dot(a)<dot_position(a,b)) {
		for (unsigned int i=dot_position(a,b)-length_before_dot(a); i>0; i--) { 
			insert(a,0,'0');
		}
	}
	else if (length_before_dot(b)<dot_position(a,b)) {
		for (unsigned int i=dot_position(a,b)-length_before_dot(b); i>0; i--) {
			insert(b,0,'0');
		}
	}
	int p=0;
	for (int i=min(strlen(a),strlen(b))-1; i>=0; i--) {
		char *k;
		k = new char [1];
		if (a[i]=='.') {
			insert(c,0,'.'); --i;
		}
		if (a[i]+b[i]-2*d+p-q<0) {
			sprintf(k,"%d",a[i]+b[i]-2*d+p);
			p=0;
		}
		else {
			sprintf(k,"%d",a[i]+b[i]-2*d+p-q);
			p=1;
		}
		insert(c,0,k[0]);
	}
	if (p==1) { 
		insert(c,0,'1');
	}
	if (c[strlen(c)-1]=='.') c[strlen(c)-1]='';
	cout << c << endl;
	return 0;
}

#include <iostream>

#include <cstring>

#include <stdio.h>

using namespace std;

unsigned int dot_position (const char *a, const char *b) {

unsigned int dota=0, dotb=0;

for (unsigned int i=0; a[i]; i++) {

if (a[i]=='.') dota=i;

}

if (dota==0) dota=strlen(a);

for (unsigned int i=0; b[i]; i++) {

if (b[i]=='.') dotb=i;

}

if (dotb==0) dotb=strlen(b);

return max (dota, dotb);

}

unsigned int length_before_dot (const char *a) {

unsigned int i=0;

for (; a[i]; i++) {

if (a[i]=='.') break;

}

return i;

}

int length_after_dot (const char *a) {

return strlen(a)-length_before_dot(a)-1;

}

void insert (char *a, size_t position, char c) {

for (unsigned int i=strlen(a); i>position; i--) {

a[i]=a[i-1];

}

a[position]=c;

}

int main() {

const int d='0';

int q;

cin >> q;

char *a;

a = new char [100];

char *b;

b = new char [100];

char *c;

c = new char [101];

cin >> a >> b;

if (length_after_dot(a)<0) insert(a,strlen(a),'.'); // Если число без точки, то условно ставим её.

if (length_after_dot(b)<0) insert(b,strlen(b),'.');

if (length_after_dot(a)>length_after_dot(b)) {

for (unsigned int i=strlen(a)-1; i>length_before_dot(a)+length_after_dot(b); i--) {

insert(c,0,a[i]);

}

else if (length_after_dot(a)<length_after_dot(b)) {

for (unsigned int i=strlen(b)-1; i>length_before_dot(b)+length_after_dot(a); i--) {

insert(c,0,b[i]);

}

if (length_before_dot(a)<dot_position(a,b)) {

for (unsigned int i=dot_position(a,b)-length_before_dot(a); i>0; i--) {

insert(a,0,'0');

}

else if (length_before_dot(b)<dot_position(a,b)) {

for (unsigned int i=dot_position(a,b)-length_before_dot(b); i>0; i--) {

insert(b,0,'0');

}

int p=0;

for (int i=min(strlen(a),strlen(b))-1; i>=0; i--) {

char *k;

k = new char [1];

if (a[i]=='.') {

insert(c,0,'.'); --i;

}

if (a[i]+b[i]-2*d+p-q<0) {

sprintf(k,"%d",a[i]+b[i]-2*d+p);

p=0;

}

else {

sprintf(k,"%d",a[i]+b[i]-2*d+p-q);

p=1;

}

insert(c,0,k[0]);

}

if (p==1) {

insert(c,0,'1');

}

if (c[strlen(c)-1]=='.') c[strlen(c)-1]='';

cout << c << endl;

return 0;

}

Из-за отсутствия функции insert() в классе <cstring> я была вынуждена написать её самостоятельно. В остальном работа заключалась лишь в «переводе» кода из одного класса в другой.

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

Related Images:

А812б

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

Задача: Дан текст, каждый символ которого может быть малой буквой, цифрой или одним из знаков «+», «-«, «*». Группой букв будем называть такую совокупность последовательно расположенных букв, которой непосредственно не предшествует и за которой непосредственно не следует буква. Аналогично определим группу цифр и группу знаков.

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

Задача решена в двух вариантах — с использованием класса string и и с использованием массива символов, завершающихся нулём ( char[], null terminated string ).

Тесты ( для двух вариантов ):

№	тестовые данные	количество посчитанных слов	результат по условию задачи
1.	afsf1213**++	letterWordCount = 1 digitWordCount = 1 symbolWordCount = 1	в данном тексте одинаковое количество групп букв и групп знаков
2.	afsf1213++asfs2434gfh21+++—dhf++vg	letterWordCount = 5 digitWordCount = 3 symbolWordCount = 3	в данном тексте больше групп букв, чем групп знаков
3.	abcd+++—123efgh++—123367++-sdf—+754+-bmwazs++834hello++—***	letterWordCount = 5 digitWordCount = 4 symbolWordCount = 7	в данном тексте групп букв меньше, чем групп знаков

Вариант 1: решение с использованием класса string

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

#include <iostream>
#include <string>
#include <stdio.h>
#include <ctype.h>

using namespace std; 

// объявление переменных - флаги и счетчики для всех видов слов
int letterWordCount = 0, letterWordOngoing = 0;
int digitWordCount  = 0, digitWordOngoing  = 0;
int symbolWordCount = 0, symbolWordOngoing = 0;
 
// функция завершения чтения слова и увеличение счетчика слова на единицу
void countLastWord(void)
{
   if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }
   else if ( digitWordOngoing != 0 ) { digitWordOngoing  = 0; digitWordCount++; }
   else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }
}
 
int main(void)
{
   string text; // стандартный строковый объект класса string
 
   cin >> text; // вводим текст из стандартного потока ввода

   // проход по символам текста
   for( unsigned int i = 0; i < text.length(); i++ )
   {
       // анализ символов: к какой группе они относятся и проверка состояний
       if ( text[i] == '*'|| text[i] == '-'|| text[i] == '+' ) // проверка принадлежности к данному типу символов
       {
          if ( symbolWordOngoing == 0 )
          {
             countLastWord();
             symbolWordOngoing = 1;
          }
       }
       else if ( isdigit( text[i] ) ) // проверка принадлежности к данному типу символов (цифра)
       {
          if ( digitWordOngoing == 0 )
          {
             countLastWord();
             digitWordOngoing = 1;
          }
       }
       else if ( islower( text[i] ) ) // проверка принадлежности к данному типу символов (буква)
       {
          if ( letterWordOngoing == 0 )
          {
             countLastWord();
             letterWordOngoing = 1;
          }
       }
       else
       {
          printf("error: illegal character: %c / 0x%x\n", text[i], text[i]);
          return 0;
       }
   }
 
   countLastWord(); // финальное завершение текущего слова
 
   // вывод количества посчитанных слов
   printf("letterWordCount = %d\n", letterWordCount);
   printf("digitWordCount  = %d\n", digitWordCount );
   printf("symbolWordCount = %d\n", symbolWordCount);
  
   // вычисление конечного результата
   if( letterWordCount > symbolWordCount ) { printf("в данном тексте больше групп букв, чем групп знаков\n"); }
   else if ( letterWordCount == symbolWordCount ) { printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }
   else { printf("в данном тексте групп букв меньше, чем групп знаков\n"); }
 
   return 0;
}

#include <iostream>

#include <string>

#include <stdio.h>

#include <ctype.h>

using namespace std;

// объявление переменных - флаги и счетчики для всех видов слов

int letterWordCount = 0, letterWordOngoing = 0;

int digitWordCount = 0, digitWordOngoing = 0;

int symbolWordCount = 0, symbolWordOngoing = 0;

// функция завершения чтения слова и увеличение счетчика слова на единицу

void countLastWord(void)

{

if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }

else if ( digitWordOngoing != 0 ) { digitWordOngoing = 0; digitWordCount++; }

else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }

}

int main(void)

{

string text; // стандартный строковый объект класса string

cin >> text; // вводим текст из стандартного потока ввода

// проход по символам текста

for( unsigned int i = 0; i < text.length(); i++ )

{

// анализ символов: к какой группе они относятся и проверка состояний

if ( text[i] == '*'|| text[i] == '-'|| text[i] == '+' ) // проверка принадлежности к данному типу символов

{

if ( symbolWordOngoing == 0 )

{

countLastWord();

symbolWordOngoing = 1;

}

else if ( isdigit( text[i] ) ) // проверка принадлежности к данному типу символов (цифра)

{

if ( digitWordOngoing == 0 )

{

countLastWord();

digitWordOngoing = 1;

}

else if ( islower( text[i] ) ) // проверка принадлежности к данному типу символов (буква)

{

if ( letterWordOngoing == 0 )

{

countLastWord();

letterWordOngoing = 1;

}

else

{

printf("error: illegal character: %c / 0x%x\n", text[i], text[i]);

return 0;

}

countLastWord(); // финальное завершение текущего слова

// вывод количества посчитанных слов

printf("letterWordCount = %d\n", letterWordCount);

printf("digitWordCount = %d\n", digitWordCount );

printf("symbolWordCount = %d\n", symbolWordCount);

// вычисление конечного результата

if( letterWordCount > symbolWordCount ) { printf("в данном тексте больше групп букв, чем групп знаков\n"); }

else if ( letterWordCount == symbolWordCount ) { printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }

else { printf("в данном тексте групп букв меньше, чем групп знаков\n"); }

return 0;

}

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

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

class StringApp
{   

   // объ¤вление переменных - флаги и счетчики дл¤ всех видов слов
   private int letterWordCount = 0; 
   private int letterWordOngoing = 0;
   private int digitWordCount = 0;
   private int digitWordOngoing = 0;
   private int symbolWordCount = 0;
   private int symbolWordOngoing = 0;
   
   // функци¤ завершени¤ чтени¤ слова и увеличение счетчика слова на единицу
   private void countLastWord()
   {
      if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }
      else if ( digitWordOngoing != 0 ) { digitWordOngoing  = 0; digitWordCount++; }
      else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }
   }
   
   public void run()
   {
      // загрузка текста в массив - цикл считывани¤ одного символа текста
      Scanner in = new Scanner(System.in); 
      String text = in.next();     
      in.close();
      
      if ( text.isEmpty() )
      {
         return;
      }
      
      // проход по символам текста загруженного в массив
      for( int i = 0; i < text.length() && text.charAt(i) != 0; i++ )
      {
         // анализ символов: к какой группе они относ¤тс¤ и проверка состо¤ний
          if ( text.charAt(i) == '*'|| text.charAt(i) == '-'|| text.charAt(i) == '+' ) // проверка принадлежности к данному типу символов
          {
             if ( symbolWordOngoing == 0 )
             {
                countLastWord();
                symbolWordOngoing = 1;
             }
          }
          else if ( Character.isDigit( text.charAt(i) ) ) // проверка принадлежности к данному типу символов (цифра)
          {
             if ( digitWordOngoing == 0 )
             {
                countLastWord();
                digitWordOngoing = 1;
             }
          }
          else if ( Character.isLowerCase( text.charAt(i) ) ) // проверка принадлежности к данному типу символов (буква)
          {
             if ( letterWordOngoing == 0 )
             {
                countLastWord();
                letterWordOngoing = 1;
             }
          }
          else
          {
             System.out.printf("error: illegal character: %c / 0x%x\n", text.charAt(i), text.charAt(i));
             return;
          }
      }
      
      countLastWord(); // финальное завершение текущего слова
      
      // вывод количества посчитанных слов
      System.out.printf("letterWordCount = %d\n", letterWordCount);
      System.out.printf("digitWordCount  = %d\n", digitWordCount );
      System.out.printf("symbolWordCount = %d\n", symbolWordCount);
      
      // вычисление конечного результата
      if( letterWordCount > symbolWordCount ) { System.out.printf("в данном тексте больше групп букв, чем групп знаков\n"); }
      else if ( letterWordCount == symbolWordCount ) { System.out.printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }
      else { System.out.printf("в данном тексте групп букв меньше, чем групп знаков\n"); }
   }
   
   public static void main( String[] args )
   {
       StringApp app = new StringApp();
       app.run();
   }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class StringApp

{

// объ¤вление переменных - флаги и счетчики дл¤ всех видов слов

private int letterWordCount = 0;

private int letterWordOngoing = 0;

private int digitWordCount = 0;

private int digitWordOngoing = 0;

private int symbolWordCount = 0;

private int symbolWordOngoing = 0;

// функци¤ завершени¤ чтени¤ слова и увеличение счетчика слова на единицу

private void countLastWord()

{

if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }

else if ( digitWordOngoing != 0 ) { digitWordOngoing = 0; digitWordCount++; }

else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }

}

public void run()

{

// загрузка текста в массив - цикл считывани¤ одного символа текста

Scanner in = new Scanner(System.in);

String text = in.next();

in.close();

if ( text.isEmpty() )

{

return;

}

// проход по символам текста загруженного в массив

for( int i = 0; i < text.length() && text.charAt(i) != 0; i++ )

{

// анализ символов: к какой группе они относ¤тс¤ и проверка состо¤ний

if ( text.charAt(i) == '*'|| text.charAt(i) == '-'|| text.charAt(i) == '+' ) // проверка принадлежности к данному типу символов

{

if ( symbolWordOngoing == 0 )

{

countLastWord();

symbolWordOngoing = 1;

}

else if ( Character.isDigit( text.charAt(i) ) ) // проверка принадлежности к данному типу символов (цифра)

{

if ( digitWordOngoing == 0 )

{

countLastWord();

digitWordOngoing = 1;

}

else if ( Character.isLowerCase( text.charAt(i) ) ) // проверка принадлежности к данному типу символов (буква)

{

if ( letterWordOngoing == 0 )

{

countLastWord();

letterWordOngoing = 1;

}

else

{

System.out.printf("error: illegal character: %c / 0x%x\n", text.charAt(i), text.charAt(i));

return;

}

countLastWord(); // финальное завершение текущего слова

// вывод количества посчитанных слов

System.out.printf("letterWordCount = %d\n", letterWordCount);

System.out.printf("digitWordCount = %d\n", digitWordCount );

System.out.printf("symbolWordCount = %d\n", symbolWordCount);

// вычисление конечного результата

if( letterWordCount > symbolWordCount ) { System.out.printf("в данном тексте больше групп букв, чем групп знаков\n"); }

else if ( letterWordCount == symbolWordCount ) { System.out.printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }

else { System.out.printf("в данном тексте групп букв меньше, чем групп знаков\n"); }

}

public static void main( String[] args )

{

StringApp app = new StringApp();

app.run();

}

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

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

Объявление переменных — флаги и счетчики для всех видов слов
Функция завершения чтения слова и увеличение счетчика слова на единицу
Стандартный строковый объект класса string
Ввод текст из стандартного потока ввода
Проход по символам текста
Анализ символов: к какой группе они относятся и проверка состояний
Проверка принадлежности к данному типу символов ( +, — , * / цифра / буква )
Финальное завершение текущего слова
Вывод количества посчитанных слов
Вычисление конечного результата

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

Цикл выполняется по всем символам string, вплоть до нулевого символа и анализирует принадлежность каждого символа к группе символов. Согласно условию задачи это — мал. буквы, цифры и символы + , — , * . В программе использованы 3 переменных-флага, описывающих текущие состояние чтение одного слова данной группы. Также есть переменные-счётчики для каждой группы слов. Каждый счётчик наращивается при сбрасывании флага, то есть, по завершении чтения группы.

Для проверки типа символа используются стандартные макросы isdigit и islower из библиотеки ctype .

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

Вариант 2: решене с использованием строки символов с завершающим нулём char[]

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

#include <stdio.h>
#include <ctype.h>

#define TEXT_SIZE_MAX 4096

char text[TEXT_SIZE_MAX+1]; // символьный массив для загрузки текста
 
// объявление переменных - флаги и счетчики для всех видов слов
int letterWordCount = 0, letterWordOngoing = 0;
int digitWordCount  = 0, digitWordOngoing  = 0;
int symbolWordCount = 0, symbolWordOngoing = 0;
 
// функция завершения чтения слова и увеличение счетчика слова на единицу
void countLastWord(void)
{
   if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }
   else if ( digitWordOngoing != 0 ) { digitWordOngoing  = 0; digitWordCount++; }
   else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }
}
 
int main(void)
{
   int i, n, c;

   // загрузка текста в массив - цикл считывания одного символа текста
   n = 0;
   while( ( c = getchar() ) != EOF && c != 0 )
   {
      if ( n <= TEXT_SIZE_MAX - 1 ) 
         text[ n++ ] = (char)c;
      else
         break;
   }
   text[ n ] = 0;  // завершаем нулевым символом 

   // проход по символам текста загруженного в массив
   for( i = 0; text[i] != 0; i++ )
   {
      // анализ символов: к какой группе они относятся и проверка состояний
       if ( text[i] == '*'|| text[i] == '-'|| text[i] == '+' ) // проверка принадлежности к данному типу символов
       {
          if ( symbolWordOngoing == 0 )
          {
             countLastWord();
             symbolWordOngoing = 1;
          }
       }
       else if ( isdigit( text[i] ) ) // проверка принадлежности к данному типу символов (цифра)
       {
          if ( digitWordOngoing == 0 )
          {
             countLastWord();
             digitWordOngoing = 1;
          }
       }
       else if ( islower( text[i] ) ) // проверка принадлежности к данному типу символов (буква)
       {
          if ( letterWordOngoing == 0 )
          {
             countLastWord();
             letterWordOngoing = 1;
          }
       }
       else
       {
          printf("error: illegal character: %c / 0x%x\n", text[i], text[i]);
          return 0;
       }
   }
 
   countLastWord(); // финальное завершение текущего слова
 
   // вывод количества посчитанных слов
   printf("letterWordCount = %d\n", letterWordCount);
   printf("digitWordCount  = %d\n", digitWordCount );
   printf("symbolWordCount = %d\n", symbolWordCount);
  
   // вычисление конечного результата
   if( letterWordCount > symbolWordCount ) { printf("в данном тексте больше групп букв, чем групп знаков\n"); }
   else if ( letterWordCount == symbolWordCount ) { printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }
   else { printf("в данном тексте групп букв меньше, чем групп знаков\n"); }
 
   return 0;
}

#include <stdio.h>

#include <ctype.h>

#define TEXT_SIZE_MAX 4096

char text[TEXT_SIZE_MAX+1]; // символьный массив для загрузки текста

// объявление переменных - флаги и счетчики для всех видов слов

int letterWordCount = 0, letterWordOngoing = 0;

int digitWordCount = 0, digitWordOngoing = 0;

int symbolWordCount = 0, symbolWordOngoing = 0;

// функция завершения чтения слова и увеличение счетчика слова на единицу

void countLastWord(void)

{

if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }

else if ( digitWordOngoing != 0 ) { digitWordOngoing = 0; digitWordCount++; }

else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }

}

int main(void)

{

int i, n, c;

// загрузка текста в массив - цикл считывания одного символа текста

n = 0;

while( ( c = getchar() ) != EOF && c != 0 )

{

if ( n <= TEXT_SIZE_MAX - 1 )

text[ n++ ] = (char)c;

else

break;

}

text[ n ] = 0; // завершаем нулевым символом

// проход по символам текста загруженного в массив

for( i = 0; text[i] != 0; i++ )

{

// анализ символов: к какой группе они относятся и проверка состояний

if ( text[i] == '*'|| text[i] == '-'|| text[i] == '+' ) // проверка принадлежности к данному типу символов

{

if ( symbolWordOngoing == 0 )

{

countLastWord();

symbolWordOngoing = 1;

}

else if ( isdigit( text[i] ) ) // проверка принадлежности к данному типу символов (цифра)

{

if ( digitWordOngoing == 0 )

{

countLastWord();

digitWordOngoing = 1;

}

else if ( islower( text[i] ) ) // проверка принадлежности к данному типу символов (буква)

{

if ( letterWordOngoing == 0 )

{

countLastWord();

letterWordOngoing = 1;

}

else

{

printf("error: illegal character: %c / 0x%x\n", text[i], text[i]);

return 0;

}

countLastWord(); // финальное завершение текущего слова

// вывод количества посчитанных слов

printf("letterWordCount = %d\n", letterWordCount);

printf("digitWordCount = %d\n", digitWordCount );

printf("symbolWordCount = %d\n", symbolWordCount);

// вычисление конечного результата

if( letterWordCount > symbolWordCount ) { printf("в данном тексте больше групп букв, чем групп знаков\n"); }

else if ( letterWordCount == symbolWordCount ) { printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }

else { printf("в данном тексте групп букв меньше, чем групп знаков\n"); }

return 0;

}

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

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

class CharArrApp
{   

   // объ¤вление переменных - флаги и счетчики дл¤ всех видов слов
   private int letterWordCount = 0; 
   private int letterWordOngoing = 0;
   private int digitWordCount = 0;
   private int digitWordOngoing = 0;
   private int symbolWordCount = 0;
   private int symbolWordOngoing = 0;
   
   // функци¤ завершени¤ чтени¤ слова и увеличение счетчика слова на единицу
   private void countLastWord()
   {
      if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }
      else if ( digitWordOngoing != 0 ) { digitWordOngoing  = 0; digitWordCount++; }
      else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }
   }
   
   public void run()
   {
      // загрузка текста в массив - цикл считывани¤ одного символа текста
      Scanner in = new Scanner(System.in); 
      String s = in.next();     
      in.close();
      
      if ( s.isEmpty() )
      {
         return;
      }
      
      char[] text = s.toCharArray();
      
      // проход по символам текста загруженного в массив
      for( int i = 0; i < text.length && text[i] != 0; i++ )
      {
         // анализ символов: к какой группе они относ¤тс¤ и проверка состо¤ний
          if ( text[i] == '*'|| text[i] == '-'|| text[i] == '+' ) // проверка принадлежности к данному типу символов
          {
             if ( symbolWordOngoing == 0 )
             {
                countLastWord();
                symbolWordOngoing = 1;
             }
          }
          else if ( Character.isDigit( text[i] ) ) // проверка принадлежности к данному типу символов (цифра)
          {
             if ( digitWordOngoing == 0 )
             {
                countLastWord();
                digitWordOngoing = 1;
             }
          }
          else if ( Character.isLowerCase( text[i] ) ) // проверка принадлежности к данному типу символов (буква)
          {
             if ( letterWordOngoing == 0 )
             {
                countLastWord();
                letterWordOngoing = 1;
             }
          }
          else
          {
             System.out.printf("error: illegal character: %c / 0x%x\n", text[i], text[i]);
             return;
          }
      }
      
      countLastWord(); // финальное завершение текущего слова
      
      // вывод количества посчитанных слов
      System.out.printf("letterWordCount = %d\n", letterWordCount);
      System.out.printf("digitWordCount  = %d\n", digitWordCount );
      System.out.printf("symbolWordCount = %d\n", symbolWordCount);
      
      // вычисление конечного результата
      if( letterWordCount > symbolWordCount ) { System.out.printf("в данном тексте больше групп букв, чем групп знаков\n"); }
      else if ( letterWordCount == symbolWordCount ) { System.out.printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }
      else { System.out.printf("в данном тексте групп букв меньше, чем групп знаков\n"); }
   }
   
   public static void main( String[] args )
   {
       CharArrApp app = new CharArrApp();
       app.run();
   }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class CharArrApp

{

// объ¤вление переменных - флаги и счетчики дл¤ всех видов слов

private int letterWordCount = 0;

private int letterWordOngoing = 0;

private int digitWordCount = 0;

private int digitWordOngoing = 0;

private int symbolWordCount = 0;

private int symbolWordOngoing = 0;

// функци¤ завершени¤ чтени¤ слова и увеличение счетчика слова на единицу

private void countLastWord()

{

if ( letterWordOngoing != 0 ) { letterWordOngoing = 0; letterWordCount++; }

else if ( digitWordOngoing != 0 ) { digitWordOngoing = 0; digitWordCount++; }

else if ( symbolWordOngoing != 0 ) { symbolWordOngoing = 0; symbolWordCount++; }

}

public void run()

{

// загрузка текста в массив - цикл считывани¤ одного символа текста

Scanner in = new Scanner(System.in);

String s = in.next();

in.close();

if ( s.isEmpty() )

{

return;

}

char[] text = s.toCharArray();

// проход по символам текста загруженного в массив

for( int i = 0; i < text.length && text[i] != 0; i++ )

{

// анализ символов: к какой группе они относ¤тс¤ и проверка состо¤ний

if ( text[i] == '*'|| text[i] == '-'|| text[i] == '+' ) // проверка принадлежности к данному типу символов

{

if ( symbolWordOngoing == 0 )

{

countLastWord();

symbolWordOngoing = 1;

}

else if ( Character.isDigit( text[i] ) ) // проверка принадлежности к данному типу символов (цифра)

{

if ( digitWordOngoing == 0 )

{

countLastWord();

digitWordOngoing = 1;

}

else if ( Character.isLowerCase( text[i] ) ) // проверка принадлежности к данному типу символов (буква)

{

if ( letterWordOngoing == 0 )

{

countLastWord();

letterWordOngoing = 1;

}

else

{

System.out.printf("error: illegal character: %c / 0x%x\n", text[i], text[i]);

return;

}

countLastWord(); // финальное завершение текущего слова

// вывод количества посчитанных слов

System.out.printf("letterWordCount = %d\n", letterWordCount);

System.out.printf("digitWordCount = %d\n", digitWordCount );

System.out.printf("symbolWordCount = %d\n", symbolWordCount);

// вычисление конечного результата

if( letterWordCount > symbolWordCount ) { System.out.printf("в данном тексте больше групп букв, чем групп знаков\n"); }

else if ( letterWordCount == symbolWordCount ) { System.out.printf("в данном тексте одинаковое количество групп букв и групп знаков\n"); }

else { System.out.printf("в данном тексте групп букв меньше, чем групп знаков\n"); }

}

public static void main( String[] args )

{

CharArrApp app = new CharArrApp();

app.run();

}

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

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

Объявление символьного массива для загрузки текста
Объявление переменных — флаги и счетчики для всех видов слов
Функция завершения чтения слова и увеличение счетчика слова на единицу
Загрузка текста в массив — цикл считывания одного символа текста
Завершение нулевым символом
Проход по символам текста загруженного в массив
Анализ символов: к какой группе они относятся и проверка состояний
Проверка принадлежности к данному типу символов ( +, — , * / цифра / буква )
Финальное завершение текущего слова
Вывод количества посчитанных слов
Вычисление конечного результата

Программа читает непрерывный поток текстовых символов и загружает их в символьный массив text . По окончанию ввода добавляется нулевой символ, чтобы символьный массив выглядел, как строка, завершающаяся нулём (null terminated string). При вводе учитывается возможность появления мулевого символа, что также прекращает ввод.

Цикл выполняется по символьному массиву, вплоть до нулевого символа и анализирует принадлежность каждого символа к группе символов. Согласно условию задачи это — мал. буквы, цифры и символы + , — , * . В программе использованы 3 переменных-флага, описывающих текущие состояние чтение одного слова данной группы. Также есть переменные- счётчики для каждой группы слов. Каждый счётчик наращивается при сбрасывании флага, то есть, по завершении чтения группы.

Для проверки типа символа используются стандартные макросы isdigit и islower из библиотеки ctype .

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