Pesterevaev

pesterevaev_week16_task1_1

Feb 19th, 2020
129
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.19 KB | None | 0 0
  1. #pragma once
  2. #include <cstring>
  3.  
  4.  
  5. int myStrCmp(const char* str1, const char* str2) {
  6.     int count1 = 0;
  7.     int count2 = 0;
  8.     int countEqual = 0;
  9.     while (str1[count1] != '\0') {
  10.         ++count1;
  11.     }  
  12.     ++count1;
  13.     while (str2[count2] != '\0') {
  14.         ++count2;
  15.     }  
  16.     ++count2;
  17.     if (count1 > count2)
  18.         return 1;
  19.     else if (count1 < count2)
  20.         return -1;
  21.     else {
  22.         for (int i = 0; i < count1; ++i) {
  23.             if (str1[i] > str2[i])
  24.                 return 1;
  25.             else if (str2[i] > str1[i])
  26.                 return -1;
  27.             else ++countEqual;
  28.         }
  29.     }
  30.     if (countEqual == count1) return 0;
  31. }
  32.  
  33. int stringToNumber(char* str) {
  34.     int sizeStr = 0;   
  35.     int* digits = new int[32];
  36.     int numInUnicod = 0;
  37.     int sizeNumber = 0;
  38.     int resultNumber = 0;
  39.     while (str[sizeStr] != '\0') {
  40.         numInUnicod = (int)str[sizeStr];
  41.         if (numInUnicod < 48 || numInUnicod > 57) {        
  42.             return -1;
  43.         }
  44.         else {
  45.             switch (numInUnicod) {
  46.                 case 48: digits[sizeStr] = 0; ++sizeNumber; break;
  47.                 case 49: digits[sizeStr] = 1; ++sizeNumber; break;
  48.                 case 50: digits[sizeStr] = 2; ++sizeNumber; break;
  49.                 case 51: digits[sizeStr] = 3; ++sizeNumber; break;
  50.                 case 52: digits[sizeStr] = 4; ++sizeNumber; break;
  51.                 case 53: digits[sizeStr] = 5; ++sizeNumber; break;
  52.                 case 54: digits[sizeStr] = 6; ++sizeNumber; break;
  53.                 case 55: digits[sizeStr] = 7; ++sizeNumber; break;
  54.                 case 56: digits[sizeStr] = 8; ++sizeNumber; break;
  55.                 case 57: digits[sizeStr] = 9; ++sizeNumber; break;
  56.             }
  57.         }
  58.         ++sizeStr;     
  59.     }  
  60.     for (int i = 0; i < sizeNumber; ++i){
  61.         for (int j = 0; j < sizeNumber - i - 1; ++j) {
  62.             digits[i] *= 10;
  63.         }      
  64.         resultNumber += digits[i];
  65.     }
  66.     delete[] digits;
  67.     return resultNumber;// не учла отрицательные числа
  68. }
  69.  
  70. char* numberToString(int number) {
  71.     int arrayDigit[32] = {};
  72.     int countDigit = 0;
  73.     for (int i = number / 10; i >= 0; i /= 10) {
  74.         if (i == 0) {
  75.             arrayDigit[countDigit] = number;
  76.             break;
  77.         }
  78.         int digit = number - i * 10;       
  79.         arrayDigit[countDigit] = digit;
  80.         ++countDigit;
  81.         number = i;
  82.     }  
  83.     char* strDigit = new char[countDigit + 1];// где очистить эту память???
  84.     int countChar = 0;
  85.     for (int i = countDigit; i >= 0; --i) {
  86.         switch (arrayDigit[i]) {
  87.         case 0: strDigit[countChar] = '0'; ++countChar; break;
  88.             case 1: strDigit[countChar] = '1'; ++countChar; break;
  89.             case 2: strDigit[countChar] = '2'; ++countChar; break;
  90.             case 3: strDigit[countChar] = '3'; ++countChar; break;
  91.             case 4: strDigit[countChar] = '4'; ++countChar; break;
  92.             case 5: strDigit[countChar] = '5'; ++countChar; break;
  93.             case 6: strDigit[countChar] = '6'; ++countChar; break;
  94.             case 7: strDigit[countChar] = '7'; ++countChar; break;
  95.             case 8: strDigit[countChar] = '8'; ++countChar; break;
  96.             case 9: strDigit[countChar] = '9'; ++countChar; break;
  97.         }      
  98.     }
  99.     strDigit[countDigit + 1] = '\0';
  100.     return strDigit;
  101. }
  102. char* upperCase(char* str) {
  103.     int sizeStr = strlen(str);
  104.     for (int i = 0; i < sizeStr; ++i) {
  105.         int numUtf8 = (int)str[i];
  106.         switch (numUtf8) {
  107.         case 97: str[i] = 'A'; break;
  108.         case 98: str[i] = 'B'; break;
  109.         case 99: str[i] = 'C'; break;
  110.         case 100: str[i] = 'D'; break;
  111.         case 101: str[i] = 'E'; break;
  112.         case 102: str[i] = 'F'; break;
  113.         case 103: str[i] = 'G'; break;
  114.         case 104: str[i] = 'H'; break;
  115.         case 105: str[i] = 'I'; break;
  116.         case 106: str[i] = 'J'; break;
  117.         case 107: str[i] = 'K'; break;
  118.         case 108: str[i] = 'L'; break;
  119.         case 109: str[i] = 'M'; break;
  120.         case 110: str[i] = 'N'; break;
  121.         case 111: str[i] = 'O'; break;
  122.         case 112: str[i] = 'P'; break;
  123.         case 113: str[i] = 'Q'; break;
  124.         case 114: str[i] = 'R'; break;
  125.         case 115: str[i] = 'S'; break;
  126.         case 116: str[i] = 'T'; break;
  127.         case 117: str[i] = 'U'; break;
  128.         case 118: str[i] = 'V'; break;
  129.         case 119: str[i] = 'W'; break;
  130.         case 120: str[i] = 'X'; break;
  131.         case 121: str[i] = 'Y'; break;
  132.         case 122: str[i] = 'Z'; break;
  133.         }
  134.     }
  135.     return str;
  136. }
  137.  
  138. char* lowerCase(char* str) {
  139.     int sizeStr = strlen(str);
  140.     for (int i = 0; i < sizeStr; ++i) {
  141.         int numUtf8 = (int)str[i];
  142.         switch (numUtf8) {
  143.         case 65: str[i] = 'a'; break;
  144.         case 66: str[i] = 'b'; break;
  145.         case 67: str[i] = 'c'; break;
  146.         case 68: str[i] = 'd'; break;
  147.         case 69: str[i] = 'e'; break;
  148.         case 70: str[i] = 'f'; break;
  149.         case 71: str[i] = 'g'; break;
  150.         case 72: str[i] = 'h'; break;
  151.         case 73: str[i] = 'i'; break;
  152.         case 74: str[i] = 'j'; break;
  153.         case 75: str[i] = 'k'; break;
  154.         case 76: str[i] = 'l'; break;
  155.         case 77: str[i] = 'm'; break;
  156.         case 78: str[i] = 'n'; break;
  157.         case 79: str[i] = 'o'; break;
  158.         case 80: str[i] = 'p'; break;
  159.         case 81: str[i] = 'q'; break;
  160.         case 82: str[i] = 'r'; break;
  161.         case 83: str[i] = 's'; break;
  162.         case 84: str[i] = 't'; break;
  163.         case 85: str[i] = 'u'; break;
  164.         case 86: str[i] = 'v'; break;
  165.         case 87: str[i] = 'w'; break;
  166.         case 88: str[i] = 'x'; break;
  167.         case 89: str[i] = 'y'; break;
  168.         case 90: str[i] = 'z'; break;
  169.         }
  170.     }
  171.     return str;
  172. }
  173.  
  174. char* myStrRev(char* str) {
  175.     int sizeStr = strlen(str); 
  176.     int countStr = sizeStr - 1;
  177.     char* newStr = new char[sizeStr];// и эту память где очистить, не понятно
  178.     for (int i = 0; i < sizeStr; ++i) {
  179.         newStr[i] = str[countStr];
  180.         --countStr;
  181.     }
  182.     newStr[sizeStr] = '\0';
  183.     return newStr;
  184. }
Add Comment
Please, Sign In to add comment