C++ Contador de ocorrência de palavras em arquivo txt.

[Dalmarg]

Eu estou tentando fazer um programa em C que leia um arquivo-texto e grave em outro arquivo uma estatística de palavras. Cada palavra lida, deverá ser inserida em uma lista, sem repetição. Cada nó dessa estrutura deve ter um contador de ocorrência. No arquivo de saída a sequência de palavras deverá em ordem decrescente de ocorrências. Fiz um programa base que deveria ler e inserir na lista, porém não esta funcionando. Queria ajuda por favor.

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

//Declaração da estrutura usada no programa.
typedef struct palavras{
	char palavra[100];
	int quantidade;
	struct palavras *prox;
}palavras;

int main(){
	//Variaveis
	palavras *primeiro=NULL, *aux=NULL, *percorre=NULL;
	char string[100], ch[0];
	int total=0;
	//Abrindo o arquivo
	FILE* arquivo = fopen("teste.txt", "r");
	if(arquivo == NULL) {
		fprintf(stderr, "Erro ao abrir o arquivo.txt.");
		return 1;
	}
	//Lendo a primeira palavra do arquivo
	while(1){
		strcat(string,ch);
		ch[0]= fgetc(arquivo);
		if(ch[0]==' '||ch[0]=='\n'||ch[0]=='\t')
			break;
	}
	printf("%s",string);
	//Guardando a primeira palavra em um nó de uma lista encadeada.
	primeiro= (palavras*)malloc(sizeof(palavras));
	strcpy(primeiro->palavra,string);
	primeiro->quantidade=0;
	primeiro->prox=NULL;
	//
	while(!feof(arquivo)){
		if((ch[0]==' ')||(ch[0]=='\n')||(ch[0]=='\t')){
			for(percorre=primeiro; percorre!=NULL; percorre=percorre->prox){
				if(strcmp(string,percorre->palavra)==0){
					percorre->quantidade++;
					strcpy(string,"");
					break;
				}
				if(percorre->prox==NULL && strcmp(string,"")!=0){
					aux= primeiro;
					primeiro= (palavras*)malloc(sizeof(palavras));
					primeiro->quantidade= 1;
					strcpy(primeiro->palavra, string);
					primeiro->prox= aux;
					strcpy(string,"");
				}
			}
		}else{
			strcat(string,ch);
		}
		ch[0]= getc(arquivo);
	}
	//
	for (percorre=primeiro; percorre!=NULL; percorre= percorre->prox){
		total= total + percorre->quantidade;
		printf("%s - %d\n", percorre->palavra, percorre->quantidade);
	}
	//
	printf("\nO texto cont%cm %d palavras.\n", 130,total);
	fclose(arquivo); 
}

 

[kgin]

@Dalmarg Isso está muito complicado, você deveria simplificar um pouco na hora de retirar as palavras.

Recomendo você tentar dessa maneira.

/*
 * Trabalhando com arquivos em C.
 *  09/15/2022 ás 08:24p.m
 */

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

#define NOME_ARQUIVO "teste.txt"
#define TAMANHO_BUFFER 512

int main(int argc, char *argv[])
{
    char buffer[TAMANHO_BUFFER] = {'\0'};
    FILE *arquivo = fopen(NOME_ARQUIVO, "r+");
    if (arquivo == NULL) {
        perror("não foi possível abrir o arquivo! ");
        exit(EXIT_FAILURE);
    }
    do {
        char *palavra = NULL;
        /* Pega uma linha do arquivo */
        fgets(buffer, TAMANHO_BUFFER, arquivo);
        /* Separa em palavras */
        palavra = strtok(buffer, " ;,._");
        while (palavra != NULL) {
            printf("%s\n", palavra);    /* Mostra as palavras */
            palavra = strtok(0, " ;,._");   /* Pega a proxíma palavra */
        }
    } while (!feof(arquivo) && !ferror(arquivo));
    fclose(arquivo);
    return(0);
}

Versão online!

[Dalmarg]

@kgin Então, eu entendi seu programa, mas não consegui implementa-lo na ideia. Pois seu programa apenas separa as palavras.

Minha intenção é ler as palavras já registrando na lista e contar a ocorrência de repetições da mesma.

[arfneto]

você pode conseguir terminar e mesmo escrever outros programas desse modo mas

• vai ter um trabalho do inferno
• pouco ou nada vai levar de um programa para outro
• está tudo misturado e fica muito difícil de testar

Contador de ocorrência de palavras em arquivo txt

 

Esse é o objetivo. Em C. Sua ideia: uma lista ligada de palavras onde ao final da leitura do texto vai estar o resultado, que vai gravado em outro arquivo. E esá ok. Um único passo no arquivo, um único passo na lista resultande, return 0 e a vida segue.

 

Onde está  a lista ligada? Onde está o consumo do arquivo? onde está  a criação do outro? Como testar as partes se tudo está junto?

 

E os dados? Escreva em torno dos dados. É o simples.

 

typedef struct palavras{
	char palavra[100];
	int quantidade;
	struct palavras *prox;
}palavras;

 

Essa é a única estrutura de seu programa. Onde está a lista? os nós? Onde insere? Onde navega?

 

Como não tem nada mais o programa já começa com

 

	palavras *primeiro=NULL, *aux=NULL, *percorre=NULL;

 

alocando 3 ponteiros para a mesma lista. Como controlar uma coisa dessas? Os 3 são globais em main, que é o programa TODO.

 

Sugiro separar a lista. É seu primeiro programa de listas? Vai gostar de poder usar de novo. Não é o primeiro? Porque não começou pelo último programa de listas que escreveu? Seria bem mais simples.

 

Como consumir um arquivo? Como ler os parâmetros? É um programa de console então é claro que a gente espera poder fazer o simples:
 

	programa "entrada.tx" "saida.txt"

 

E o programa lê o primeiro arquivo e cria o segundo com as palavras e os contadores.

 

E é claro que enquanto está em teste vai mostrar essa saída na tela também porque não se pode imaginar ter que abrir um arquivo toda vez que o programa roda pra ver se os valores estão ok.

 

Sugiro considerar.

 

 

[kgin]

@Dalmarg Sugiro você seguir as dicas do @arfneto e quebrar o algoritmo em partes.

tente fazer primeiro a lista ligada e depois tentar implementar a leitura do arquivo.

recomendo dar uma olhada no livro C completo e total no capitulo 20 pagina 550.

3 horas atrás, Dalmarg disse:

@kgin Então, eu entendi seu programa, mas não consegui implementa-lo na ideia. Pois seu programa apenas separa as palavras.

Minha intenção é ler as palavras já registrando na lista e contar a ocorrência de repetições da mesma.

Eu acho que com esse exemplo vai ficar mais claro

/*
 * Trabalhando com arquivos em C.
 *  09/15/2022 ás 08:24p.m
 *  Atualizado 09/16/2022 12:42p.m
 */

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

#define NOME_ARQUIVO "teste.txt"
#define TAMANHO_BUFFER 512

#define TAMANHO_PALAVRA 60
#define TAMANHO_LISTA 200

struct lista
{
    char palavra[TAMANHO_PALAVRA];
    int ocorrencias;
};

void
caixa_alta(char *str)
{
    if (str != NULL) {
        int contador;
        for (contador = 0; contador < strlen(str); contador++) {
            str[contador] = toupper(str[contador]);
        }
    }
}

int main(int argc, char *argv[])
{
    struct lista lista_palavras[TAMANHO_LISTA] = {0};
    int quantidade_palavras = 0;
    int contador;
    char buffer[TAMANHO_BUFFER] = {'\0'};
    FILE *arquivo = fopen(NOME_ARQUIVO, "r+");
    if (arquivo == NULL) {
        perror("não foi possível abrir o arquivo! ");
        exit(EXIT_FAILURE);
    }
    do {
        char *palavra = NULL;
        /* Pega uma linha do arquivo */
        fgets(buffer, TAMANHO_BUFFER, arquivo);
        /* Separa em palavras */
        palavra = strtok(buffer, " ;,._\n");
        while (palavra != NULL) {
            /* 
             * Critérios para se considerada uma palavra
             *  -Ser pelo menos monossilábica
             *  -Não pode conter espaços ou números no inicio
             */
            if (isalpha(*palavra) && strlen(palavra) > 1) {
                int palavra_encontrada = 0;
                int posicao_palavra = 0;
                for (contador = 0; contador < quantidade_palavras && contador < TAMANHO_LISTA; contador++) {
                    /* Salva as palavras temporariamente */
                    char tmp_palavra1[100] = {'\0'};
                    char tmp_palavra2[100] = {'\0'};
                    strcpy(tmp_palavra1, palavra);
                    strcpy(tmp_palavra2, lista_palavras[contador].palavra);
                    /* Passa as palavras para maiúsculas */
                    caixa_alta(tmp_palavra1);
                    caixa_alta(tmp_palavra2);
                    if (strcmp(tmp_palavra1, tmp_palavra2) == 0) {
                        palavra_encontrada = 1;
                        posicao_palavra = contador;
                        break;
                    }
                }
                
                if (palavra_encontrada) {
                    lista_palavras[posicao_palavra].ocorrencias++;
                } else {
                    strcpy(lista_palavras[quantidade_palavras].palavra, palavra);
                    lista_palavras[quantidade_palavras].ocorrencias++;
                    quantidade_palavras++;
                }
            }
            palavra = strtok(0, " ;,._\n");   /* Pega a próxima palavra */
        }
    } while (!feof(arquivo) && !ferror(arquivo));
    fclose(arquivo);
    printf("Quantidade de palavras encontradas no texto:%i\n", quantidade_palavras);
    printf("\tQuantidade de ocorrencias de cada palavra\n");
    for (contador = 0; contador < quantidade_palavras; contador++) {
        printf("%s %i ", lista_palavras[contador].palavra, lista_palavras[contador].ocorrencias);
        if (lista_palavras[contador].ocorrencias > 1) {
            printf("vezes");
        } else {
            printf("vez");
        }
        putchar('\n');
    }
    printf("Pressione enter para encerrar o programa...\n");
    fgets(buffer, TAMANHO_BUFFER, stdin);
    return(0);
}

É apenas um exemplo, eu implementei usando um vetor.

Versão online!