Volosatova_doch_huini

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

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <sstream>
#include <cstring>
#include <regex>
#include <iomanip>

#define EPS 10        //конечное число шагов

using namespace std;

int digit_check (const char* argv) {
std::string str = argv;
std::cmatch result;
std::regex regular ("[A-Fa-f0-9]+");

if (std::regex_match(str.c_str(), result, regular))
return 1;
else return 0;
}

long reverse(long a)      //функция переворота числа
{
  long y = 0;
  while(a)
  {
    y = y * 10 + a % 10;
    a /= 10;
  }
  return y;
}

int bin_sum(int a, int b)
{
int sum = 0, digit = 0, carry = 0, digit_rank = 1;

// Calculate the sum
while (a > 0 || b > 0 || carry)
{
// Calculate the digit
digit = a % 10 + b % 10 + carry;

// Determine if you should carry or not
if (digit > 1)
{
carry = 1;
digit %= 2;
}
else
carry = 0;

// Add the digit at the beggining of the sum
sum += digit * digit_rank;
digit_rank *= 10;

// Get rid of the digits of a and b we used
a /= 10;
b /= 10;
}
return sum;
}

int octal_sum(int a, int b)
{
int sum = 0, digit = 0, carry = 0, digit_rank = 1;

// Calculate the sum
while (a > 0 || b > 0 || carry)
{
// Calculate the digit
digit = a % 10 + b % 10 + carry;

// Determine if you should carry or not
if (digit > 7)
{
carry = 1;
digit %= 8;
}
else
carry = 0;

// Add the digit at the beggining of the sum
sum += digit * digit_rank;
digit_rank *= 10;

// Get rid of the digits of a and b we used
a /= 10;
b /= 10;
}
return sum;
}
char hex_digit(int num)
{
  switch (num) {
  case 0: return '0';
  case 1: return '1';
  case 2: return '2';
  case 3: return '3';
  case 4: return '4';
  case 5: return '5';
  case 6: return '6';
  case 7: return '7';
  case 8: return '8';
  case 9: return '9';
  case 10: return 'A';
  case 11: return 'B';
  case 12: return 'C';
  case 13: return 'D';
  case 14: return 'E';
  case 15: return 'F';
  }
}

std::string shifting2(int num)
{
    std::string B[16] = { "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F" };
    std::string answr = "";
    int A[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
    int num2;
    int ssc[33];
    int i = 0;
    while (num != 0) {
        num2 = num / 16;
        ssc[i] = num - (num2 * 16);
        num = num2;
        i++;
    }
    for (int j = i-1; j >= 0; j--)
    {
        //std::cout << "im here" << std::endl;
        for (int k = 0; k < 16; k++)
        {
            if (ssc[j] == A[k])
                answr += B[k];
        }

    }
    return answr;
}



class Digit
{
private:
  long long number;       //очередное полученное число, в начале задается аргументом
  const char* number_hex;
  const char* reverse_hex_number;
  long long reverse_number;   //перевернутое вариант числа
  int flags[4];          //2CC, 8CC, 10CC, 16CC
  int answer;
public:
  const char* hex_sum(const char*);
  Digit(long long);       //конструктор преобразования
  Digit(const char*);
  void set_polindrom();
  int check_polindrom();
  void det_notation();        //метод определяет, в каких СС может быть представлено число
  void get_answer();
  int digit_check_notation();
  void reverse_hex();
};
inline const char* Digit::hex_sum(const char* a){
  int n1, n2;
  std::string s1;
  s1 = a;
  std::istringstream(a) >> std::hex >> n1;
  std::string rev = std::string(s1.rbegin(), s1.rend());
  std::istringstream(rev) >> std::hex >> n2;
  //cout << n1 <<", " << n2 << endl;
  //cout << "s1:" << rev << endl;
  const char* crev = rev.c_str();
  reverse_hex_number = crev;
  //cout << crev << endl;
  cout << "Перевернутое число равно: " << reverse_hex_number << endl;
  int sum = n1 + n2;
  std::string sum1 = shifting2(sum);

  const char* cstr = sum1.c_str();
  number_hex = cstr;
  std::cout << "Их сумма равна: " << cstr << std::endl;
  return cstr;
}
/*inline void Digit::reverse_hex()
{
  int str1 = strlen(number_hex);
  char* str2 = new char[str1];
  strcpy(str2, number_hex);
  char* str3 = new char[str1];
  int i;
  int j = 0;
  for(i = str1-1; i >= 0; i--, j++)
  {
    str3[j] = str2[i];
  }
  reverse_hex_number = str3;
  cout << str3;
  delete str2;
  delete str3;

}*/
inline int Digit::digit_check_notation () {
std::string str = number_hex;
std::cmatch result;
std::regex regular2 ("[0-1]+");
std::regex regular8("[0-7]+");
std::regex regular10 ("[0-9]+");
std::regex regular16 ("[A-Fa-f0-9]+");

if (std::regex_match(str.c_str(), result, regular2)) {
number = atoi(number_hex);
}

else if (std::regex_match(str.c_str(), result, regular8)){
number = atoi(number_hex);
flags[0] = 0;
}

else if (std::regex_match(str.c_str(), result, regular10)){
number = atoi(number_hex);
flags[0] = 0;
flags[1] = 0;
}

else if (std::regex_match(str.c_str(), result, regular16))
{
  flags[0] = 0;
  flags[1] = 0;
  flags[2] = 0;
}
}

inline Digit::Digit(const char* s)
{
  number_hex = s;
  reverse_number = 0;
  for(int i = 0; i < 4; i++)
    flags[i] = 1;
}
inline void Digit::get_answer()
{
  this->det_notation();     //определяем, в каких СС число может быть представлено
  cout << "Введите, в кокой возможной СС вы хотите провести вычисления" << endl;
  for(int i = 0; i < 4; i++)
    cout << flags[i] << " " << endl;
  if(flags[0])
  {
    cout << "1 - 16CC; 2 - 10CC; 3 - 8CC; 4 - 2CC" << endl;
    cin >> answer;
  }
  else if(flags[1])
  {
    cout << "1 - 16CC; 2 - 10CC; 3 - 8CC" << endl;
    cin >> answer;
  }
  else if(flags[2])
  {
    cout << "1 - 16CC; 2 - 10CC" << endl;
    cin >> answer;
  }
  else
    cout << "Вы ввели чилсо в 16 СС" << endl;
}
inline void Digit::det_notation()
{

 this->digit_check_notation();

}

inline int Digit::check_polindrom()
{
if(flags[0] != 0 || flags[1] != 0 || flags[2] != 0 && answer != 1)
{
  if(number != reverse(number))
  {
    //cout << "Вощтш" << endl;
    cout << "Сумма данных чисел равная " << number << " не является полиндромом"
         << " для предыдущего числа!" << endl;
    cout << endl;
    return 1;
  }
  else
  {
    cout << "Их сумма является полиндромом: " << number << ". Итоговое число: "
         << number << endl;
    return 0;
  }
}
else
{
  if(!(strcmp(number_hex, reverse_hex_number)))
  {
    cout << "Сумма данных чисел равная " << number_hex << " не является полиндромом"
         << " для предыдущего числа!" << endl;
    cout << endl;
    return 1;
  }
  else
  {
    cout << "Их сумма является полиндромом: " << number_hex<< ". Итоговое число: "
         << number_hex << endl;
    return 0;
  }
}

}

inline void Digit::set_polindrom()
{
  if(flags[0] != 0 || flags[1] != 0 || flags[2] != 0 && answer != 1)
  {
    cout << "Текущее число: "<< number << endl;
    reverse_number = reverse(number);
    cout << "Перевернутое число равно: " << reverse_number << endl;
  }
  else
  {
    cout << "Текущее число: "<< number_hex << endl;
    //cout << "Перевернутое число равно: " << reverse_hex_number << endl;
  }

  /*for(int i = 0; i < 4; i++)
    cout << flags[i] << " " << endl;
  */
  if(flags[0])
  {
    switch(answer)
    {
      case 4:
        number = bin_sum(number, reverse_number);
        //cout << number << endl;
        break;
      case 3:
        number = octal_sum(number, reverse_number);
        //cout << number << endl;
        break;
      case 2:
        reverse_number = reverse(number);
        number += reverse_number;
        //cout << number << endl;
        break;
      case 1:
        break;
    }
  }
  else if(flags[1])
  {
    switch(answer)
    {
      case 3:
        number = octal_sum(number, reverse_number);
        //cout << number << endl;
        break;
      case 2:
        reverse_number = reverse(number);
        number += reverse_number;
        break;
      case 1:
        break;
    }
  }
  else if(flags[2])
  {
    switch(answer)
    {
      case 2:
        reverse_number = reverse(number);
        number += reverse_number;
        break;
      case 1:
        number_hex = hex_sum(number_hex);
        break;
    }
  }
  else
  {
    //cout << "Djitk" << endl;
    number_hex = hex_sum(number_hex);
  }

}

/*inline Digit::Digit(long long a)
{
  number = a;
  reverse_number = 0;
  for(int i = 0; i < 4; i++)
    flags[i] = 1;
};*/

int main(int argc, const char** argv)
{
  int i = 0;    //счетчик
  Digit* a;
  if(argc != 2)
  {
    cout << "Ошибка во время ввода! "
         << "Введите изначальное число!" << endl;
    exit(255);
  }
  if(digit_check(argv[1]))
  {
    a = new Digit(argv[1]);
    //cout << "hex number" << endl;
  }
  else
  {
    cout << "Ошибка ввода!" << endl;
    exit(255);
  }
  a->get_answer();
  while(i < EPS)
  {
    a->set_polindrom();
    if(a->check_polindrom())      //если полиндром не равен самому себе
      i++;
    else
      break;
  }
  if(i >= EPS)
    cout << "Из введенного Вами числа не возможно получить"
         << " полиндром, используя метод конечных сумм!" << endl;
  delete a;
  return 0;
}