Calcolo occorenze in C

**BossWolf** · 13-06-2012, 12:33

Ciao a tutti,
sono nuovo del forum e mi sto addentrando per la prima volta nella programmazione in C.

Dovrei scrivere come esercizio un programma in C dentro al quale ci siano vari algoritmi per il calcolo delle occorenze

Il testo dell'esercizio è il seguente:

/* Gli usuali programmi di compressione utilizzano diverse tecniche per valutare se e come un file è comprimibile.
Alcune di queste tecniche si basano sulla frequenza dei caratteri e sono le seguenti:

a) Per un carattere calcolo la sua frequenza.
b) Per ogni carattere calcolo quante volte il prossimo carattere è di ordine successivo a quello letto
[se leggo a incontro dopo b ---- h incontro i ]
c) Per ogni carattere calcolo quante sequenze almeno lunghe 2 ci sono [per la z ho una sequenza lunga 2 in "mezzo" ------ aaaab -> 1 sequenza di a (non importa quante volte ripetute basta che sia una sequenza)

Scrivere un programma:

Dato un file di ingresso contenente esclusivamente i caratteri A…Z e a….z da 0…9
in questo ordine ABCD…Zabcd…z012….9

calcolare a,b,c

fornire le frequente assolute e relative e percentuali. */

Ho provato a scrivere una bozza di tutto il codice ma tutte le volte che lo avvio non fa quello che gli chiedo e rimane solo una grande amarezza...
Grazie per chiunque mi aiuti o mi indichi vie per risolvere questi algoritmi.

**Scara95** · 13-06-2012, 12:36

Posta il codice che hai scritto e vediamo dove stanno i problemi...

**BossWolf** · 13-06-2012, 12:38

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

int main(void)
{

//Array di interi che conterrà le frequenze dei singoli caratteri nell'ordine 1..0 A..Z a..z
int occorrenzaCarattere[62];

//Array di interi che conterrà le frequenze del carattere successivo a quello appena letto
int occorrenzaSuccessivo[62];

//Array di interi che conterrà le frequenze delle sequenze per ciascun carattere
int occorrenzaSequenze[62];

//Variabile ausiliaria nella quale memorizzo il carattere appena letto
char carattereCorrente;

//Variabile ausiliaria nella quale memorizzo il carattere precedente a quello letto
char caratterePrecedente;

//Per il punto 3, è a 1 se stavo già contando quella che stà leggendo come una sequenza di lettere uguali, e quindi non devo ricontarla, 0 altrimenti
int contaSequenza;

int seqcont;
//Apro il file in modalità lettura
FILE *pf;

//pf = fopen(("caratteri.txt","r")!=NULL);
pf = fopen ("caratteri.txt","r");
if ( pf == NULL)
{
printf("Impossibile aprire il file");
exit(1);
}

//Leggo carattere per carattere dal file finchè il file non è finito
while((carattereCorrente = getc(pf))!=EOF)

{
//Verifico se il carattere letto è una cifra
if ((carattereCorrente >= 48)&&(carattereCorrente <= 57))
{
//Se è una cifra la conta
occorrenzaCarattere[carattereCorrente - 48]++;
//se è in sequenza conta la sequenza per quel carattere
if (carattereCorrente == caratterePrecedente +1)
{
occorrenzaSuccessivo[caratterePrecedente - 48]++;
}

if ((carattereCorrente == caratterePrecedente) && (seqcont==0))

{
contaSequenza = 1;
occorrenzaSequenze[carattereCorrente - 48]++;
}
else
{
contaSequenza = 0;
}

}
}
}
//Verifico se il carattere letto è una lettera maiuscola
if ((carattereCorrente >= 65) && (carattereCorrente <= 90))
{
//Se è una lettera maiuscola la conta
occorrenzaCarattere[carattereCorrente - 55]++;
//se è in sequenza conta la sequenza per quel carattere
if (carattereCorrente = caratterePrecedente +1)
occorrenzaSuccessivo[caratterePrecedente - 55]++;
if ((carattereCorrente==caratterePrecedente)&&(seqcon t==0))
{
contaSequenza = 1;
occorrenzaSequenze[carattereCorrente - 55]++;
}
else
{
contaSequenza = 0;
}

//Verifico se il carattere letto è una lettera minuscola
if ((carattereCorrente >= 97) && (carattereCorrente <= 122))
{
//Se è una lettera minuscola la conta
occorrenzaCarattere[carattereCorrente - 61]++;
//se è in sequenza conta la sequenza per quel carattere
if (carattereCorrente = caratterePrecedente +1)
occorrenzaSuccessivo[caratterePrecedente - 61]++;
if ((carattereCorrente==caratterePrecedente)&&(seqcon t==0))
{
contaSequenza = 1;
occorrenzaSequenze[carattereCorrente - 61]++;
}
else
{
contaSequenza = 0;
}
}
}

**BossWolf** · 13-06-2012, 14:43

Scusate non ho posto il codice con questa formula

codice:

codice

**Scara95** · 13-06-2012, 16:10

Ho semplicemente identato il codice; controlla le graffe: sono tutte errate...

codice:

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

int main(void)
{
	//Array di interi che conterrà le frequenze dei singoli caratteri nell'ordine 1..0 A..Z a..z
	int occorrenzaCarattere[62];

	//Array di interi che conterrà le frequenze del carattere successivo a quello appena letto
	int occorrenzaSuccessivo[62];

	//Array di interi che conterrà le frequenze delle sequenze per ciascun carattere
	int occorrenzaSequenze[62];

	//Variabile ausiliaria nella quale memorizzo il carattere appena letto
	char carattereCorrente;

	//Variabile ausiliaria nella quale memorizzo il carattere precedente a quello letto
	char caratterePrecedente;

	//Per il punto 3, è a 1 se stavo già contando quella che stà leggendo come una sequenza di lettere uguali, e quindi non devo ricontarla, 0 altrimenti
	int contaSequenza;

	int seqcont;
	//Apro il file in modalità lettura
	FILE *pf;

	//pf = fopen(("caratteri.txt","r")!=NULL);
	pf = fopen ("caratteri.txt","r");
	if ( pf == NULL)
	{
		printf("Impossibile aprire il file");
		exit(1);
	}

	//Leggo carattere per carattere dal file finchè il file non è finito
	while((carattereCorrente = getc(pf))!=EOF)
	{
		//Verifico se il carattere letto è una cifra
		if ((carattereCorrente >= 48)&&(carattereCorrente <= 57))
		{
			//Se è una cifra la conta
			occorrenzaCarattere[carattereCorrente - 48]++;
			//se è in sequenza conta la sequenza per quel carattere
			if (carattereCorrente == caratterePrecedente +1)
			{
				occorrenzaSuccessivo[caratterePrecedente - 48]++;
			}

			if ((carattereCorrente == caratterePrecedente) && (seqcont==0))
			{
				contaSequenza = 1;
				occorrenzaSequenze[carattereCorrente - 48]++;
			}
			else
			{
				contaSequenza = 0;
			}
		}
	}
}
//Verifico se il carattere letto è una lettera maiuscola
if ((carattereCorrente >= 65) && (carattereCorrente <= 90))
{
	//Se è una lettera maiuscola la conta
	occorrenzaCarattere[carattereCorrente - 55]++;
	//se è in sequenza conta la sequenza per quel carattere
	if (carattereCorrente = caratterePrecedente +1)
		occorrenzaSuccessivo[caratterePrecedente - 55]++;
	if ((carattereCorrente==caratterePrecedente)&&(seqcont==0))
	{
		contaSequenza = 1;
		occorrenzaSequenze[carattereCorrente - 55]++;
	}
	else
	{
		contaSequenza = 0;
	}

	//Verifico se il carattere letto è una lettera minuscola
	if ((carattereCorrente >= 97) && (carattereCorrente <= 122))
	{
		//Se è una lettera minuscola la conta
		occorrenzaCarattere[carattereCorrente - 61]++;
		//se è in sequenza conta la sequenza per quel carattere
		if (carattereCorrente = caratterePrecedente +1)
		occorrenzaSuccessivo[caratterePrecedente - 61]++;
		if ((carattereCorrente==caratterePrecedente)&&(seqcont==0))
		{
			contaSequenza = 1;
			occorrenzaSequenze[carattereCorrente - 61]++;
		}
		else
		{
			contaSequenza = 0;
		}
	}
}

**BossWolf** · 13-06-2012, 18:05

Ho ricontrollato, ma quando vado a stampare questi

codice:

printf("occorrenzaCarattere:%d\n",occorrenzaCarattere);
printf("occorrenzaSuccessivo:%d\n",occorrenzaSuccessivo);
printf("occorrenzaSequenze:%d\n",occorrenzaSequenze);
printf("contaSequenza:%d\n",contaSequenza);

mi stampa numeri enormi...per caso sono indirizzi di memoria quelli? e devo indicare più specificatamente cosa stampare?

**Who am I** · 13-06-2012, 20:39

Il nome dell' array è semplicemente l' indirizzo del primo elemento.
Non si stampa così un array, fai un ciclo e iteri su tutti gli elementi.

**BossWolf** · 14-06-2012, 11:55

Ho sistemato il codice, ho fatto i cicli di stampa sugli array,ma mi stampa ogni volta valori che non ho richiesto...come file di testo gli ho messo "1566AGGHlppq"

codice:

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

int main(void)
{
int i;
int k;
int g;

//Array di interi che conterrà le frequenze dei singoli caratteri nell'ordine 1..0  A..Z a..z
int occorrenzaCarattere[62];
//Array di interi che conterrà le frequenze del carattere successivo a quello appena letto
int occorrenzaSuccessivo[62];
//Array di interi che conterrà le frequenze delle sequenze per ciascun carattere
int occorrenzaSequenze[62];
//Variabile ausiliaria nella quale memorizzo il carattere appena letto
char carattereCorrente;
//Variabile ausiliaria nella quale memorizzo il carattere precedente a quello letto
char caratterePrecedente;
//Per il punto 3, è a 1 se stavo già contando quella che stà leggendo come una sequenza di lettere uguali, e quindi non devo ricontarla, 0 altrimenti
int contaSequenza;
int seqcont;
//Apro il file in modalità lettura
FILE *pf;
//pf = fopen(("caratteri.txt","r")!=NULL);
pf = fopen ("caratteri3.txt","r");
if ( pf == NULL)
{
printf("Impossibile aprire il file");
exit(1);
}
//Leggo carattere per carattere dal file finchè il file non è finito
while((carattereCorrente = getc(pf))!=EOF)

	{
	    //Verifico se il carattere letto è una cifra
        if ((carattereCorrente >= 48)&&(carattereCorrente <= 57))
			{
			//Se è una cifra la conta
            occorrenzaCarattere[carattereCorrente - 48]++;
			//se è in sequenza conta la sequenza per quel carattere
            if (carattereCorrente == caratterePrecedente +1)
                {
                occorrenzaSuccessivo[caratterePrecedente - 48]++;
                }

            if ((carattereCorrente == caratterePrecedente) && (seqcont==0))

				{
                contaSequenza = 1;
                occorrenzaSequenze[carattereCorrente - 48]++;
           		}
            else
				{
                contaSequenza = 0;
            	}

            }


		//Verifico se il carattere letto è una lettera maiuscola
        if ((carattereCorrente >= 65) && (carattereCorrente <= 90))
		{
			//Se è una lettera maiuscola la conta
            occorrenzaCarattere[carattereCorrente - 55]++;
			//se è in sequenza conta la sequenza per quel carattere
            if (carattereCorrente == caratterePrecedente +1)
                 occorrenzaSuccessivo[caratterePrecedente - 55]++;
                if ((carattereCorrente==caratterePrecedente)&&(seqcont==0))
                {
                contaSequenza = 1;
                occorrenzaSequenze[carattereCorrente - 55]++;
                }
                    else
                        {
                        contaSequenza = 0;
                        }

			//Verifico se il carattere letto è una lettera minuscola
            if ((carattereCorrente >= 97) && (carattereCorrente <= 122))
            {
            //Se è una lettera minuscola la conta
            occorrenzaCarattere[carattereCorrente - 61]++;
			//se è in sequenza conta la sequenza per quel carattere
                if (carattereCorrente == caratterePrecedente +1)
                    occorrenzaSuccessivo[caratterePrecedente - 61]++;
                    if ((carattereCorrente==caratterePrecedente)&&(seqcont==0))
                    {
                    contaSequenza = 1;
                    occorrenzaSequenze[carattereCorrente - 61]++;
                    }
                        else
                            {
                            contaSequenza = 0;
                            }

           }
        }
	}


    for(i=0; i<30; i++)
    {
    printf("occorrenzaCarattere:%d\n",occorrenzaCarattere[i]);
    }
    for(k=0; k<30; k++)
    {
    printf("occorrenzaSuccessivo:%d\n",occorrenzaSuccessivo[k]);
    }
    for(g=0; g<30; g++)
    {
    printf("occorrenzaSequenze:%d\n",occorrenzaSequenze[g]);
    }  
}

Discussione: Calcolo occorenze in C

Strumenti discussione

Ricerca discussione

Visualizza

Calcolo occorenze in C

Permessi di invio