Advertisement
Ilya_and

Строки

Dec 19th, 2018
79
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 11.14 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <Windows.h>
  3. #include <iostream>
  4. using namespace std;
  5. int strlen1(char *s) {
  6.     int n = 0;
  7.     while (s[n] != '\0')
  8.         n++;
  9.     return n;
  10. }
  11. int strlen2(char *s) {
  12.     int n;
  13.     for (n = 0; *s; ++s)
  14.         n++;
  15.     return n;
  16. }
  17. int strlen3(char *s) {
  18.     int n = 0;
  19.     for (int i = 0;; i++) {
  20.         if (s[i] != '\0')
  21.             n++;
  22.         else break;
  23.     }
  24.     return n;
  25. }
  26. int strlen4(char *s) {
  27.     int n = 0;
  28.     char *s1 = s;
  29.     begin:
  30.         if (*s1) {
  31.             n++;
  32.             *s1++;
  33.             goto begin;
  34.         }
  35.     return n;
  36. }
  37.  
  38. char* strcpy1(char *dest, char *s, int p, int k) {
  39.     int N = strlen1(s);
  40.     if (k < 1 || p > N)
  41.         return dest;
  42.     if (p + k > N)
  43.         k = N - p;
  44.     for (int i = 0; i < k; i++, p++) {
  45.         dest[i] = s[p];
  46.     }
  47.     return dest;
  48. }
  49. char* strcpy2(char *dest, char *s, int p, int k) {
  50.     int N = strlen1(s);
  51.     if (k < 1 || p > N)
  52.         return dest;
  53.     if (p + k > N)
  54.         k = N - p;
  55.     int i = 0;
  56.     p++;
  57.     while (k != 0 && dest != '\0') {
  58.         *(dest + i) = *(s + p - 1);
  59.         i++;
  60.         p++;
  61.         k--;
  62.     }
  63.     return dest;
  64. }
  65. char* strcpy3(char *dest, char *s, int p, int k) {
  66.     int N = strlen1(s);
  67.     if (k < 1 || p > N)
  68.         return dest;
  69.     if (p + k > N)
  70.         k = N - p;
  71.     int j = 0;
  72.     while (p <= N && k != 0) {
  73.         dest[j] = s[p];
  74.         p++;
  75.         k--;
  76.         j++;
  77.     }
  78.     return dest;
  79. }
  80. char* strcpy4(char *dest, char *s, int p, int k) {
  81.     int N = strlen1(s);
  82.     if (k < 1 || p > N)
  83.         return dest;
  84.     if (p + k > N)
  85.         k = N - p;
  86.     for (int i = 0; s[i] != 0; i++) {
  87.         if (i < k) {
  88.             dest[i] = s[p];
  89.             p++;
  90.         }
  91.     }
  92.     return dest;
  93. }
  94.  
  95. int strcmp1(char *s1, char *s2) {
  96.     for (int i = 0; i < strlen1(s1); i++) {
  97.         if (s1[i] < s2[i])
  98.             return -1;
  99.         if (s1[i] > s2[i])
  100.             return 1;
  101.     }
  102.     if (strlen1(s2) > strlen1(s1)) {
  103.         return -1;
  104.     }
  105.     else {
  106.         return 0;
  107.     }
  108. }
  109. int strcmp2(char *s1, char *s2) {
  110.     int i = 0;
  111.     while (s1[i] || s2[i]) {
  112.         if (s1[i] < s2[i])
  113.             return -1;
  114.         if (s1[i] > s2[i])
  115.             return 1;
  116.         i++;
  117.     }
  118.     return 0;
  119. }
  120. int strcmp3(char *s1, char *s2) {
  121.     while (*s1 && *s2) {
  122.         if (*s1 < *s2)
  123.             return -1;
  124.         if (*s1 > *s2)
  125.             return 1;
  126.         *s1++; *s2++;
  127.     }
  128.     if (strlen1(s2) == strlen1(s1)) {
  129.         return 0;
  130.     }
  131.     else {
  132.         if (strlen1(s2) > strlen1(s1)) {
  133.             return -1;
  134.         }
  135.         else
  136.             return 1;  
  137.     }
  138. }
  139. int strcmp4(char *s1, char *s2) {
  140.     int N = strlen1(s1);
  141.     int i = 0;
  142.     begin:
  143.     if (i < N) {
  144.         if (s1[i] < s2[i])
  145.             return -1;
  146.         if (s1[i] > s2[i])
  147.             return 1;
  148.         i++;
  149.         goto begin;
  150.     }
  151.     return s2[i] ? -1 : 0;
  152. }
  153.  
  154. char* strcat1(char *dest, char *s) {
  155.     char *n = dest;
  156.     while (*dest)
  157.         dest++;
  158.     while (*dest++ = *s++)
  159.         ;
  160.     *dest = '\0';
  161.     return n;
  162. }
  163. char *strcat2(char *dest, char *s) {
  164.     int i = 0;
  165.     while (dest[i])
  166.         i++;
  167.     for (int j = 0; j < strlen1(s); j++) {
  168.         dest[i] = s[j];
  169.         i++;
  170.     }
  171.     dest[i] = '\0';
  172.     return dest;
  173. }
  174. char *strcat3(char *dest, char *s) {
  175.     int i = strlen1(dest), j = 0;
  176.     begin:
  177.     if (j < strlen1(s)) {
  178.         dest[i] = s[j];
  179.         i++;
  180.         j++;
  181.         goto begin;
  182.     }
  183.     dest[i] = '\0';
  184.     return dest;
  185. }
  186. char *strcat4(char *dest, char *s) {
  187.     int i, j;
  188.     int N = 0;
  189.     for (i = 0; dest[i]; i++)
  190.         N++;
  191.     for (i = 0; s[i]; i++)
  192.         N++;
  193.     char* n = new char[N + 1];
  194.     for (i = 0, j = 0; dest[i]; i++, j++)
  195.         n[j] = dest[i];
  196.     for (i = 0; s[i]; i++, j++)
  197.         n[j] = s[i];
  198.     n[j] = '\0';
  199.     return n;
  200. }
  201.  
  202. char* strins1(char *sub, char *s, int p) {
  203.     int N = strlen1(sub) + strlen1(s);
  204.     if (p > strlen1(s))
  205.         p = strlen1(s);
  206.     if (p < 0)
  207.         p = 0;
  208.     char* n = new char[N + 1];
  209.     int i;
  210.     for(i = 0; i <= p - 1; i++)
  211.         n[i] = s[i];
  212.     for (int j = 0; j < strlen1(sub); j++, i++)
  213.         n[i] = sub[j];
  214.     for (int k = p; k < strlen1(s); k++, i++)
  215.         n[i] = s[k];
  216.     n[i] = '\0';
  217.     return n;
  218. }
  219. char* strins2(char *sub, char *s, int p) {
  220.     int N = strlen1(sub) + strlen1(s);
  221.     if (p > strlen1(s))
  222.         p = strlen1(s);
  223.     if (p < 0)
  224.         p = 0;
  225.     char* n = new char[N + 1];
  226.     int j = 0;
  227.     while (s[j] != 0) {
  228.         n[j] = s[j];
  229.         j++;
  230.     }
  231.     n[j] = '\0';
  232.     int i = p, k = 0;
  233. begin1:
  234.     int m = strlen1(n);
  235. begin2:
  236.     n[m + 1] = n[m];
  237.     m--;
  238.     if (m >= i)
  239.         goto begin2;
  240.     n[i] = sub[k];
  241.     i++, k++;
  242.     if (i < strlen1(sub) + p)
  243.         goto begin1;
  244.     return n;
  245. }
  246. char* strins3(char *sub, char *s, int p) {
  247.     int N = strlen1(sub) + strlen1(s);
  248.     if (p > strlen1(s))
  249.         p = strlen1(s);
  250.     if (p < 0)
  251.         p = 0;
  252.     char* n = new char[N + 1];
  253.     int i = 0, k = 0, t = p;
  254.     while (i <= p - 1) {
  255.         n[i] = s[i];
  256.         i++;
  257.     }
  258.     while (k < strlen1(sub)) {
  259.         n[i] = sub[k];
  260.         k++; i++;
  261.     }
  262.     while(t < strlen1(s)) {
  263.         n[i] = s[t];
  264.         t++; i++;
  265.     }
  266.     n[i] = '\0';
  267.     return n;
  268. }
  269. char* strins4(char *sub, char *s, int p) {
  270.     int N = strlen1(sub) + strlen1(s);
  271.     if (p > strlen1(s))
  272.         p = strlen1(s);
  273.     if (p < 0)
  274.         p = 0;
  275.     char* n = new char[N + 1];
  276.     int j = 0;
  277.     while (s[j] != 0) {
  278.         n[j] = s[j];
  279.         j++;
  280.     }
  281.     n[j] = '\0';
  282.     for (int i = p, k = 0; i < strlen1(sub) + p; i++, k++) {
  283.         for (int m = strlen1(n); m >= i; m--)
  284.             *(n + m + 1) = *(n + m);
  285.         *(n + i) = *(sub + k);
  286.     }
  287.     return n;
  288. }
  289. char* strdel1(char *s, int p, int k) {
  290.     if (p + k > strlen1(s))
  291.         k = strlen1(s) - p;
  292.     int i, j;
  293.     for (i = p; i < p + k; i++)
  294.         s[i] = s[i + k];
  295.     for (j = i; j <= strlen1(s) - k; j++)
  296.         s[j] = s[j + k];
  297.     return s;
  298. }
  299. char* strdel2(char *s, int p, int k) {
  300.     if (p + k > strlen1(s))
  301.         k = strlen1(s) - p;
  302.     int i = p;
  303.     while (i <= strlen1(s) - k) {
  304.         s[i] = s[i + k];
  305.         i++;
  306.     }
  307.     return s;
  308. }
  309. char* strdel3(char *s, int p, int k) {
  310.     if (p + k > strlen1(s))
  311.         k = strlen1(s) - p;
  312.     for (int i = p; i <= strlen1(s) - k; i++) {
  313.         *(s + i) = *(s + i + k);
  314.    }
  315.     return s;
  316. }
  317. char* strdel4(char *s, int p, int k) {
  318.     if (p + k > strlen1(s))
  319.         k = strlen1(s) - p;
  320.     begin:
  321.     if (p <= strlen1(s) - k) {
  322.         s[p] = s[p + k];
  323.         p++;
  324.         goto begin;
  325.     }
  326.     return s;
  327. }
  328. void teststrlen(char*s) {
  329.     printf("strlen1('%s')= %d\n", s, strlen1(s));
  330.     printf("strlen2('%s')= %d\n", s, strlen2(s));
  331.     printf("strlen3('%s')= %d\n", s, strlen3(s));
  332.     printf("strlen4('%s')= %d\n", s, strlen4(s));
  333.     printf("\n");
  334. }
  335. void teststrcpy(char *dest, char *s, int p, int k) {
  336.     printf("strcpy1('%s','%s', %d, %d)= ", dest, s, p, k);
  337.     printf("'%s'\n", strcpy1(dest, s, p, k));
  338.     for (int i = strlen1(dest) - 1; i >= 0; i--)
  339.         dest[i] = 0;
  340.     printf("strcpy2('%s','%s', %d, %d)= ", dest, s, p, k);
  341.     printf("'%s'\n", strcpy2(dest, s, p, k));
  342.     for (int i = strlen1(dest) - 1; i >= 0; i--)
  343.         dest[i] = 0;
  344.     printf("strcpy3('%s','%s', %d, %d)= ", dest, s, p, k);
  345.     printf("'%s'\n", strcpy3(dest, s, p, k));
  346.     for (int i = strlen1(dest) - 1; i >= 0; i--)
  347.         dest[i] = 0;
  348.     printf("strcpy4('%s','%s', %d, %d)= ", dest, s, p, k);
  349.     printf("'%s'\n", strcpy4(dest, s, p, k));
  350.     printf("\n");
  351. }
  352. void teststrcmp(char *s1, char *s2) {
  353.     printf("strcmp1('%s','%s')= %d\n", s1, s2, strcmp1(s1, s2));
  354.     printf("strcmp2('%s','%s')= %d\n", s1, s2, strcmp2(s1, s2));
  355.     printf("strcmp3('%s','%s')= %d\n", s1, s2, strcmp3(s1, s2));
  356.     printf("strcmp4('%s','%s')= %d\n", s1, s2, strcmp4(s1, s2));
  357.     printf("\n");
  358. }
  359. void teststrcat(char *dest, char *s) {
  360.     int n = strlen1(dest);
  361.     printf("strcat1('%s','%s')= ", dest, s);
  362.     printf("'%s'\n", strcat1(dest, s));
  363.     for (int i = n + strlen1(s); i >= n; i--)
  364.         dest[i] = 0;
  365.     printf("strcat2('%s','%s')= ", dest, s);
  366.     printf("'%s'\n", strcat2(dest, s));
  367.     for (int i = n + strlen1(s); i >= n; i--)
  368.         dest[i] = 0;
  369.     printf("strcat3('%s','%s')= ", dest, s);
  370.     printf("'%s'\n", strcat3(dest, s));
  371.     for (int i = n + strlen1(s); i >= n; i--)
  372.         dest[i] = 0;
  373.     printf("strcat4('%s','%s')= ", dest, s);
  374.     printf("'%s'\n", strcat4(dest, s));
  375.     for (int i = n + strlen1(s); i >= n; i--)
  376.         dest[i] = 0;
  377.     printf("\n");
  378. }
  379. void teststrins(char *sub, char *s, int p) {
  380.     printf("strins1('%s','%s', %d)= ", sub, s, p);
  381.     printf("'%s'\n", strins1(sub, s, p));
  382.     printf("strins2('%s','%s', %d)= ", sub, s, p);
  383.     printf("'%s'\n", strins2(sub, s, p));
  384.     printf("strins3('%s','%s', %d)= ", sub, s, p);
  385.     printf("'%s'\n", strins3(sub, s, p));
  386.     printf("strins4('%s','%s', %d)= ", sub, s, p);
  387.     printf("'%s'\n", strins4(sub, s, p));
  388.     printf("\n");
  389. }
  390. void teststrdel(char *s, int p, int k) {
  391.     char s1[100]{ 0 }; int i = 0;
  392.     while (s[i]) {
  393.         s1[i] = s[i];
  394.         i++;
  395.     }
  396.     i = 0;
  397.     printf("strdel1('%s', %d, %d)= ", s1, p, k);
  398.     printf("'%s'\n", strdel1(s1, p, k));
  399.     while (s[i]) {
  400.         s1[i] = s[i];
  401.         i++;
  402.     }
  403.     i = 0;
  404.     printf("strdel2('%s', %d, %d)= ", s1, p, k);
  405.     printf("'%s'\n", strdel2(s1, p, k));
  406.     while (s[i]) {
  407.         s1[i] = s[i];
  408.         i++;
  409.     }
  410.     i = 0;
  411.     printf("strdel3('%s', %d, %d)= ", s1, p, k);
  412.     printf("'%s'\n", strdel3(s1, p, k));
  413.     while (s[i]) {
  414.         s1[i] = s[i];
  415.         i++;
  416.     }
  417.     printf("strdel4('%s', %d, %d)= ", s1, p, k);
  418.     printf("'%s'\n", strdel4(s1, p, k));
  419.     printf("\n");
  420. }
  421. int main()
  422. {
  423.     setlocale(LC_ALL, "");
  424.     int answer;
  425.     begin:
  426.     system("cls");
  427.     printf("Выберите функцию:\n1.strlen\n2.strcpy\n3.strcmp\n4.strcat\n5.strins\n6.strdel\n");
  428.     scanf_s("%d", &answer);
  429.     switch (answer) {
  430.     case 1: {
  431.         system("cls");
  432.         printf("Тесты для функции strlen:\n");
  433.         char s1[] = "hello";
  434.         teststrlen(s1);
  435.         char s2[] = "456";
  436.         teststrlen(s2);
  437.         char s3[] = "";
  438.         teststrlen(s3);
  439.         char s4[] = "World123";
  440.         teststrlen(s4);
  441.         system("pause");
  442.         goto begin;
  443.     }
  444.     case 2: {
  445.         system("cls");
  446.         printf("Тесты для функции strcpy:\n");
  447.         int p, k;
  448.         char s1[] = "Hello";
  449.         char dest1[50] = "";
  450.         p = 1;
  451.         k = 3;
  452.         teststrcpy(dest1, s1, p, k);
  453.         char s2[] = "123456";
  454.         char dest2[50] = "";
  455.         p = 3;
  456.         k = 1;
  457.         teststrcpy(dest2, s2, p, k);
  458.         char s3[] = "rabbit";
  459.         char dest3[50] = "";
  460.         p = 10;
  461.         k = 4;
  462.         teststrcpy(dest3, s3, p, k);
  463.         char s4[] = "x123cut97";
  464.         char dest4[50] = "";
  465.         p = 2;
  466.         k = 5;
  467.         teststrcpy(dest4, s4, p, k);
  468.         system("pause");
  469.         goto begin;
  470.     }
  471.     case 3: {
  472.         system("cls");
  473.         printf("Тесты для функции strcmp:\n");
  474.         char s1[] = "Abc", s2[] = "Abc";
  475.         teststrcmp(s1, s2);
  476.         char s3[] = "help", s4[] = "help1";
  477.         teststrcmp(s3, s4);
  478.         char s5[] = "mother", s6[] = "mothEr";
  479.         teststrcmp(s5, s6);
  480.         char s7[] = "01234", s8[] = "01334";
  481.         teststrcmp(s7, s8);
  482.         system("pause");
  483.         goto begin;
  484.     }
  485.     case 4: {
  486.         system("cls");
  487.         printf("Тесты для функции strcat:\n");
  488.         char dest1[50] = "Hello ";
  489.         char s1[] = "world";
  490.         teststrcat(dest1, s1);
  491.         char dest2[50] = "123";
  492.         char s2[] = "456";
  493.         teststrcat(dest2, s2);
  494.         char dest3[50] = "Str";
  495.         char s3[] = "cat";
  496.         teststrcat(dest3, s3);
  497.         char dest4[50] = "100 - 23 = ";
  498.         char s4[] = "77";
  499.         teststrcat(dest4, s4);
  500.         system("pause");
  501.         goto begin;
  502.     }
  503.     case 5: {
  504.         system("cls");
  505.         printf("Тесты для функции strins:\n");
  506.         int p;
  507.         char s1[] = "012345-6";
  508.         char sub[] = "abc";
  509.         p = 6;
  510.         teststrins(sub, s1, p);
  511.         char s2[] = "0123456";
  512.         p = 0;
  513.         teststrins(sub, s2, p);
  514.         char s3[] = "0123456";
  515.         p = 4;
  516.         teststrins(sub, s3, p);
  517.         char s4[] = "0123456";
  518.         p = 12;
  519.         teststrins(sub, s4, p);
  520.         system("pause");
  521.         goto begin;
  522.     }
  523.     case 6: {
  524.         system("cls");
  525.         printf("Тесты для функции strdel:\n");
  526.         int p, k;
  527.         char s1[] = "0123456";
  528.         p = 1;
  529.         k = 2;
  530.         teststrdel(s1, p, k);
  531.         char s2[] = "Машина";
  532.         p = 0;
  533.         k = 2;
  534.         teststrdel(s2, p, k);
  535.         char s3[] = "str-1234del";
  536.         p = 3;
  537.         k = 5;
  538.         teststrdel(s3, p, k);
  539.         char s4[] = "workout478";
  540.         p = 4;
  541.         k = 15;
  542.         teststrdel(s4, p, k);
  543.         system("pause");
  544.         goto begin;
  545.     }
  546.     }
  547.     system("pause");
  548. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement