Zeichenkette aus Datei ohne Interpunktion für Rechtschreibprüfung Ausgabe mit Originalzeichen.

Question

Hallo Ich mache eine Rechtschreibprüfung in c, die ein Wörterbuch in einem Array von Zeichenfolgen hat und Binärsuche verwendet, um Wörter im Wörterbuch zu finden.

Mein Problem ist, dass ich versuche, Text aus einer Datei zu lesen und den Text in eine neue Datei mit falschen Worten wie folgt zurückzusenden: ** Rechtschreibfehler **, aber die Datei enthält Zeichen wie.,!? Diese sollte in der neuen Datei ausgegeben werden, aber offensichtlich nicht vorhanden sein, wenn das Wort mit dem Wörterbuch verglichen wird.

so möchte ich dies:

text file: "worng!" 

new file: "** worng **!" 

Ich habe diese die besten zu lösen versucht, ich kann und habe schon eine ganze Weile auf Google verbracht, aber ich nicht näher an einer Lösung zu bekommen. Ich habe bisher den folgenden Code geschrieben, um jedes Zeichen zu lesen und zwei char-Arrays zu füllen, eine Kleinschreibung für den Wörterbuchvergleich und eine Eingabe für das Originalwort, die funktioniert, wenn es keine Interpunktion gibt, aber offensichtlich verliere ich den Raum auf diese Weise, wenn Interpunktion vorliegt Ich bin mir sicher, dass es einen besseren Weg gibt, dies zu tun, aber ich kann es einfach nicht finden, so dass irgendwelche Hinweise geschätzt würden.

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

#define MAX_STRING_SIZE 29 /*define longest non-technical word in english dictionary plus 1*/ 

/*function prototypes*/ 
int dictWordCount(FILE *ptrF); /*counts and returns number of words in dictionary*/ 
void loadDictionary(char ***pArray1, FILE *ptrFile, int counter); /*create dictionary array from file based on word count*/ 
void printDictionary(char **pArray2, int size); /*prints the words in the dictionary*/ 
int binarySearch(char **pArray3, int low, int high, char *value); /*recursive binary search on char array*/ 

void main(int argc, char *argv[]){ 
    int i; /*index*/ 
    FILE *pFile; /*pointer to dictionary file*/ 
    FILE *pInFile; /*pointer to text input file*/ 
    FILE *pOutFile; /*pointer to text output file*/ 
    char **dict; /*pointer to array of char pointer - dictionary*/ 
    int count;  /*number of words in dictionary*/ 
    int dictElement; /*element the word has been found at returns -1 if word not found*/ 

    char input[MAX_STRING_SIZE]; /*input to find in dictionary*/ 
    char temp[MAX_STRING_SIZE]; 
    char ch; /*store each char as read - checking for punctuation or space*/ 
    int numChar = 0; /*number of char in input string*/ 

    /*************************************************************************************************/ 
    /*open dictionary file*/ 
    pFile = fopen("dictionary.txt", "r"); /*open file dictionary.txt for reading*/ 
    if(pFile==NULL){ /*if file can't be opened*/ 
     printf("ERROR: File could not be opened!/n"); 
     exit(EXIT_FAILURE); 
    } 

    count = dictWordCount(pFile); 
    printf("Number of words is: %d\n", count); 

    /*Load Dictionary into array*/ 
    loadDictionary(&dict, pFile, count); 

    /*print dictionary*/ 
    //printDictionary(dict, count); 
    /*************************************************************************************************/ 
    /*open input file for reading*/ 
    pInFile = fopen(argv[1], "r"); 
    if(pInFile==NULL){ /*if file can't be opened*/ 
     printf("ERROR: File %s could not be opened!/n", argv[1]); 
     exit(EXIT_FAILURE); 
    } 
    /*open output file for writing*/ 
    pOutFile = fopen(argv[2], "w"); 
    if(pOutFile==NULL){ /*if file can't be opened*/ 
     printf("ERROR: File could not be created!/n"); 
     exit(EXIT_FAILURE); 
    } 

    do{ 
     ch = fgetc(pInFile);    /*read char fom file*/ 

     if(isalpha((unsigned char)ch)){  /*if char is alphabetical char*/ 
      //printf("char is: %c\n", ch); 
      input[numChar] = ch;   /*put char into input array*/ 
      temp[numChar] = tolower(ch); /*put char in temp in lowercase for dictionary check*/ 
      numChar++;      /*increment char array element counter*/ 
     } 
     else{ 
      if(numChar != 0){ 
       input[numChar] = '\0'; /*add end of string char*/ 
       temp[numChar] = '\0'; 

       dictElement = binarySearch(dict,0,count-1,temp); /*check if word is in dictionary*/ 

       if(dictElement == -1){ /*word not in dictionary*/ 
        fprintf(pOutFile,"**%s**%c", input, ch); 
       } 
       else{ /*word is in dictionary*/ 
        fprintf(pOutFile, "%s%c", input, ch); 
       } 
       numChar = 0; /*reset numChar for next word*/ 
      } 
     } 
    }while(ch != EOF); 

    /*******************************************************************************************/ 
    /*free allocated memory*/ 
    for(i=0;i<count;i++){ 
     free(dict[i]); 
    } 
    free(dict); 

    /*close files*/ 
    fclose(pInFile); 
    fclose(pOutFile); 

} 

Answer 1

Ich bin mir nicht 100% sicher, dass ich dein Problem richtig verstanden habe, aber ich werde es versuchen.

Zuerst Ihre Schleife

do{ 
    ch = fgetc(pInFile); 
    /* do stuff */ 
}while(ch != EOF); 

auch ausgeführt wird, wenn das Ende der Datei erreicht ist, so dass, wenn das letzte Byte der Datei alphabetisch ist, werden Sie entweder einen unerwünschten EOF Byte in die Ausgabedatei drucken, oder, da Sie ch in eine unsigned char umwandeln, wenn Sie es an isalpha() übergeben, was normalerweise 255 [für EOF = -1 und 8 Bit unsigned char] ergibt, wird es in einigen Gebietsschemas (en_US.iso885915, zum Beispiel) als ein alphabetisches Zeichen betrachtet unterdrückt das letzte Wort der Eingabedatei.

damit zu umgehen, erstens, nicht ch nicht werfen, wenn es um isalpha(), vorbei und zweitens eine gewisse Logik in die Schleife hinzufügen, um unbeabsichtigte Handhabung von EOF zu verhindern. Ich entschied mich dafür, es durch eine neue Zeile zu ersetzen, wenn die Notwendigkeit entsteht, da das einfach ist.

Dann bleibt es die nicht-alphabetische Zeichen zu drucken, die nicht sofort alphabetische Zeichen folgen:

do{ 
    ch = fgetc(pInFile);    /*read char fom file*/ 

    if(isalpha(ch)){     /*if char is alphabetical char*/ 
     //printf("char is: %c\n", ch); 
     input[numChar] = ch;   /*put char into input array*/ 
     temp[numChar] = tolower(ch); /*put char in temp in lowercase for dictionary check*/ 
     numChar++;      /*increment char array element counter*/ 
    } 
    else{ 
     if(numChar != 0){ 
      input[numChar] = '\0'; /*add end of string char*/ 
      temp[numChar] = '\0'; 

      dictElement = binarySearch(dict,0,count-1,temp); /*check if word is in dictionary*/ 

      if(dictElement == -1){ /*word not in dictionary*/ 
       fprintf(pOutFile,"**%s**%c", input, (ch == EOF) ? '\n' : ch); 
      } 
      else{ /*word is in dictionary*/ 
       fprintf(pOutFile, "%s%c", input, (ch == EOF) ? '\n' : ch); 
      } 
      numChar = 0; /*reset numChar for next word*/ 
     } 
     else 
     { 
      if (ch != EOF) { 
       fprintf(pOutFile, "%c",ch); 
      } 
     } 
    } 
}while(ch != EOF); 

Answer 2

Es sieht aus wie jetzt, wenn die Zeichen den else Block für if(isalpha((unsigned char)ch)){ und das Zeichen selbst wird nicht ignoriert werden alphabetisch auslöst.

Wenn Sie eine Anweisung hinzufügen, um alle nicht-alphabetischen Zeichen genau so auszugeben, wie sie kommen, denke ich, dass das erreichen wird, was Sie wollen. Dies müsste in den else Block und nach dem if(numChar != 0){ Block gehen und wäre nur eine einfache fprintf Anweisung.