We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. C
  3. Functions
  4. Querying the Document
  5. Discussions

Querying the Document

Sort by

recency

|

160 Discussions

|

  • yashdeora98294
     + 0 comments

    Here is Querying the Document solution in C - https://programmingoneonone.com/hackerrank-querying-the-document-solution-in-c.html

  • sandeepsiva18
     + 0 comments
    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) {
    int i=0,j=0,k=0,n_para = 0, n_sent[MAX_PARAGRAPHS] = {0}, n_word[MAX_PARAGRAPHS][MAX_CHARACTERS] = {{0}};
    char ****doc = NULL;
    text[strlen(text)] = '\n';
    text[strlen(text)] = '\0';
    //printf("%s\n", text);
    while(text[i] != '\0') {
        if(text[i] == ' ') {
            n_word[n_para][n_sent[n_para]]++;
            i++;
            continue;
        }
        else if(text[i] == '.') {
            n_word[n_para][n_sent[n_para]]++;
            n_sent[n_para]++;
            i++;
            continue;
        }
        else if(text[i] == '\n') {
            n_para++;
            i++;
        } else {
            i++;
        }
    }
    doc = (char ****)calloc(n_para, sizeof(char ***));
    char *str = text;
    char *reserve = NULL;
    for(i = 0; i < n_para; i++) {
        *(doc+i) = (char ***) calloc(n_sent[i], sizeof(char **));
        //printf("n_sent[%d] = %d\n", i, n_sent[i]);
        for(j = 0; j < n_sent[i]; j++) {
            *(*(doc+i)+j) = (char **) calloc(n_word[i][j], sizeof(char *));
            //printf("n_word[%d][%d] = %d\n", i, j, n_word[i][j]);
            for(k = 0; k < n_word[i][j]; k++) {
                *(*(*(doc+i)+j)+k) = (char *)calloc(100, sizeof(char));
                doc[i][j][k] = strtok_r(str, " .\n", &reserve);
                if(i == 0 && j == 0 && k == 0)
                    str = NULL;
            }
        }
    }
    return doc;
}

  • yusufzahitmert
     + 0 comments
    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) {
    char**** document = (char****)malloc(sizeof(char***)*5);
    for (int i = 0; i < 5; i++){
        document[i] = (char***)malloc(sizeof(char**)*10);
        for (int j = 0; j < 10; j++){
            document[i][j] = (char**)malloc(sizeof(char*)*50);
            for(int k = 0; k < 50; k++){
                document[i][j][k] = (char*)malloc(sizeof(char)*100);
            }
        }
    } 
    char ch = ' ';
    int par = 0, sen = 0, wor = 0, let = 0;
    for (int i = 0; i < strlen(text); i++){
        ch = text[i];
        if (ch == ' '){
            wor++;
            let = 0;
        } else if (ch == '.'){
            sen++;
            wor = 0;
            let = 0;
        } else if (ch == '\n'){
            par++;
            sen = 0;
            wor = 0;
            let = 0;
        } else{
            document[par][sen][wor][let] = ch;
            let++;
        }
    }
    return document;
}

  • coobnoob
     + 0 comments

    This test measures nothing other than the candidate's tolerance for torture.

    There would only be two realistic approaches to this problem in real life.

    1) Rewrite the entire thing, and if not allowed to do that: 2) Quit the job.

  • mcsilvio
     + 0 comments
    #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];
}

void resetTempWord(char * tmpWord, int * tmpWordIndex) {
    tmpWord[0] = '\0';
    *tmpWordIndex = 0;
}

char**** get_document(char* text) {
    char **** document;

    int wordIndex = -1;
    int sentenceIndex = -1;
    int paragraphIndex = -1;
    
    int wordOpen = 0;
    int sentenceOpen = 0;
    int paragraphOpen = 0;
    
     //when to make a new slot
     // - upon observation of new requirement for a slot (letter)
     //when to reset the tempword
     // - when the last word was wrapped up
     //when to wrap up the current word, sentend and paragraph
     // - when their delimiters are observed
            
    char tempWord[1000000];
    int tempWordIndex = 0;
    tempWord[0] = '\0';
    int length = strlen(text);
    for (int i = 0; i < length; i++) {
        char chr = text[i];
        if (chr == '\0') { 
            //i think we just need to wrap up the paragraph
            paragraphOpen = 0;
            break;
        } else if (chr == ' ') {
            tempWord[tempWordIndex] = '\0';
            char * newWord = malloc(tempWordIndex);
            strcpy(newWord, tempWord);
            document[paragraphIndex][sentenceIndex][wordIndex] = newWord;
            resetTempWord(tempWord, &tempWordIndex);
            wordOpen = 0;
        } else if (chr == '.') {
            tempWord[tempWordIndex] = '\0';
            char * newWord = malloc(tempWordIndex);
            strcpy(newWord, tempWord);
            document[paragraphIndex][sentenceIndex][wordIndex] = newWord;
            resetTempWord(tempWord, &tempWordIndex);
            wordOpen = 0;
            
            sentenceOpen = 0;
        } else if (chr == '\n') {
            paragraphOpen = 0;
        } else {
            if (!paragraphOpen) {
                paragraphIndex++;
                sentenceIndex = wordIndex = -1;
                if (!document) {
                    document = calloc(1, sizeof(char ***));
                } else {
                    document = realloc(document, (paragraphIndex + 1) * sizeof(char ***));
                }
                paragraphOpen = 1;
            }
            //if we need a sentence mem, make it now
            if (!sentenceOpen) {
                sentenceIndex++;
                wordIndex = -1;
                if (!document[paragraphIndex]) {
                    document[paragraphIndex] = calloc(1, sizeof(char **));
                } else {
                    document[paragraphIndex] = realloc(document[paragraphIndex], (sentenceIndex + 1) * sizeof(char **));
                }
                sentenceOpen = 1;
            }
            //if we need a word mem, make it now
            if (!wordOpen) {
                wordIndex++;
                if (!document[paragraphIndex][sentenceIndex]) {
                    document[paragraphIndex][sentenceIndex] = calloc(1, sizeof(char *));
                } else {
                    document[paragraphIndex][sentenceIndex] = realloc(document[paragraphIndex][sentenceIndex], (wordIndex + 1) * sizeof(char *));
                }
                wordOpen = 1;
            }
            
            //add letter to word
            tempWord[tempWordIndex++] = chr;
        }
    }
    
    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");
    }     
}