Выделение памяти с помощью функции realloc - C (СИ)

Узнай цену своей работы

Формулировка задачи:

в общем задачка по сути своей вроде бы легкая, должна укладываться в 60 строчек, но что-то допереть не могу. Суть задания в том, что в у нас есть строка вида AB5CDE10. При выводе нам должно выйти ABBBBBCDEEEEEEEEEE, то есть если после чтения знака не следует десятичное число, знак копируем 1 раз до выходного ряда, если после чтение знака следует десятичное число, прочитаем это число N раз и до выхода скопируем этот самый знак N раз. Причем тут используется чтение кодов ASCII. Вот что до меня пока нашло, как это изобразить:
Листинг программы 
  1. #ifndef __PROGTEST__
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <ctype.h>
  6. #include <assert.h>
  7. #define MAX 1000000
  8.  
  9. #endif /* __PROGTEST__ */
  10.  
  11. char * RLEDecompress ( const char * src ){
  12.     //char pole[10000];//*pole=(char*)malloc(sizeof(pole)*MAX);
  13.     int kolvo=0;
  14.     int i=0;
  15.     while(src[kolvo]!=NULL){
  16.         kolvo++;
  17.     }
  18.     for(i=0; i<kolvo; i++){
  19.         if(src[i]<48 || src[i]>57){
  20.             if(src[i+1]!='0'){
  21.                 printf("%c", src[i]);
  22.             }
  23.         }
  24.         else {
  25.             int cif=1;
  26.             int cislo=0;
  27.             cislo=src[i]-48;
  28.             while (src[i+1]>=48 && src[i+1]<=57){
  29.                 cislo=0;
  30.                 cif++;
  31.                 i++;
  32.             }
  33.             if(cif>1){
  34.                 int step1=0, step2=1;
  35.                 int k=0, j=0, l=0;
  36.                 for (k=i; k>i-cif; k--){
  37.                     for(j=0; j<step1; j++){
  38.                         step2=step2*10;
  39.                     }
  40.                     cislo=cislo+(src[k]-48)*step2;
  41.                     step1++;
  42.                     step2=1;
  43.                 }
  44.                 for(l=0;l<cislo-1; l++){
  45.                     printf("%c", src[i-cif]);
  46.                 }
  47.  
  48.             }
  49.             if (cif==1) {
  50.                 int j = 0;
  51.                 for (j = 0; j < cislo - 1; j++) {
  52.                     printf("%c", src[i - cif]);
  53.                 }
  54.             }
  55.         }
  56.     }
  57.     return 0;
  58.  
  59. }
  60.  
  61. #ifndef __PROGTEST__
  62. int main ( int argc, char * argv [] )
  63. {
  64.     char * res=(char*)malloc(sizeof(char)* MAX);
  65.  
  66.     assert ( ! strcmp (
  67.             (res = RLEDecompress ( "He4llo world!" )),
  68.             "Hello world!" ));
  69.     free ( res );
  70.  
  71.     assert ( ! strcmp (
  72.             (res = RLEDecompress ( "Hello 30world!" )),
  73.             "Hello                              world!" ));
  74.     free ( res );
  75.  
  76.     assert ( ! strcmp (
  77.             (res = RLEDecompress ( "Hel2o world!10" )),
  78.             "Hello world!!!!!!!!!!" ));
  79.     free ( res );
  80.  
  81.     assert ( ! strcmp (
  82.             (res = RLEDecompress ( "H2e6l8o15 35w5o6r-2d0!" )),
  83.             "HHeeeeeellllllllooooooooooooooo                                   wwwwwoooooor--!" ));
  84.     free ( res );
  85.  
  86.     return 0;
  87. }
  88. #endif /* __PROGTEST__ */
то что в функции main было уже дано. осталось дело за малым-выделение памяти. Помогите с этим пожалуйста.

Решение задачи: «Выделение памяти с помощью функции realloc»

textual
Листинг программы 
  1. #ifndef __PROGTEST__
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <ctype.h>
  6. #include <assert.h>
  7.  
  8.  
  9. #endif /* __PROGTEST__ */
  10.  
  11. char * RLEDecompress(const char * src){
  12.     int kolvo = 0;
  13.     int i = 0;
  14.     int size = 100, p = -1;
  15.     char *res1;
  16.     res1 = (char *)malloc(size*sizeof(char));
  17.     kolvo = strlen(src);
  18.     for (i = 0; i<kolvo; i++){
  19.         if (src[i]<48 || src[i]>57){
  20.             if (src[i + 1] != '0'){
  21.                 p++;
  22.                 if (p == size - 2){
  23.                     size *= 1.5;
  24.                     res1 = (char *)realloc(res1, size*sizeof(char));
  25.                     if (res1 == NULL) exit(1);
  26.                 }
  27.                 res1[p] = src[i];
  28.             }
  29.         }
  30.         else {
  31.             int cif = 1;
  32.             int cislo = 0;
  33.             cislo = src[i] - 48;
  34.             while (src[i + 1] >= 48 && src[i + 1] <= 57){
  35.                 cislo = 0;
  36.                 cif++;
  37.                 i++;
  38.             }
  39.             if (cif>1){
  40.                 int step1 = 0, step2 = 1;
  41.                 int k = 0, j = 0, l = 0;
  42.                 for (k = i; k>i - cif; k--){
  43.                     for (j = 0; j<step1; j++){
  44.                         step2 = step2 * 10;
  45.                     }
  46.                     cislo = cislo + (src[k] - 48)*step2;
  47.                     step1++;
  48.                     step2 = 1;
  49.                 }
  50.                 for (l = 0; l<cislo - 1; l++){
  51.                     p++;
  52.                     if (p == size - 2){
  53.                         size *= 1.5;
  54.                         res1 = (char *)realloc(res1, size*sizeof(char));
  55.                         if (res1 == NULL) exit(1);
  56.                     }
  57.                     res1[p] = src[i - cif];
  58.                 }
  59.  
  60.             }
  61.             if (cif == 1) {
  62.                 int j = 0;
  63.                 for (j = 0; j < cislo - 1; j++) {
  64.                     p++;
  65.                     if (p == size - 2){
  66.                         size *= 1.5;
  67.                         res1 = (char *)realloc(res1, size*sizeof(char));
  68.                         if (res1 == NULL) exit(1);
  69.                     }
  70.                     res1[p] = src[i - cif];
  71.                 }
  72.             }
  73.         }
  74.     }
  75.     res1[p + 1] = '\0';
  76.     return res1;
  77. }
  78.  
  79. #ifndef __PROGTEST__
  80. int main(int argc, char * argv[])
  81. {
  82.     char * res;
  83.     assert(!strcmp(
  84.         (res = RLEDecompress("Hello world!")),
  85.         "Hello world!"));
  86.     free(res);
  87.  
  88.     assert(!strcmp(
  89.         (res = RLEDecompress("Hello 30world!")),
  90.         "Hello                              world!"));
  91.     free(res);
  92.  
  93.     assert(!strcmp(
  94.         (res = RLEDecompress("Hel2o world!10")),
  95.         "Hello world!!!!!!!!!!"));
  96.     free(res);
  97.  
  98.     assert(!strcmp(
  99.         (res = RLEDecompress("H2e6l8o15 35w5o6r-2d0!")),
  100.         "HHeeeeeellllllllooooooooooooooo                                   wwwwwoooooor--!"));
  101.     free(res);
  102.  
  103.     return 0;
  104. }
  105. #endif /* __PROGTEST__ */

Объяснение кода листинга программы

В данном коде реализована функция RLEDecompress, которая принимает на вход строку, закодированную по алгоритму RLE (Run-Length Encoding), и возвращает декодированную строку. Список действий, которые выполняются в коде:

  1. Инициализация переменных:
    • kolvo = 0;
    • i = 0;
    • size = 100;
    • p = -1;
    • res1 = (char )malloc(sizesizeof(char));
    • kolvo = strlen(src);
  2. Проход по исходной строке:
    • for (i = 0; i < kolvo; i++){
    • if (src[i]<48 || src[i]>57){
      • if (src[i + 1] != '0'){
      • p++;
      • if (p == size - 2){
        • size *= 1.5;
        • res1 = (char )realloc(res1, sizesizeof(char));
        • if (res1 == NULL) exit(1); }
      • res1[p] = src[i]; } }
    • else {
      • int cif = 1;
      • int cislo = 0;
      • cislo = src[i] - 48;
      • while (src[i + 1] >= 48 && src[i + 1] <= 57){
      • cislo = 0;
      • cif++;
      • i++; }
      • if (cif>1){
      • int step1 = 0, step2 = 1;
      • int k = 0, j = 0, l = 0;
      • for (k = i; k>i - cif; k--){
        • for (j = 0; j<step1; j++){
        • step2 = step2 * 10; }
        • cislo = cislo + (src[k] - 48)*step2;
        • step1++;
        • step2 = 1; }
      • for (l = 0; l<cislo - 1; l++){
        • p++;
        • if (p == size - 2){
        • size *= 1.5;
        • res1 = (char )realloc(res1, sizesizeof(char));
        • if (res1 == NULL) exit(1); }
        • res1[p] = src[i - cif]; } }
      • if (cif == 1) {
      • int j = 0;
      • for (j = 0; j < cislo - 1; j++) {
        • p++;
        • if (p == size - 2){
        • size *= 1.5;
        • res1 = (char )realloc(res1, sizesizeof(char));
        • if (res1 == NULL) exit(1); }
        • res1[p] = src[i - cif]; } } }
  3. Добавление завершающего нулевого символа в декодированную строку:
    • res1[p + 1] = '\0';
  4. Возврат декодированной строки:
    • return res1; В функции main() производится тестирование функции RLEDecompress на нескольких примерах. В случае успешного завершения функции, строка, переданная в качестве аргумента, сравнивается с результатом декодирования этой же строки функцией RLEDecompress. Если строки совпадают, то выводится сообщение об успешном прохождении теста. Затем, с помощью функции free(), освобождается память, выделенная под результат декодирования.

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

6   голосов , оценка 4.167 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут
Похожие ответы