Аналоги строковых функций С++

Уровень сложности:

Задание
Решение

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

Интерфейс создаваемых функций:

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

int lengthString(char *); // прототип функции определения длинны строки

Функция переворачивает строку и возвращает указатель на перевёрнутую строку, пример:

входная строка: С++
выходная строка: ++С

char *reverseString(char *); // прототип функции для переворота (инверсии) строки

Функция для проверки баланса скобок, то есть количество открытых скобок должно совпадать с количеством закрытых, причём необходимо отличать тип скобочек — круглые, квадратные, фигурные. Функция возвращает значение типа int, если 0 — баланс скобок нарушен, если 1 — баланс скобок выдержан, если -1 скобок во входной строке нет.

int balanceBrackets(char *); // прототип функции проверки баланса парных скобок

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

int occurenceSubstring(char *, char *); // прототип функции поиска первого вхождения подстроки в строку, функция должна возвращать позицию первого вхождения подстроки

Функция конкатенации строк, но конкатенация выполняется начиная с n-й позиции так, что вторая строка вставляется в первую строку не удалив ни одного из символов первой строки. Возвращаемое значение — строка, полученная после вставки второй в первую строки. Пример:
входные данные: строка 1 — cpp.com, строка 2 — studio, номер позиции = 4
результат = cppstudio.com

char *insertnString (char *, char *, int); // прототип функции вставки строки во вторую строку с указанной позиции

Функция должна скопировать часть входной строки (k символов), начиная с позиции с номером N.

char *сutString(char *, int, int); // прототип функции извлечения k символов входной строки, начиная с позиции N

Программа написана на языке программирования С++ в среде разработки программ MVS.

// reinvent_wheel.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int lengthString(char *); // прототип функции определения длинны строки
char *reverseString(char *); // прототип функции для переворота строки
int balanceBrackets(char *); // прототип функции баланс парных скобок
int occurenceSubstring(char *, char *); // прототип функции поиска первого вхождения подстроки в строку
char *insertnString (char *, char *, int); // прототип функции вставки строки во вторую строку с указанной позиции
char *сutString(char *, int, int); // прототип функции извлечения k символов входной строки, начиная с позиции N

int main(int argc, char* argv[])
{
    char string[100]; // входная строка
    setlocale(LC_ALL, "rus");

    cout << "Введите строку для определения её длинны: ";
    cin >> string;
    cout << "Длинна строки = " << lengthString (string) << endl; // определяем длину входной строки

    cout << "\nВведите строку, которую необходимо инвертировать: ";
    cin >> string;
    cout << "Конвертированная строка = " << reverseString(string) << endl; // выполняем конверт строки

    int bal; // баланс скобок
    cout << "\nВведите строку для проверки баланса скобок: ";
    cin >> string;
    bal = balanceBrackets(string); // проверка баланса скобок 
    if ( bal == -1) 
        cout << "Во входной строке скобок нет" << endl;
    else
        if (bal)
        cout << "Баланс скобок выдержан" << endl; 
        else
            cout << "Баланс скобок нарушен" << endl;

    char substring[100]; // подстрока
    cout << "\nВведите строку для получения позиции подстроки: ";
    cin >> string;
    cout << "Введите подстроку: ";
    cin >> substring;
    cout << "Номер позиции = " << occurenceSubstring(string, substring) << endl; // получаем позицию первого вхождения подстроки в строку

    int n; // позиция вставляемой строки
    cout << "\nВведите первую строку для конкатенации: ";
    cin >> string;
    cout << "Введите вторую строку для конкатенации: ";
    cin >> substring;
    cout << "Введите позицию для вставляемой строки: ";
    cin >> n;
    cout << "Результат объединения = " << insertnString (string, substring, n) << endl; // конкатенация строк

    int k; // длинна копируемой строки
    cout << "\nВведите строку из которой необходимо скопировать n символов: ";
    cin >> string;
    cout << "Введите длину копируемой строки: ";
    cin >> k;
    cout << "Введите номер позиции, начиная с которой необходимо скопировать строку: ";
    cin >> n;
    cout << "Скопированная строка = " << сutString(string, k, n) << endl; // копируем строку

    system("pause");
    return 0;
}

int lengthString(char *string) // длинна строки
{
    int index = 0; // индекс символа в строке
    while (string[index] != '\0') // пока не конец строки
    {
        index++; // считаем количество символов в строке
    }
    return index; 
}

char *reverseString(char *string) // конверт строки
{
    int length = lengthString (string); // находим длину строки
    char temp; // временная переменная для хранения переставляемого символа
    for (int counter = 0; counter < (length / 2); counter++)
    {
        if (counter != (length - 1 - counter))
        {
        temp = string[length - 1 - counter]; // символ с конца строки сохраняем во временную переменную
        string[length - 1 - counter] = string[counter];
        string[counter] = temp;
        }
    }

 return string; // возвращаем указатель на строку
}

int balanceBrackets(char *string) // баланс скобок в строке
{
    int return_value = 0; // баланс скобок, если 0 - баланс скобок нарушен, если 1 - баланс скобок выдержан, если -1 скобок нет
    int counterParenthesisOpen = 0, // количество вхождений круглых открывающихся скобок
        counterParenthesisClose = 0, // количество вхождений круглых закрывающихся скобок
        counterBracketOpen = 0, // количество вхождений квадратных открывающихся скобок
        counterBracketClose = 0, // количество вхождений квадратных закрывающихся скобок
        counterBraceOpen = 0, // количество вхождений фигурных открывающихся скобок
        counterBraceClose = 0; // количество вхождений фигурных закрывающихся скобок
    int index = 0; // индекс символа в строке
    bool exit = false;
    while (string[index] != '\0' && !exit) // пока не конец строки
    {
        switch (string[index]) // считаем скобки
        {
        case '(':
            {
                counterParenthesisOpen++; // инкремент количества октрывающихся круглых скобок
                break;
            }
        case ')':
            {
                counterParenthesisClose++; // инкремент количества закрывающихся круглых скобок
                if (counterParenthesisClose > counterParenthesisOpen) exit = true; // выход из цикла
                break;
            }
        case '[':
            {
                counterBracketOpen++; // инкремент количества октрывающихся квадратных скобок
                break;
            }
        case ']':
            {
                counterBracketClose++; // инкремент количества закрывающихся квадратных скобок
                if (counterBracketClose > counterBracketOpen) exit = true; // выход из цикла
                break;
            }
        case '{':
            {
                 counterBraceOpen++; // инкремент количества октрывающихся фигурных скобок
                 break;
            }
        case '}':
            {
                counterBraceClose++; // инкремент количества закрывающихся фигурных скобок
                if (counterBraceClose > counterBraceOpen)  exit = true; // выход из цикла
                break;
            }
        }
        index++;
    }

    // выполняем проверку баланса скобок
    if (counterParenthesisOpen == 0 && counterParenthesisClose == 0 && counterBracketOpen == 0 && 
        counterBracketClose == 0 && counterBraceOpen == 0 && counterBraceClose == 0) return_value = -1; // во входной строке нет скобок
    else
    if (counterParenthesisOpen == counterParenthesisClose && counterBracketOpen == counterBracketClose
        && counterBraceOpen == counterBraceClose ) return_value = 1; // баланс скобок не нарушен
    return return_value; 
}

int occurenceSubstring(char *string, char * substring)
{
    int index1 = 0, // индекс символа в строке string
        index2 = 0; // индекс символа в строке substring
    int return_index = -1; // индекс первого вхождения подстроки 
    bool in = true; // булевская переменная-флаг, определяет однократное вхождение в тело оператора выбора if

    while (string[index1] != '\0')
    {
        if (string[index1] == substring[index2])
        {
            if (in) {return_index = index1 + 1; in = false;}
            index2++;
        } 
        else
        {
            if ((index2 ) != lengthString(substring))
            {
             return_index = -1;
             index2 = 0;
             in = true;
            }
        }
        index1++;
    }

 return return_index;
}

char *insertnString (char *string1, char * string2, int n) // функция вставки строки во вторую строку с указанной позиции
{
    n-=1; // уменьшаем номер позиции на 1, так как нумерация элементов массива начинается с 0 
    static char temp_string[200]; // строка для хранения объединённых входных строк

    // записываем в новую строку n символов первой строки
    for (int counter = 0; counter < n; counter++)
        temp_string[counter] = string1[counter];

    int index_str2 = 0, // индекс символов второй строки
        current_index = n; // индекс символов новой строки

    // в цикле объединяем вторую строку с первыми n символами первой строки
    while (string2[index_str2] != '\0')
    {
        temp_string[current_index] = string2[index_str2];
        current_index++;
        index_str2++;
    }

    int index_str1 = n; // индекс символов первой строки

    // в цикле оставшиеся символы первой строки добавляем в конец новой строки
    while (string1[index_str1] != '\0')
    {
        temp_string[current_index] = string1[index_str1];
        index_str1++;
        current_index++;
    }

 return temp_string;
}

char *сutString(char *string, int k, int n) // функция извлечения k символов входной строки, начиная с позиции N
{
    static char returnString[100]; // извлекаемая часть строки
    int index = 0; // текущий индекс в возвращаемой строке
    for (int counter = n - 1; counter < (n - 1 + k) ; counter++)
    {
        returnString[index] = string[counter];
        index++;
    }

 return returnString;
}

Результат работы программы показан на рисунке 1.

CppStudio.com

Введите строку для определения её длинны: cppstudio.com
Длинна строки = 13

Введите строку, которую необходимо инвертировать: cppstudio.com
Конвертированная строка = moc.oidutsppc

Введите строку для проверки баланса скобок: (5+(4+a[2])+b[1]*(3-2))
Баланс скобок выдержан

Введите строку для получения позиции подстроки: cppstudio.com
Введите подстроку: studio
Номер позиции = 4

Введите первую строку для конкатенации: cpp.com
Введите вторую строку для конкатенации: studio
Введите позицию для вставляемой строки: 4
Результат объединения = cppstudio.com

Введите строку из которой необходимо скопировать n символов: cppstudio.com
Введите длину копируемой строки: 6
Введите номер позиции, начиная с которой необходимо скопировать строку: 4
Скопированная строка = studio

Следующие статьи помогут вам в решении данной задачи:

Передача строки в функцию

Символы и строки в С++

Обсудить на форуме

Автор: admin

Дата: 12.09.2012

#include<iostream>
#include<stdio.h.>
#include<conio.h> // для getche()
using namespace std;

const int MAX = 1000;

int   lengthString(char*);
char *reverseString(char *);
int   balanceBrackets(char *);
int   occurenceSubstring(char *, char *);
char *insertnString (char *, char *, int);
char *cutString(char *, int, int);
int   strncmp(char*  , char* , int  );

int main()
{
    setlocale(LC_CTYPE, "rus");

    char *stroka1 = new char[MAX];
    char *stroka2 = new char[MAX];

    char menu;
  while(true)
  {
    cout<<"Выберите  действие:"
        <<"\n1 - для определения длины строки"
        <<"\n2 - для инверсии(переворота) стороки"
        <<"\n3 - для проверки баланса скобок в строке"
        <<"\n4 - для поиска первого вхождения подстроки в строку"
        <<"\n5 - для вставки строки во вторую строку с указанной позиции"
        <<"\n6 - для извлечения k символов входной строки, начиная с позиции N"
        <<"\n0 - выход"
        <<"\nВаш выбор: ";
        while(true)
        {
           menu = getch();
        if(menu>='0' && menu<='9')
             {
               cout<<menu;
               while(getch() != '\r');
               break;
             }
        }
    switch(menu)
    {
   case '1':
    {
    cout<<"\nВведите строку для определения её длины: ";
    cin.getline(stroka1, MAX);
    cout<<"Длина строки: "<<lengthString(stroka1)<<endl;
    break;
    }
   case '2':
    {
    cout<<"\nВведите строку которую надо инвертировать: ";
    cin.getline(stroka1, MAX);
    cout<<"Конвертированная строка: "
        <<reverseString(stroka1)<<endl;
    break;
    }

   case '3':
    {
    cout<<"\nВведите строку для проверки баланса скобок: ";
    cin.getline(stroka1, MAX);

       switch(balanceBrackets(stroka1))
        {
         case  1:   cout<<"Баланс скобок не выдержан"<<endl; break;
         case  0:   cout<<"Баланс скобок выдержан"<<endl;    break;
         case -1:   cout<<"Нет скобок в строке"<<endl;
        }
        break;
    }
   case '4':
    {
    cout<<"\nВведите строку для получения позиции подстроки: ";
    cin.getline(stroka1, MAX);
    cout<<"Введите подстроку: ";
    cin.getline(stroka2, MAX);
    if(occurenceSubstring(stroka1, stroka2)==0)
        cout<<"В строке нет такой подстроки"<<endl;
    else
        cout<<"Номер позиции: "<<occurenceSubstring(stroka1, stroka2)<<endl;
    break;
    }
   case '5':
    {
    int pozic;
    cout<<"\nВведите первую строку для конкатенации: ";
    cin.getline(stroka1, MAX);
    cout<<"Введите вторую строку для конкатенации: ";
    cin.getline(stroka2, MAX);
    while(true)
    {
        cout<<"Введите позицию для вставляемой строки"<<"(1 - "<<lengthString(stroka1) + 1<<"): ";
        cin>>pozic;
        if(cin.good() && pozic>0 && pozic<= (lengthString(stroka1) + 1)  )
            {
               cin.ignore(MAX, '\n');
               break;
            }
          cin.clear();
          cout<<"\nНеправильный ввод данных\n";
          cin.ignore(MAX, '\n');
    }

    cout<<"Результат объединения: ";
    cout<<insertnString (stroka1, stroka2, pozic)<<endl;
    break;
    }
   case '6':
    {
    int  n, k;
    cout<<"\nВведите строку из которой необходимо скопировать n символов: ";
    cin.getline(stroka1, MAX);
    while(true)
    {
        cout<<"Введите длину копируемой строки"<<"(1 - "<<lengthString(stroka1)<<"): ";
        cin>>k;
        if(cin.good() && k>0 && k<= (lengthString(stroka1) + 1)  )
            {
               cin.ignore(MAX, '\n');
               break;
            }
          cin.clear();
          cout<<"\nНеправильный ввод данных\n";
          cin.ignore(MAX, '\n');
    }

    while(true)
    {
        cout<<"Введите номер позиции с которой необходимо скопировать строку"<<"(1 - "<<lengthString(stroka1)<<"): ";
        cin>>n;
        if(cin.good() && n>0 && n<= (lengthString(stroka1) + 1)  )
            {
               cin.ignore(MAX, '\n');
               break;
            }
          cin.clear();
          cout<<"\nНеправильный ввод данных\n";
          cin.ignore(MAX, '\n');
    }

    cout<<"Скопированная строка: "
        <<cutString(stroka1, k, n)<<endl;
    break;
    }
   case '0': return 0;
   default:
     cout<<"\nНедопустимый ввод!"<<endl;
}
  }
    return 0;
}
//////////////////////////////////////////////////////////////////////
int lengthString(char *stroka)
{
     int i;
     for( i = 0; stroka[i] != 0; i++);
     return i;
}
///////////////////////////////////////////////////////////////////
char *reverseString(char *stroka)
{
   char temp;
   int lens = lengthString(stroka); //найти длину строки
   for(int x=0; x<lens/2; x++)
  {
      temp = stroka[x];             // поменять символы из первой половины строки
      stroka[x] = stroka[lens-1-x]; //на символы из второй половины
      stroka[lens-1-x] = temp;
  }
   return stroka;
}
////////////////////////////////////////////////////////////////////////////////
int balanceBrackets(char *stroka)
{
    char stek[100];                //стек для хранения скобок
    char ch;
    char lastch;
    int j = 0;
    bool flag = 0;

    for(int i = 0; stroka[i] != 0; i++)
    {
       ch = stroka[i];
       if(ch == '(' || ch == '{' || ch == '[')
            {
                stek[j++] = ch;  flag = 1;        //если символ открывающая скобка, он заносится в стек
            }

        if(ch == ')' || ch == '}' || ch == ']')
        {
           flag = 1;
           if(j == 0)  return 1;                   //если закрывающая скобка есть, а открывающей нет
           lastch = stek[--j];                     //получить последний символ из стека

           if(lastch == '(' && ch != ')') return 1; //если последний символ открывающай скобка, а текущий символ не закрывающая скобка
           if(lastch == '{' && ch != '}') return 1;
           if(lastch == '[' && ch != ']') return 1;
        }
    }
     if(!flag) return -1;          //если нет скобок в строке
     if(j == 0)
        return 0;
     else
        return 1;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int occurenceSubstring(char *stroka, char *podstroka)
{
     int  x = 0;

     if(podstroka[x] != 0)
     for(int i=0; stroka[i] != 0; i++)                   //последовательно сравниваем элемент строки с элеметами подстроки
     {
          for( x=0; podstroka[x] != 0; x++)
               if(stroka[i + x] != podstroka[x] )        //если элемент строки совпал с первым элементом подстроки
                  break;                                 //инкреминируем счетчик

          if(podstroka[x] == 0)                          //если элементы строки последовательно совпали с элементами подстроки
                 return i+1;
     }
       return 0;
    //альтернативный вариант, используется функция сравнения строк с префиксом
    /*int i;
    int n = lengthString(podstroka);
    for(i = 0; stroka[i] != 0; i++)
         if(strncmp(stroka + i, podstroka, n) == 0) return i + 1;
    return 0;*/
}
//////////////////////////////////////////////////////////////////////
char *insertnString (char *s1, char *s2, int n)
{
    int l1 = lengthString(s1);
    int l2 = lengthString(s2);

    char *rezult_str = new char[l1 + l2 +1];                // строка - сборка +1 для символа конца строки
    n--; //
    for(int x = 0; x<n; x++)
        rezult_str[x] = s1[x];                       // копируем часть первой строки до нужного индекса
    for(int x = 0; x<l2; x++)            //добавляем вставляемую строку
        rezult_str[x + n] = s2[x];
    for(int x = n; s1[x] != 0; x++)     //добавляем оставшуюся часть первой строки
        rezult_str[x +  l2] = s1[x];
    rezult_str[l1 + l2] = '';

       return  rezult_str;
}
/////////////////////////////////////////////////////////////////////////////
char *cutString(char *cutsroka1, int lens, int poz)
{
   char *cutstroka2 = new char[lens + 1];  //+1 для символа конца строки
   int x = 0;
   int y = poz - 1;
    for(x; x<lens && cutsroka1[y] != '' ; x++, y++)
        cutstroka2[x] = cutsroka1[y];

    cutstroka2[x] = '';
   return cutstroka2;
}
////////////////////////////////////////////////////////////////////////
int strncmp(char* a, char* b, int n) //для альтернативного варианта occurenceSubstring(...)
{
   int x;
   for(x = 0; x<n && a[x] != 0; x++ )
      if(a[x] != b[x]) return (a[x] - b[x]);

   return 0;
}

Arthur

12.06.2016

#include<iostream>
#include<stdio.h.>
#include<conio.h> // для getche()
using namespace std;

const int MAX = 1000;

int lengthString(char*);
char *reverseString(char *);
int balanceBrackets(char *);
int occurenceSubstring(char *, char *);
char *insertnString (char *, char *, int);
char *cutString(char *, int, int);
int strncmp(char*  , char* , int  ); //для альтернативного варианта occurenceSubstring(...)

int main()
{
    setlocale(LC_CTYPE, "rus");

    char *stroka1 = new char[MAX];
    char *stroka2 = new char[MAX];

    char menu;
  while(true)
  {
   cin.sync();
   cout<<"Выберите  действие:"
        <<"\n1 - для определения длины строки"
        <<"\n2 - для инверсии(переворота) стороки"
        <<"\n3 - для проверки баланса скобок в строке"
        <<"\n4 - для поиска первого вхождения подстроки в строку"
        <<"\n5 - для вставки строки во вторую строку с указанной позиции"
        <<"\n6 - для извлечения k символов входной строки, начиная с позиции N"
        <<"\n0 - выход"
        <<"\nВаш выбор: ";
        while(true)
        {
           menu = getch();
        if(menu>='0' && menu<='9')
             {
               cout<<menu;
               while(getch() != '\r');
               break;
             }
        }
    switch(menu)
    {
   case '1':
    {
    cout<<"\nВведите строку для определения её длины: ";
    gets(stroka1);
    cout<<"Длина строки: "<<lengthString(stroka1)<<endl;
    break;
    }
   case '2':
    {
    cout<<"\nВведите строку которую надо инвертировать: ";
    gets(stroka1);
    cout<<"Конвертированная строка: "
        <<reverseString(stroka1)<<endl;
    break;
    }

   case '3':
    {
    cout<<"\nВведите строку для проверки баланса скобок: ";
    gets(stroka1);

   switch(balanceBrackets(stroka1))
      {
       case  1:   cout<<"Баланс скобок не выдержан"<<endl; break;
       case  0:   cout<<"Баланс скобок выдержан"<<endl;    break;
       case -1:   cout<<"Нет скобок в строке"<<endl;
      }
        break;
    }
   case '4':
    {
    cout<<"\nВведите строку для получения позиции подстроки: ";
    gets(stroka1);
    cout<<"Введите подстроку: ";
    gets(stroka2);
    if(occurenceSubstring(stroka1, stroka2)==0)
        cout<<"В строке нет такой подстроки"<<endl;
    else
    cout<<"Номер позиции: "<<occurenceSubstring(stroka1, stroka2)<<endl;
    break;
    }
   case '5':
    {
      unsigned int pozic;
    cout<<"\nВведите первую строку для конкатенации: ";
    gets(stroka1);
    cout<<"Введите вторую строку для конкатенации: ";
    gets(stroka2);
    while(true)
    {
        cout<<"Введите позицию для вставляемой строки"<<"(1 - "<<lengthString(stroka1) + 1<<"): ";
        cin>>pozic;
        if(cin.good() && pozic>0 && pozic<= (lengthString(stroka1) + 1)  )
            {
               cin.sync();
               break;
            }
          cin.clear();
          cout<<"\nНеправильный ввод данных\n";
          cin.sync();
    }

    cout<<"Результат объединения: ";
    cout<<insertnString (stroka1, stroka2, pozic)<<endl;
    break;
    }
   case '6':
    {
      unsigned int  n, k;
    cout<<"\nВведите строку из которой необходимо скопировать n символов: ";
    gets(stroka1);
    while(true)
    {
        cout<<"Введите длину копируемой строки"<<"(1 - "<<lengthString(stroka1)<<"): ";
        cin>>k;
        if(cin.good() && k>0 && k<= lengthString(stroka1)  )
            {
               cin.sync();
               break;
            }
          cin.clear();
          cout<<"\nНеправильный ввод данных\n";
          cin.sync();
    }

    while(true)
    {
        cout<<"Введите номер позиции с которой необходимо скопировать строку"<<"(1 - "<<lengthString(stroka1)<<"): ";
        cin>>n;
        if(cin.good() && n>0 && n<= lengthString(stroka1)  )
            {
               cin.sync();
               break;
            }
          cin.clear();
          cout<<"\nНеправильный ввод данных\n";
          cin.sync();
    }

    cout<<"Скопированная строка: "
        <<cutString(stroka1, k, n)<<endl;
    break;
    }
   case '0': return 0;
   default:
     cout<<"\nНедопустимый ввод!"<<endl;
}
  }
    return 0;
}
//////////////////////////////////////////////////////////////////////
int lengthString(char *stroka)
{
     int i;
     for( i = 0; stroka[i] != 0; i++);
     return i;
}
///////////////////////////////////////////////////////////////////
char *reverseString(char *stroka)
{
   char temp;
   int lens = lengthString(stroka); //найти длину строки
   for(int x=0; x<lens/2; x++)
  {
      temp = stroka[x];             // поменять символы из первой половины строки
      stroka[x] = stroka[lens-1-x]; //на символы из второй половины
      stroka[lens-1-x] = temp;
  }
   return stroka;
}
////////////////////////////////////////////////////////////////////////////////
int balanceBrackets(char *stroka)
{
    char stek[100];                //стек для хранения скобок
    char ch;
    char lastch;
    int j = 0;
    bool flag = 0;

    for(int i = 0; stroka[i] != 0; i++)
    {
       ch = stroka[i];
       if(ch == '(' || ch == '{' || ch == '[')
            {
                stek[j++] = ch;  flag = 1;        //если символ открывающая скобка, он заносится в стек
            }

        if(ch == ')' || ch == '}' || ch == ']')
        {
           flag = 1;
           if(j == 0)  return 1;                   //если закрывающая скобка есть, а открывающей нет
           lastch = stek[--j];                     //получить последний символ из стека

           if(lastch == '(' && ch != ')') return 1; //если последний символ открывающай скобка, а текущий символ не закрывающая скобка
           if(lastch == '{' && ch != '}') return 1;
           if(lastch == '[' && ch != ']') return 1;
        }
    }
     if(!flag) return -1;          //если нет скобок в строке
     if(j == 0)
        return 0;
     else
        return 1;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int occurenceSubstring(char *stroka, char *podstroka)
{
     int  x;
     for(int i=0; stroka[i] != 0; i++)                   //последовательно сравниваем элемент строки с элеметами подстроки
     {
          for( x=0; podstroka[x] != 0; x++)
               if(stroka[i + x] != podstroka[x] )        //если элемент строки совпал с первым элементом подстроки
                  break;                                 //инкреминируем счетчик

          if(podstroka[x] == 0)                          //если элементы строки последовательно совпали с элементами подстроки
                 return i+1;
     }
       return 0;
    //альтернативный вариант, используется функция сравнения строк с префиксом
    /*int i;
    int n = lengthString(podstroka);
    for(i = 0; stroka[i] != 0; i++)
         if(strncmp(stroka + i, podstroka, n) == 0) return i + 1;
    return 0;*/
}
//////////////////////////////////////////////////////////////////////
char *insertnString (char *s1, char *s2, int n)
{
    int l1 = lengthString(s1);
    int l2 = lengthString(s2);

    char *rezult_str = new char[l1 + l2];                // строка - сборка
    n--; //
    for(int x = 0; x<n; x++)
        rezult_str[x] = s1[x];                       // копируем часть первой строки до нужного индекса
    for(int x = 0; x<l2; x++)            //добавляем вставляемую строку
        rezult_str[x + n] = s2[x];
    for(int x = n; s1[x] != 0; x++)     //добавляем оставшуюся часть первой строки
        rezult_str[x +  l2] = s1[x];

       return  rezult_str;
}
/////////////////////////////////////////////////////////////////////////////
char *cutString(char *cutsroka1, int lens, int poz)
{
   char *cutstroka2 = new char[lens];
   for(int x=0; x<lens; x++)
          cutstroka2[x] = cutsroka1[x+(poz-1)];
   return cutstroka2;
}
////////////////////////////////////////////////////////////////////////
int strncmp(char* a, char* b, int n) //для альтернативного варианта occurenceSubstring(...)
{
   int x;
   for(x = 0; x<n && a[x] != 0; x++ )
      if(a[x] != b[x]) return (a[x] - b[x]);

   return 0;
}

Владимир Шумов

08.11.2015

#include <conio.h>
#include <iostream>

using std::cout;
using std::cin;
using std::endl;

int lengthString(char *str)
{
	int numberSymbol = 0;
	while (str[numberSymbol] != '')
	{
		numberSymbol++;
	}
	return numberSymbol;
}

char *reverseStr(char *str)
{
	int length, j = 0;
	char x;
	length = lengthString(str);
	for (int i(0); i < length / 2; i++)
	{
		x = str[length - 1 - i];
		str[length - 1 - i] = str[i];
		str[i] = x;

		length--;
	}
	return str;
}

int balanceBrackets(char *str)
{
	int parentheses = 0, squareBrackets = 0, braces = 0, result = -1;
	bool balanceParentheses = true;
	for (int i(0); i < lengthString(str); i++)
	{
		if (str[i] == '(')
		{
			parentheses++;
			balanceParentheses = false;
		}
		if (str[i] == ')')
		{
			parentheses--;
			balanceParentheses = false;
		}
		if (str[i] == '[')
		{
			squareBrackets++;
			balanceParentheses = false;
		}
		if (str[i] == '[')
		{
			squareBrackets--;
			balanceParentheses = false;
		}
		if (str[i] == '{')
		{
			braces++;
			balanceParentheses = false;
		}
		if (str[i] == '}')
		{
			braces--;
			balanceParentheses = false;
		}
	}
	if (parentheses != 0 || squareBrackets != 0 || braces != 0)
	{
		result = 0;
	}
	if (balanceParentheses == false && parentheses == 0 && squareBrackets == 0 && braces == 0)
	{
		result = 1;
	}
	return result;
}

int occurenceSubstring(char *str2, char *str)
{
	int k = 0, result = 0, n = 0;
	for (int i(0); i < lengthString(str); i++)
	{
		if (str2[n] == str[i])
		{
			k++;
			n++;
		}
		else
		{
			k = 0;
			n = 0;
		}
		if (k == lengthString(str2))
		{
			result = i + 2 - k;
			break;
		}
	}
	return result;
}

char *insertnString (char *str, char *str2, int x)
{
	static char str3[256];
	int n = 0;
	x--;
	for (int i(0); i < x + lengthString(str2) + (lengthString(str)-x); i++)
	{
		if (i < x)
		{
			str3[i] = str[i];
		}
		if (i > x-1 && i < lengthString(str2) + x)
		{
			str3[i] = str2[n];
			n++;
		}
		if (i > lengthString(str2) - 1 + x && i < x + lengthString(str2) + (lengthString(str) - x))
		{
			str3[i] = str[x];
			x++;
		}
	}
	return str3;
}

char *сutString(char *str, int lengthString, int firstSymbol)
{
	static char str2[256];
	int x = 0;
	for (int i(firstSymbol - 1); i < firstSymbol + lengthString - 1; i++)
	{
		str2[x] = str[i];
		x++;
	}
	return str2;
}

int main()
{
  setlocale(LC_ALL, "Russian");
  char str[256], str2[256];
  int lengthStr, firstSymbol;
  cout << "Введите строку для определения её длинны: ";
  cin.getline(str, 256);
  cout << "Количество символов: " << lengthString(str)<< endl;
  cout << endl;
  cout << "Введите строку, которую необходимо инвертировать: ";
  cin.getline(str, 256);
  cout << "Конвертированная строка: " << reverseStr(str);
  cout << endl << endl;
  cout << "Введите строку для проверки баланса скобок: ";
  cin.getline(str, 256);
  if (balanceBrackets(str) == 1)
  {
	  cout << "Баланс скобок выдержан." << endl;
  }
  if (balanceBrackets(str) == 0)
  {
	  cout << "Баланс скобок нарушен." << endl;
  }
  if (balanceBrackets(str) == -1)
  {
	  cout << "Скобок во входной строке нет." << endl << endl;
  }
  cout << "Введите строку для получения позиции подстроки: ";
  cin.getline(str, 256);
  cout << "Введите подстроку: ";
  cin.getline(str2, 256);
  cout << occurenceSubstring(str2, str) << endl << endl;
  cout << "Введите первую строку для конкатенации: ";
  cin.getline(str, 256);
  cout << "Введите вторую строку для конкатенации: ";
  cin.getline(str2, 256);
  cout << "Введите позицию для вставляемой строки: ";
  cin >> lengthStr;
  cout << "Результат объединения: "<< insertnString (str, str2, lengthStr) << endl << endl;
  cout << "Введите строку из которой необходимо скопировать n символов: ";
  cin.getline(str, 256);
  cin.getline(str, 256);
  cout << "Введите длину копируемой строки: ";
  cin >> lengthStr;
  cout << "Введите номер позиции, начиная с которой необходимо скопировать строку: ";
  cin >> firstSymbol;
  cout << "Скопированная строка: " << сutString(str, lengthStr, firstSymbol);;
  _getch();
}

Андрей Ратушный
25.10.2015
Вот мой вариант

#include <iostream>
using namespace std;

int lenthString(char *String)//Кол-во символов в строке
{
int count = 0;
while (*String)
{
++String;
++count;
}
return count;
}
char *reverseString(char *String)//Строка наоборот
{
int lenth = lenthString(String);
char *tempString=new char[lenth+1];
while (*String)
{
++String;
}
for (int i = 0; i < lenth;++i)
tempString[i]=*—String;
tempString[lenth] = »;
return tempString;
}
int occurenceSubstring(char *String, char *FoundString)//Определение позиции в 1 строке начала второй строки
{
int count = 0, lenthFound = lenthString(FoundString),position,countLast=0;
while (*String)
{
++countLast;
if (*String == *FoundString)
{
if (!count) position = countLast;
++count;
++FoundString;
}
else if (count && count!=lenthFound)
{
while (count)
{
—count;
—FoundString;
}
—String;
—countLast;
}
++String;
}
return position;
}
char *insertnString(char *StringOriginal, char *AddString, int position) //Конкатенация (вставка в 1 строку другой строки по указаной позиции)
{
int lenth = lenthString(StringOriginal) + lenthString(AddString);
char *TempString = new char[lenth + 1];
TempString[0] = NULL;
for (int i = 0; i < lenth; ++i)
{
if (i + 1 != position)
TempString[i] = *StringOriginal++;
else
{
TempString[i] = *AddString++;
++position;
if (!*AddString) position = 0;
}
}
TempString[lenth] = »;
return TempString;
}
char *сutString(char *String, int position, int lenthNewString)// Вырезание строки из заданой (определено колво символов и позицию откуда вырезать)
{
char *TempString = new char[lenthNewString + 1];
int count = 0;
for (int i = 0;1; ++i)
{
if (i + 1 == position)
{
++position;
TempString[count] = String[i];
++count;
if (count == lenthNewString) break;
}
}
TempString[lenthNewString] = »;
return TempString;
}
void main()
{
char *String=nullptr;
String = «cppstudio.com»;
char *FoundString = nullptr;
FoundString = «studio»;
char *StringOriginal = nullptr;
StringOriginal = «cpp.com»;
//cout << lengthString(String);
//cout << reverseString(String);
//cout << occurenceSubstring(String, FoundString);
//cout << insertnString(StringOriginal, FoundString,4);
//cout << сutString(String, 4, 6);
}
Войдите, чтобы ответить

Adam1983

08.04.2015

#include <conio.h>
#include <iostream>

using namespace std;


	
int lengthString(char* );

char* reverseString(char* );

int balanceBrackets(char* );

int occurenceSubstring(char *, char *);

char* insertnString (char *, char *, int);

char* сutString(char*, int, int);


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

setlocale (LC_ALL, "russian");

//выдиление динамической памяти и ввод строки
char* str = new char[255];

cout << "Введите строку: ";
cin.getline(str,255);

//вызов функции с определением длинны строки
cout <<"Длинна строки: "<< lengthString(str)<< endl;

//выводим строку с приминением функции реверса и возвращаем её в первоначальное состояние
cout << reverseString(str) << endl;
reverseString(str);


// вывод результата работы функции проверки скобок в понятное состояние для пользователя

if (balanceBrackets(str)==1)
{
	cout << "Баланс скобок выдержан" << endl;
}
else
	if (balanceBrackets(str)==0)
		cout << "Баланс скобок нарушен" << endl;
	else
		cout << "Скобок в строке нет" << endl;

// выдиляем динамическую память для подстроки и ввод подстроки с последующим применением функции
// вставки подстроки в основную строку
char* str1 = new char[255];

cout << "Введите подстроку: ";

cin.getline(str1,255);

cout << "Номер позиции: " << occurenceSubstring(str,str1) << endl;


cout << "Введите Н: ";
int n;
cin >> n;

// выдиляем динамическую память под строку, для копирования в неё результата
//функции insertnString и выводим рузулдьтат на экран

char* str2 = new char[255];

str2=insertnString (str,str1,n);

for (int i(0); i<(lengthString(str)+lengthString(str1)); i++)
	cout <<str2[i];
	


int length, position;

cout << "\nВведите длинну копируемой строки: ";
cin >> length;

cout << "Введите номер позиции, начиная с которой необходимо скопировать строку: ";
cin >> position;

// выдиляем динамическую память под строку, для копирования в неё результата
//функции сutString и выводим рузулдьтат на экран

char* str3 = new char[length];
str3=сutString(str,length,position);

for (int i(0); i<length; i++)
	cout <<str3[i];

// освобождаем память
delete [] str;
delete [] str1;
delete [] str2;
delete [] str3;

_getch();
  return 0;
}

int lengthString(char* str) //функция для определения длинны строки
{
 //устанавливаем счётчик и возвращаем его значение
  int counter(0);

  for(int i(0); str[i]; i++)
  {
   counter++;
  }
  return counter;
}

char* reverseString(char* str)//функция для реверса строки
{
 //выдиляем память под новую строку, для копирования в неё результата реверса
 int temp = lengthString(str)+1;
 char* str1= new char[temp];
 
  for (int i(0), j(temp-1); i<temp; i++, j--)
 {
   str1[i]=str[j];
 }

  for (int i(1); i<temp; i++)
 {
 str[i-1]= str1[i];
 }

  delete [] str1;

  return str;

}

int balanceBrackets(char* str)// функция для проверки баланса скобок
{
 int temp = lengthString(str)+1;
 int left(0);
 int right(0);

 // подсчитываем коллдичество левых и правых скобок и записываем значения
 // в переменные
 for (int i(0); i<temp; i++)
 {
   if (str[i]=='[' || str[i]=='{' || str[i]=='(')
	   left++;
   if (str[i]==']' || str[i]=='}' || str[i]==')')
	   right++;
 }

  //сравниваем значения переменных и в зависимости от этого возвращаем результат

 if(left==0 && right==0)
	   return -1;
  
 if(left==right)
	   return 1;
 else
	   return 0;  
 
}

int occurenceSubstring(char* str, char* str1) //функция поиска первого вхождения подстроки в строку
{
	int temp = lengthString(str);

	int temp1 = lengthString(str1);
	int level(0);

	for(int i(0); i<temp ; i++)
	{
		
		 if(str[i]==str1[0] && str[i+temp1-1] == str1[temp1-1])
		 {
			return i+1;
		 }
	}
}

char* insertnString (char* str, char* str1, int n)//функция вставки подстроки в строку
{
 int temp = lengthString(str);

 int temp1 = lengthString(str1);

 //выдиляем  динамическую память для записи в неё результата обьединения строк
 // и копируем в неё участки первой строки и подстроку в нужной посделовательности
 char* str2 = new char[temp+temp1];

 
 for (int i(0); i<(n-1); i++)
 {
	 str2[i] = str[i]; 
 }
 

 for (int i(n-1), j(0); j<(temp1+n-1); i++, j++)
 {
	 str2[i] = str1[j];
 }
 
 
  for (int i(temp1+n-1), j(n-1); i<(temp+temp1); i++, j++)
  {
	 str2[i] = str[j];
  }
 
   //копируем результат в первую строку, так как нужно освободить память для выделенной
   // временной строки
   str = new char [temp+temp1];

   for (int i(0); i<(temp+temp1); i++)
   {
	  str[i]=str2[i];
   }
   
   

  delete [] str2;

   return str;
 
}

char* сutString(char* str, int length, int position)//функция извлечения k(length) символов входной строки
{
	//выдиляем динамическую память для временной строки и копируем в неё необходимы отрезок основной строки
	char* temp = new char[length];

	for (int i(position-1), j(0); i<(length+position-1);i++, j++)
	{
		temp[j]=str[i];
	}

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

	   str = new char [length];

   for (int i(0); i<length; i++)
   {
	  str[i]=temp[i];
   }
   

   delete [] temp;
   return str;
}

Arthur
22.04.2015
В функции occurenceSubstring — переменная int level зачем?
Функция occurenceSubstring неверно работает если, например: строка StrSabSub, подстрока Sub, возвращает 4,
то есть функция сравнивает только первый и последний элемент, и длину подстроки, с элементами строки.
Войдите, чтобы ответить

Оставить комментарий

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

Интерфейс создаваемых функций:

Комментарии

Arthur

Arthur

Владимир Шумов

Андрей Ратушный

Adam1983

Arthur

Оставить комментарий