Totale caratteri nel file

[kwb]

Ciao, avevo tempo fa questo programma da fare: dato un file con del testo dentro, stampare a schermo quante volte compare ogni lettera. Per i caratteri speciali e punteggiatura, usare un'unico contatore. Le lettere maiuscole e minuscole sono contate separatamente.

La soluzione proposta dal professore era quella di fare 2 array, i primi due da 26 caratteri per i contatori di tutte le lettere dell'alfabeto, una variabile per contenere gli 'altri caratteri' e un grande array bello lungo per contenere la stringa in input ( dal file ).
Ovviamente char_low[0] corrisponde ad a, char_low[3] corrisponde a d ecc...

Avevo già svolto questo esercizio facendo uno switch sulla stringa in input, analizzando ogni singola parola e incrementando di uno la posizione dell'array corrispondente al carattere.

Come si capisce, facendo lo switch, viene un lavoro lunghissimo per una banalità di programma.

Ho pensato a come farlo in altro modo, ma non ho niente in mente... Mi pare impossibile ci sia solo questa dispendiosa soluzione ( che tra l'altro non so quanto sia leggera a livello di codice... ).

Questo era quello che avevo scritto:

/*Write a C program that reads a text from a file and prints how many times each character has
occurred in the text read. Upper and lower case letters should be counted separately. Use a
single counter to compute the number of occurrences of all the characters other than letters and
digits. Hint: use an array of counters for lowercase characters, where index 0 stands for ëaí,
index 1 for ëbí and so on. A similar array can be used for uppercase characters.*/


#include <stdio.h>
#include <stdlib.h>
#define MAX 200

int main()
{
int c_low [25];
int c_up [25];
int i;
int c_ot=0;
FILE *fp;
int d;
char txt[MAX];

for (i=0;i<25;i++)
{
c_low[i]=0;
c_up[i]=0;
}

if((fp=fopen("troppo_gaggi.txt","r"))==NULL)
printf("error\n");
else
{
while((fgets(txt, MAX-1, fp)!=NULL))
{
for(i=0;txt[i]!=NULL;i++)
switch(txt[i])
{
case 'a':
c_low[0]++;
break;
case'b':
c_low[1]++;
break;
case'c':
c_low[2]++;
break;
case'd':
c_low[3]++;
break;
case'e':
c_low[4]++;
break;
case'f':
c_low[5]++;
break;
case'g':
c_low[6]++;
break;
case'h':
c_low[7]++;
break;
case'i':
c_low[8]++;
break;
case'j':
c_low[9]++;
break;
case'k':
c_low[10]++;
break;
case'l':
c_low[11]++;
break;
case'm':
c_low[12]++;
break;
case'n':
c_low[13]++;
break;
case'o':
c_low[14]++;
break;
case'p':
c_low[15]++;
break;
case'q':
c_low[16]++;
break;
case'r':
c_low[17]++;
break;
case's':
c_low[18]++;
break;
case't':
c_low[19]++;
break;
case'u':
c_low[20]++;
break;
case'v':
c_low[21]++;
break;
case'w':
c_low[22]++;
break;
case'x':
c_low[23]++;
break;
case'y':
c_low[24]++;
break;
case'z':
c_low[25]++;
break;
case'A':
c_up[0]++;
break;
case'B':
c_up[1]++;
break;
case'C':
c_up[2]++;
break;
case'D':
c_up[3]++;
break;
case'E':
c_up[4]++;
break;
case'F':
c_up[5]++;
break;
case'G':
c_up[6]++;
break;
case'H':
c_up[7]++;
break;
case'I':
c_up[8]++;
break;
case'J':
c_up[9]++;
break;
case'K':
c_up[10]++;
break;
case'L':
c_up[11]++;
break;
case'M':
c_up[12]++;
break;
case'N':
c_up[13]++;
break;
case'O':
c_up[14]++;
break;
case'P':
c_up[15]++;
break;
case'Q':
c_up[16]++;
break;
case'R':
c_up[17]++;
break;
case'S':
c_up[18]++;
break;
case'T':
c_up[19]++;
break;
case'U':
c_up[20]++;
break;
case'V':
c_up[21]++;
break;
case'W':
c_up[22]++;
break;
case'X':
c_up[23]++;
break;
case'Y':
c_up[24]++;
break;
case'Z':
c_up[25]++;
break;
default:
c_ot++;
break;
}

}
}
fclose(fp);

for (i = 0; i <25; i++)
{
printf("c_low[%d] = %d\n", i, c_low[i]);
printf("c_up[%d] = %d\n", i, c_up[i]);

}
printf("Other characters: %d\n", c_ot);

return 0;
}


Vorrei rifarlo senza perdere troppo tempo visto che mi manca. Essenzialmente ho capito come funziona, ero curioso di capire se si poteva fare in altro modo, più corto.
Ho provato a guardare anche nella libreria ctype.h ma non c'è niente che faccia al caso mio...

EDIT: Ho visto che su alcuni libri di programmazione utilizzano, per la risoluzione di questo esercizio, gli argomenti nel main argv[] e robe simili che non ho la più pallida idea a cosa servano xD

[shinya]

Ho provato a guardare anche nella libreria ctype.h ma non c'è niente che faccia al caso mio...
Guarda meglio.
Tipo isalpha, islower, isupper... e una tabella con i codici ascii...

[kwb]

Guarda meglio.
Tipo isalpha, islower, isupper... e una tabella con i codici ascii...

Ok ma da quel che ne so, isalpha è in grado di riconoscere solo se si tratta di un carattere alfabetico, non quale... Almeno sui miei libri non c'è scritto che si possa identificare anche il carattere...

[shinya]

Ok ma da quel che ne so, isalpha è in grado di riconoscere solo se si tratta di un carattere alfabetico, non quale... Almeno sui miei libri non c'è scritto che si possa identificare anche il carattere...

Infatti 'isalpha' era solo una parte della risposta che ti ho dato.
Sarò più esplicito: in realtà non ti serve niente da ctype.h, puoi ricavarti le funzioni che ti servono facilmente.
Guarda una tabella ascii e cerca di capire cosa lega la lettera 'A' all'indice 0 dell'array, la lettera 'B' a 1, ecc... non c'è bisogno di uno switch.

[oNaSsIs]

Piccolo suggerimento, prova a fare un casting (si proprio il casting di cui abbiamo parlato in un altro topic...) di un char contenente la lettera 'a' in una variabile intera e vedi cosa ci finisce...magari fallo con una tabella ASCII vicino..;)

[kwb]

Si, conosco la tabella ASCII... Immagino che convertendo in qualche modo l'intera stringa ( per singoli caratteri ) in interi io ottenga i corrispettivi ASCII.
E magari ( la butto li ) succede anche il contrario se ho un intero e lo converto in char...
Una soluzione così alla svelta che mi viene è convertire tutta la stringa in interi ( così forse ottengo gli ascii ), fatto questo faccio in modo che lo 0 dell'array per le maiuscole, corrisponda al 65 ( A maiuscola ), in sostanza si tratta di avere una sorta di indice fittizio. Poi quando stampo, stampo l'indice dell'array, convertito in ascii e sommato a 65.
Se le premesse sono fattibili, mi pare una valida soluzione. Intanto devo capire come fare a fargli capire che quando incontra uno \65 si tratta di A e che la deve incrementare l'indice 0 di uno.

[shinya]

Intanto devo capire come fare a fargli capire che quando incontra uno \65 si tratta di A e che la deve incrementare l'indice 0 di uno.
Protip: lo sa già!
Prova questo pezzo di codice:

#include <stdio.h>

main() {
int c;
c = getchar();
printf("%d\n", c);
printf("%c\n", c);
}

Inserisci 'A' e ... MIND. BLOWN. :D

[kwb]

Protip: lo sa già!
Prova questo pezzo di codice:

#include <stdio.h>

main() {
int c;
c = getchar();
printf("%d\n", c);
printf("%c\n", c);
}

Inserisci 'A' e ... MIND. BLOWN. :D
Meglio di quanto pensassi, non c'è nemmeno bisogno del casting :D

EDIT: Sono su mac... Ho provato a creare sto file, l'ho salvato prima come rtf e poi come txt. L'apertura del file è corretta, però caricando i singoli caratteri dentro una variabile vengono fuori delle cose che nel file di testo non ci sono... Credo sia un problema del Text Edit... Mi sta a caricare graffe, backslash e caratteri che non ci sono...

Questo è ciò che ho scritto:

/*
Write a C program that reads a text from a file and prints how many times each character has occurred in the text read.
Upper and lower case letters should be counted separately.
Use a single counter to compute the number of occurrences of all the characters other than letters and digits.
Hint: use an array of counters for lowercase characters, where index 0 stands for ‘a’, index 1 for ‘b’ and so on.
A similar array can be used for uppercase characters.
*/

#include <stdio.h>
#include <ctype.h>
#define CHARS 25

void clear ( int array[] );

int main (void)
{

FILE *fp;
int char_low[CHARS], char_up[CHARS], i=0, c;

clear(char_low);
clear(char_up);

if ((fp=fopen("prova.rtf", "r"))== NULL)
{
printf("Error in opening the file, QUIT\n");
return -1;
}
else
{
while((c=getc(fp))!= EOF)
{
if ( islower(c) )
char_low[c-65]++;
}
}

if ((fclose(fp)== EOF))
{
printf("Error in closing the file, QUIT\n");
return -1;
}
return 0;
}

void clear ( int array[] )
{
int i;
for ( i=0; i < CHARS; i++)
array[i] = 0;
}


Ovviamente l'incremento del vettore è errato, lo so, è un problema che risolvo dopo... Finchè non riesco a leggere correttamente i dati è inutile...

[kwb]

Si ho risolto, era un problema di TextEdit che impostava una formattazione... Non ho visto che c'era l'opzione apposita per dirgli di farmi solo testo.
Ecco il codice completo cmq:

/*
Write a C program that reads a text from a file and prints how many times each character has occurred in the text read.
Upper and lower case letters should be counted separately.
Use a single counter to compute the number of occurrences of all the characters other than letters and digits.
Hint: use an array of counters for lowercase characters, where index 0 stands for ‘a’, index 1 for ‘b’ and so on.
A similar array can be used for uppercase characters.
*/

#include <stdio.h>
#include <ctype.h>
#define CHARS 25
#define CODEU 65 //Starting upper letter
#define CODEL 97 //Starting lower letter
void clear ( int array[] );
void print_result ( int array[], int code );
int main (void)
{

FILE *fp;
int char_low[CHARS], char_up[CHARS], c, other_chars=0;

clear(char_low);
clear(char_up);

if ((fp=fopen("prova.txt", "r"))== NULL)
{
printf("Error in opening the file, QUIT\n");
return -1;
}
else
{
while((c=getc(fp))!= EOF)
{
if ( islower(c) )
char_low[c-CODEL]++; //CODEL = 97 is 'a' in ASCII Code
else if ( isupper(c) )
char_up[c-CODEU]++; //CODEU = 65 is 'A' in ASCII Code
else
other_chars++;
}
print_result( char_up, CODEU );
printf("\n\n");
print_result( char_low, CODEL );
printf("\n\nOther chars: %d", other_chars);
}

if ((fclose(fp)== EOF))
{
printf("Error in closing the file, QUIT\n");
return -1;
}
return 0;
}

void clear ( int array[] )
{
int i;
for ( i=0; i < CHARS; i++)
array[i] = 0;
}

void print_result ( int array[], int code )
{
int i;

for (i =0; i < CHARS; i++)
printf("Char %c has been found %d times\n", i+code, array[i]);
}

Una curiosità: come faccio ad assegnare il nome del file tramite input?
Ho provato una cosa del genere:

void main ()
{
char filename[30];
FILE *fp;

//azzero l'array

printf("Filename: ");
scanf("%s" filename);

fp= fopen(filename, "r");

Non va, ritorna sempre NULL

[shinya]

Alcune cose:
1) Le lettere dell'alfabeto sono 26, non 25.
2) Non hai bisogno di definire delle costanti per i codici ascii. Puoi scrivere anche c - 'A' per indicizzare l'array.

[kwb]

Alcune cose:
1) Le lettere dell'alfabeto sono 26, non 25.
2) Non hai bisogno di definire delle costanti per i codici ascii. Puoi scrivere anche c - 'A' per indicizzare l'array.

Lo so che sono ventisei, ma il contatore parte da 0 :D
Non è un codice ascii, era semplicemente un numero che intanto non devo mai cambiare e mi pareva giusto metterlo come costante...

Per il problema sopra descritto?

[VICIUS]

Lo so che sono ventisei, ma il contatore parte da 0 :D
Non è un codice ascii, era semplicemente un numero che intanto non devo mai cambiare e mi pareva giusto metterlo come costante...

Per il problema sopra descritto?

int char_low[CHARS];
Questo però ti crea un array di soli 25 elementi.

[shinya]

Per il problema sopra descritto?
Umh... a parte l'errore sintattico nella scanf (manca la virgola tra i parametri), non mi piace molto. Se il nome del file è più lungo di 30 caratteri cosa fai?

Io farei una cosa del tipo:

const FILE* input = argc > 1 ? fopen(argv[1], "r") : stdin;

... cosi funziona se passi un file da riga di comando, se te lo redirigono con una pipe, o se usi direttamente lo standard input.
Il resto rimane uguale, a parte la dimensione dell'array che è sbagliata (se non ci credi, prova a contare le 'Z' o le 'z' e vedi cosa salta fuori) e togliere un pò di boilerplate qui e là... (ma questo magari sono io che sono anale :D)

[kwb]

Umh... a parte l'errore sintattico nella scanf (manca la virgola tra i parametri), non mi piace molto. Se il nome del file è più lungo di 30 caratteri cosa fai?

Io farei una cosa del tipo:

const FILE* input = argc > 1 ? fopen(argv[1], "r") : stdin;

... cosi funziona se passi un file da riga di comando, se te lo redirigono con una pipe, o se usi direttamente lo standard input.
Il resto rimane uguale, a parte la dimensione dell'array che è sbagliata (se non ci credi, prova a contare le 'Z' o le 'z' e vedi cosa salta fuori) e togliere un pò di boilerplate qui e là... (ma questo magari sono io che sono anale :D)
Ma... Non ho idea di che significhi sta cosa xD
Cmq, l'ho risolta mettendo un ottimo array char di 30 elementi.
poi con un
scanf("%s", array)
ho caricato tutto
e finalmente si riesce ad aprire giusto...

[shinya]

e finalmente si riesce ad aprire giusto...
Emh... si no certo, funziona.
A parte spalancare le porte dell'inferno se provi a leggere il famoso "MUAHAHAHAHAHAHAHAHAHAHAHAHAHAH.txt". Per il resto, va bene.
Ma ti faccio notare che con qualche piccola modifica, senza stravolgere niente, il tuo programma potrebbe diventare molto più malleabile.

Il tuo funziona solo cosi:

$ ./a.out
Filename: a.txt
[... output ...]

Se lo modifichi in qualcosa tipo questo invece:

#include <stdio.h>
#define N 26

void display(const int* a, const int base) {
int i;

for (i = 0; i < N; ++i)
printf("%c %d\n", base + i, a[i]);
printf("\n");
}

void count_chars(const FILE* stream) {
int count_upper[N], count_lower[N], count_others = 0, ch, i;

for (i = 0; i < N; ++i)
count_upper[i] = count_lower[i] = 0;

while ((ch = getc(stream)) != EOF) {
if (ch >= 'A' && ch <= 'Z')
++count_upper[ch - 'A'];
else if (ch >= 'a' && ch <= 'z')
++count_lower[ch - 'a'];
else
++count_others;
}

display(count_upper, 'A');
display(count_lower, 'a');
printf("Other chars: %d\n", count_others);
}

int main(int argc, char** argv) {
int i;
FILE* fp;

if (argc > 1)
for (i = 1; i < argc; ++i) {
fp = fopen(argv[i], "r");

if (fp) {
count_chars(fp);
fclose(fp);
}
}
else
count_chars(stdin);

return 0;
}
...che è uguale al tuo ma con qualche accorgimento in più, funzionerebbe anche con:
$ cat a.txt | ./a.out
...
$ echo blablabla | ./a.out
...
$ ./a.out
...
$ ./a.out a.txt
...
$ ./a.out a.txt b.txt c.txt
...
ecc...ecc...

[kwb]

Bhe ma mi basterebbe mettere una cosa dopo lo scanf del tipo:
if ( strlen(filename) > 30 )
{printf("Error"); return -1;}

So che non è una soluzione bella dal punto di visto della programmazione, ma creare programmi, diciamo, 'distribuibili al grande pubblico' non fa ancora parte dei miei obiettivi.

Mi rendo conto che chiedere nella sezione programmazione ci si imbatte spesso in gente molto competente ( come te e molti altri ) che ti propone delle soluzioni certamente funzionanti ma che vanno oltre le mie capacità di programmazione. Ora come ora, avendo un esame, si tratta di capire il funzionamento delle strutture di base per passarlo. Ne avrò poi un'altro quest'anno che viene che probabilmente tratterà proprio l'ottimizzazione e argomenti inerenti, spingendosi nelle parti più remote e sconosciute del C :D :sofico: