堆栈内存溢出
  繁体   English   中英

我已经连续两天在这个问题上讨论文件，但没有用。 不想作弊，你能指出问题吗

[英]i have been on this question for quaring the document for two days straight, and it is not working. don't want to cheat, can you point the problem

 原文  2023-01-29 09:45:17  5   2    c/ pointers/ realloc

问题描述

我无法调试正在发生的事情。 代码似乎是正确的，但我对指针的指针不熟悉，这里有 4 个系列。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define MAX_CHARACTERS 1005
#define MAX_PARAGRAPHS 5

char *kth_word_in_mth_sentence_of_nth_paragraph(char ****document, int k, int m, int n) {
    return *(*(*(document + n - 1) + m - 1) + k - 1);
}

char **kth_sentence_in_mth_paragraph(char ****document, int k, int m) { 
    return (*(*(document + m - 1) + k - 1));
}

char ***kth_paragraph(char ****document, int k) {
    return *(document + k - 1);
}

char ****get_document(char *text) {
    /* allocating memory */
    int len = strlen(text);
    /* allocate memory for each component first */
    char ****document = malloc(sizeof(char ***));
    char ***paragraph = malloc(sizeof(char **));
    char **sentence = malloc(sizeof(char *));
    char *word = malloc(sizeof(char) * 1024);
    /* connect all the components to point in the sequence that is required */
    *document = paragraph;
    *paragraph = sentence;
    *sentence = word;
    /* declare some numbers as iterators for the words, sentences,etc. */
    int parano = 0;
    int sentno = 0;
    int wordno = 0;
    int charno = 0;
    /* now iterate over the text filling and expanding the document at the same time */
    /*----------------------------------------------------------------------------------------------------*/
    /* feeding data in those spaces */
    for (int i = 0; i < len; i++) {
        if (text[i] == ' ') {
            /* wrapping the current word, that is, resizing to len + 1 */
            char *current_word = *(*(*(document + parano) + sentno) + wordno);
            current_word = realloc(current_word, strlen(current_word) + 1);
            /*  resizing the current sentence to add another word*/
            char **current_sentence = (*(*(document + parano) + sentno));
            current_sentence = realloc(current_sentence, sizeof(char *) * (wordno + 2));
            
            wordno++;
            charno = 0;
            /* allocating space to that new char * / word that has been created in the same sentence */
            *(*(*(document + parano) + sentno) + wordno) = malloc(sizeof(char) * 1000);
        }
        else if (text[i] == '.') {
            /* wrapping of the current word has to be done anyways */
            char *current_word1 = *(*(*(document + parano) + sentno) + wordno);
            current_word1 = realloc(current_word1, strlen(current_word1) + 1);
            charno = 0;
            
            if (text[i + 1] != '\n') {
                /* the paragraph does not change, and the sentence ends */
                /* resize that paragraph for adding another sentence */
                char ***current_para = *(document + parano);
                current_para = realloc(current_para, sizeof(char **) * (sentno + 2));
                sentno++;
                wordno = 0;
                /* allocating word to that sentence */
                *(*(document + parano) + sentno) = malloc(sizeof(char *));
                /* allocating space for that word */
                *(*(*(document + parano) + sentno) + wordno) = malloc(sizeof(char) * 1000);
            } else {
                /*  if this is the last sentence of this paragraph*/
                wordno = 0;
                charno = 0;
                sentno = 0;
            }
        }
        else if (text[i] == '\n') {
            /* paragraph has changed */
            /* add another paragraph to the document */
            document = realloc(document, sizeof(char ***) * (parano + 2));
            parano++;
            /* add sentence to that paragraph */
            (*(document + parano) ) = malloc(sizeof(char **));
            /* add a word to that paragrapgh */
            (*(*(document + parano) + sentno)) = malloc(sizeof(char *));
            /* allocate space for that word */
            *(*(*(document + parano) + sentno) + wordno) = malloc(sizeof(char) * 1000);
        } else {
            scanf("%c", *(*(*(document + parano) + sentno) + wordno) + charno);
            printf("%c\n", **(*(*(document + parano) + sentno) + wordno) + charno);
            charno++;
        }
    }
    return document;
}

char *get_input_text() {    
    int paragraph_count;
    scanf("%d", &paragraph_count);

    char p[MAX_PARAGRAPHS][MAX_CHARACTERS], doc[MAX_CHARACTERS];
    memset(doc, 0, sizeof(doc));
    getchar();
    for (int i = 0; i < paragraph_count; i++) {
        scanf("%[^\n]%*c", p[i]);
        strcat(doc, p[i]);
        if (i != paragraph_count - 1)
            strcat(doc, "\n");
    }

    char *returnDoc = (char *)malloc((strlen(doc)+1) * (sizeof(char)));
    strcpy(returnDoc, doc);
    return returnDoc;
}

void print_word(char *word) {
    printf("%s", word);
}

void print_sentence(char **sentence) {
    int word_count;
    scanf("%d", &word_count);
    for (int i = 0; i < word_count; i++) {
        printf("%s", sentence[i]);
        if (i != word_count - 1)
            printf(" ");
    }
} 

void print_paragraph(char ***paragraph) {
    int sentence_count;
    scanf("%d", &sentence_count);
    for (int i = 0; i < sentence_count; i++) {
        print_sentence(*(paragraph + i));
        printf(".");
    }
}

int main() {
    char *text = get_input_text();
    char ****document = get_document(text);

    int q;
    scanf("%d", &q);

    while (q--) {
        int type;
        scanf("%d", &type);

        if (type == 3) {
            int k, m, n;
            scanf("%d %d %d", &k, &m, &n);
            char *word = kth_word_in_mth_sentence_of_nth_paragraph(document, k, m, n);
            print_word(word);
        }
        else if (type == 2) {
            int k, m;
            scanf("%d %d", &k, &m);
            char **sentence = kth_sentence_in_mth_paragraph(document, k, m);
            print_sentence(sentence);
        } else {
            int k;
            scanf("%d", &k);
            char ***paragraph = kth_paragraph(document, k);
            print_paragraph(paragraph);
        }
        printf("\n");
    }     
}

这是 Hackerrank 上针对 C 语言的问题之一。 链接到问题hacker rank question my profile

显示已中止， realloc无效大小。 在过去的两天里我找不到任何东西。

问题的输入

2
Learning C is fun.
Learning pointers is more fun.It is good to have pointers.
3
1 2
2
5
6
2 1 1
4
3 1 1 1

预计 output

Learning pointers is more fun.It is good to have pointers.
Learning C is fun
Learning

2 个解决方案

解决方案1
 0 已采纳  2023-01-30 02:08:04

  1. 在处理常规字符（最后的 else 子句）时，您会读取额外的输入而不是对text进行操作，即而不是：
                scanf("%c", &document[parano][sentno][wordno][charno]);
                printf("%c\n", document[parano][sentno][wordno][charno]);
                charno++;

你想做：

                document[parano][sentno][wordno][charno++] = text[i];

当我们第一次点击text[i] == ' '时， ***document的值是“3\n1 2\n2\n”，但你希望它是“Learning”。

  1. （不固定）当处理一个单词 (`text[i] == ' ') 时，您扩展了当前单词，但是，当您最初分配它时，您硬编码了 1000，所以这没有意义。 始终如一。

  2. sentno 、 parano 、 wordno 、 charno是索引，但同样表明它们是计数。 混淆并没有错，为什么在重新定位时必须使用wordno + 2 。

  3. 以‘\0’结束单词。

  4. 当你处理 ' ' 时，你添加了另一个你可能需要也可能不需要的词，这很好。 但是当处理一个'。' 你先看看后面的字母是不是\n 。 始终如一。 如果你向前看，那么你需要检查i + 1 < len ，它很脆弱，比如说，在\n之前有一个杂散空间。

  5. （未修复）Memory 泄漏。 由于子元素（段落、句子和单词）的大小是get_document()的私有实现细节，您将重构代码以使其可用。 我建议：

struct document {
   char ****document;
   size_t paragraphs;
   size_t sentences;
   size_t words;
}

  1. （不固定）重复数据删除。 与打印功能类似，为每种类型创建分配 function。

  2. （不固定，真的） get_input_text() 。 您将其拆分为段落，然后将所有内容再次连接到一个局部变量中，然后将其复制到一个动态分配的变量中：

   char *str = malloc(BUFFER_LEN);
   for(size_t i = 0, l = 0; l < lines && i + 1 < BUFFER_LEN; i += strlen(str + i)) {
       int rv = fgets(str + i, BUFFER_LEN - i, stdin);
       if(!rv) {
          // handle error
          break;
       }
   }
   return s;
  1. （不固定）将 I/O 与处理分开。 这简化了测试，并且更容易弄清楚发生了什么。 在main(), you read a query type then 1 to 3 numbers. scanf()` 告诉您读取了多少项目，因此您只需执行即可。 由于您不将 kth_ 函数用于任何其他用途，因此只需将其与 print_ funci 结合使用
    int n = scanf("%d %d %d %d", &type, &p, &s, &w);
    switch(type) {
        case 1:
            if(n != 2) {
              // handle error
            }
            print_paragraph(document, p);
            break;
        ...
    }

  1. （未修复）为剩余的malloc() 、 strdup()等添加错误检查。

  2. 不要硬编码魔法值 (1000)。 我介绍了常量WORD_LEN ，但您也有 MAX_CHARACTERS，这是一回事。

  3. （不固定）考虑使用char *s = strpbrk(text + i, ".\n")一次复制一个单词。 它将简化\0处理，并且可能比一次一个字节地遍历text更快，即i += s - text + i ，只需处理s == NULL特殊情况。

valgrind 现在很高兴除了泄漏（见上文）：

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_CHARACTERS 1005
#define MAX_PARAGRAPHS 5
#define WORD_LEN 1000

char *kth_word_in_mth_sentence_of_nth_paragraph(char ****document, int p, int s, int w) {
    return document[p - 1][s - 1][w - 1];
}

char **kth_sentence_in_mth_paragraph(char ****document, int p, int s) {
    return document[p - 1][s - 1];
}

char ***kth_paragraph(char ****document, int p) {
    return document[p - 1];
}

char ****get_document(char* text) {
    char ****document = malloc(sizeof ***document);
    *document = malloc(sizeof **document);
    **document = malloc(sizeof *document);
    ***document = malloc(WORD_LEN);

    /*  declare some numbers as iterators for the words, sentences,etc.*/
    int parano = 0;
    int sentno = 0;
    int wordno = 0;
    int charno = 0;
    /*  now iterate over the text filling and expanding the document at the same time*/
    /*----------------------------------------------------------------------------------------------------*/
    /*  feading data in those spaces*/
    size_t len = strlen(text);
    for (size_t i = 0; i < len; i++) {
        switch(text[i]) {
            case ' ': {
                document[parano][sentno][wordno][charno] = '\0';

                wordno++;
                char **words = realloc(
                    document[parano][sentno],
                    (wordno + 1) * sizeof *document[parano][sentno]
                );
                if(!words) {
                    printf("realloc of words failed\n");
                    exit(1);
                }
                document[parano][sentno] = words;
                document[parano][sentno][wordno] = malloc(WORD_LEN);
                charno = 0;
                break;
            }
            case '.': {
                document[parano][sentno][wordno][charno] = '\0';

                sentno++;
                char ***sentences = realloc(
                    document[parano],
                    (sentno + 1) * sizeof *document[parano]
                );
                if(!sentences) {
                    printf("realloc of sentences failed\n");
                    exit(1);
                }
                document[parano] = sentences;
                document[parano][sentno] = malloc(sizeof **document);
                wordno = 0;
                document[parano][sentno][wordno] = malloc(WORD_LEN);
                charno = 0;
                break;
            }
            case '\n': {
                document[parano][sentno][wordno][charno] = '\0';

                parano++;
                char ****paragraphs = realloc(
                    document,
                    (parano + 1) * sizeof *document
                );
                if(!paragraphs) {
                    printf("realloc of paragraphs failed\n");
                    exit(1);
                }
                document = paragraphs;
                document[parano] = malloc(sizeof ***document);
                sentno = 0;
                document[parano][sentno] = malloc(sizeof **document);
                wordno = 0;
                document[parano][sentno][wordno] = malloc(WORD_LEN);
                charno = 0;
                break;
            }
            default: // character
                document[parano][sentno][wordno][charno++] = text[i];
        }
    }
    return document;
}

char *get_input_text() {
    int paragraph_count;
    scanf("%d", &paragraph_count);
    char p[MAX_PARAGRAPHS][MAX_CHARACTERS];
    char doc[MAX_CHARACTERS];
    memset(doc, 0, sizeof doc);
    getchar();
    for (int i = 0; i < paragraph_count; i++) {
        scanf("%[^\n]%*c", p[i]);
        strcat(doc, p[i]);
        if (i != paragraph_count - 1)
            strcat(doc, "\n");
    }
    return strdup(doc);
}

void print_word(char *word) {
    printf("%s", word);
}

void print_sentence(char **sentence) {
    int word_count;
    scanf("%d", &word_count);
    for(int i = 0; i < word_count; i++){
        print_word(sentence[i]);
        if(i + 1 != word_count)
            printf(" ");
    }
}

void print_paragraph(char ***paragraph) {
    int sentence_count;
    scanf("%d", &sentence_count);
    for (int i = 0; i < sentence_count; i++) {
        print_sentence(paragraph[i]);
        printf(".");
    }
}

int main() {
    char *text = get_input_text();
    char ****document = get_document(text);
    int q;
    scanf("%d", &q);
    while (q--) {
        int type;
        scanf("%d", &type);
        switch(type) {
            case 1: {
                int p;
                scanf("%d", &p);
                print_paragraph(kth_paragraph(document, p));
                break;
            }
            case 2: {
                int p, s;
                scanf("%d %d", &p, &s);
                print_sentence(kth_sentence_in_mth_paragraph(document, p, s));
                break;
            }
            case 3: {
                int p, s, w;
                scanf("%d %d %d", &p, &s, &w);
                print_word(kth_word_in_mth_sentence_of_nth_paragraph(document, p, s, w));
                break;
            }
            default:
                printf("error\n");
        }
        printf("\n");
    }
    free(text);
}

Output 如预期：

Learning pointers is more fun.It is good to have pointers.
Learning C is fun
Learning

顺便说一句，解决这个问题的一种完全不同的方法是保留原始输入（ text ），然后编写函数直接从该字符串中提取段落、句子或单词。 如果您输入的内容很大，则创建一个索引，例如，( paragraph , sentence , word ) 到&text[i] 。

解决方案2
 0  2023-01-30 12:31:36

终于做到了。 非常感谢@allanwind 的支持

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include<assert.h>
#define MAX_CHARACTERS 1005
#define MAX_PARAGRAPHS 5

char *kth_word_in_mth_sentence_of_nth_paragraph(char ****document, int k, int m, int n) {
    return *(*(*(document + n - 1) + m - 1) + k - 1);
}

char **kth_sentence_in_mth_paragraph(char ****document, int k, int m) { 
    return (*(*(document + m - 1) + k - 1));
}

char ***kth_paragraph(char ****document, int k) {
    return *(document + k - 1);
}

char ****get_document(char *a) 
{
    int len = strlen(a);
    char ****document = malloc(sizeof(char ***) * MAX_PARAGRAPHS);
    int parano = 0;
    char ***paragraph = malloc(sizeof(char **) * MAX_CHARACTERS);
    int sentno = 0;
    char **sentence = malloc(sizeof( char *) * MAX_CHARACTERS);
    int wordno = 0;
    char *word = malloc(sizeof(char ) * MAX_CHARACTERS);
    int charno = 0;
    
    for (int i = 0; i < len; i++)
    {
        /*  after this way, try to learn switch conditionals*/
        if (a[i] == ' ')
        {
            /*  if find a space, that is there are more words within the same sentence*/
            /*  close the word*/
            word[charno] = '\0';
            /*  add the word to the sentence*/
            sentence[wordno] = word;
            wordno++;
            charno = 0;
            /*  create another word*/
            char *tmp = malloc(sizeof(char) * MAX_CHARACTERS);
            /*  if the word got space without errors,*/
            if (tmp != NULL)
            {
                word = tmp;
            }
        }
        else if (a[i] == '.')
        {
            // terminate the word
            word[charno] = '\0';
            // add word to the sentence
            sentence[wordno] = word;
            wordno = 0;
            charno = 0;
            //  add sentence to paragraph
            paragraph[sentno] = sentence; 
               
            if (i != len - 1)
            {
                sentno++;
                // allocate space for new sentence, as it is not the end
                char **tmp1 = malloc(sizeof(char *) * MAX_CHARACTERS);
                if (tmp1 != NULL)
                {
                    sentence = tmp1;
                }
                // allocate space for new word
                char *tmp2 = malloc(sizeof(char) * MAX_CHARACTERS);
                if (tmp2 != NULL)
                {
                    word = tmp2;
                }
                
            }
            else  
            {
                document[parano] = paragraph;
            }
        }
        else if (a[i] == '\n')
        {
            // add paragraph to the document
            document[parano] = paragraph;
            parano++;
            // allocate memory for another paragraph
            char ***tmp3 = malloc(sizeof(char **) * MAX_CHARACTERS);
            if (tmp3 != NULL)
            {
                paragraph = tmp3;
            }
            charno = 0;
            wordno = 0;
            sentno = 0;
        }
        else  
        {
            /*  step 1 read the text into the word char by char*/
            word[charno] = a[i];
            charno++;
        }
    }
    
    return document;
}

char* get_input_text() {    
    int paragraph_count;
    scanf("%d", &paragraph_count);

    char p[MAX_PARAGRAPHS][MAX_CHARACTERS], doc[MAX_CHARACTERS];
    memset(doc, 0, sizeof(doc));
    getchar();
    for (int i = 0; i < paragraph_count; i++) {
        scanf("%[^\n]%*c", p[i]);
        strcat(doc, p[i]);
        if (i != paragraph_count - 1)
            strcat(doc, "\n");
    }

    char* returnDoc = (char*)malloc((strlen (doc)+1) * (sizeof(char)));
    strcpy(returnDoc, doc);
    return returnDoc;
}

void print_word(char* word) {
    printf("%s", word);
}

void print_sentence(char** sentence) {
    int word_count;
    scanf("%d", &word_count);
    for(int i = 0; i < word_count; i++){
        printf("%s", sentence[i]);
        if( i != word_count - 1)
            printf(" ");
    }
} 

void print_paragraph(char*** paragraph) {
    int sentence_count;
    scanf("%d", &sentence_count);
    for (int i = 0; i < sentence_count; i++) {
        print_sentence(*(paragraph + i));
        printf(".");
    }
}

int main() 
{
    char* text = get_input_text();
    char**** document = get_document(text);

    int q;
    scanf("%d", &q);

    while (q--) {
        int type;
        scanf("%d", &type);

        if (type == 3){
            int k, m, n;
            scanf("%d %d %d", &k, &m, &n);
            char* word = kth_word_in_mth_sentence_of_nth_paragraph(document, k, m, n);
            print_word(word);
        }

        else if (type == 2){
            int k, m;
            scanf("%d %d", &k, &m);
            char** sentence = kth_sentence_in_mth_paragraph(document, k, m);
            print_sentence(sentence);
        }

        else{
            int k;
            scanf("%d", &k);
            char*** paragraph = kth_paragraph(document, k);
            print_paragraph(paragraph);
        }
        printf("\n");
    }     
}

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 当您不想传递任何变量时，是否可以在C变量长度自变量函数中使用带格的情况？ 两个不同的结果值，研究了好几天还是看不懂 你能解决我的问题并简化我所做的解决方案吗？ C-我不想分配我不会使用的内存！ （新问题） C Scope 问题（按值调用）：为什么我不必在此合并排序实现中全局声明？ 为什么我不能返回 realloc 的结果？ （当你看到代码时你会得到问题......） C Pthreads问题，无法传递我想要的信息？ 嗨，我有一个C编程问题。 我想知道两者之间的区别，其中哪一项比其他有用？ fprintf不断添加我不想要的额外字符。 我不能阻止这个吗？ 如果我不想将 function 作为参数传递，我该如何使用这个宏？
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM