PDA

Visualizza la versione completa : 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)&&(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, 14:43
Scusate non ho posto il codice con questa formula
codice

Scara95
13-06-2012, 16:10
Ho semplicemente identato il codice; controlla le graffe: sono tutte errate...

#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

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"


#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]);
}
}

Loading