Pagina 2 di 3 primaprima 1 2 3 ultimoultimo
Visualizzazione dei risultati da 11 a 20 su 23
  1. #11
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,589
    Facendo uso della libreria standard:
    codice:
    #include <iostream>
    #include <fstream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    
    //counts
    
    
    void counts(const vector<int>& v) {
    	//crea un vettore di dimensione max-min+1
    	//ovvero la dimensione del range in input
    	int mi = *min_element(v.begin(), v.end());
    	int ma = *max_element(v.begin(), v.end());
    	int l = ma-mi+1;
    	int *c = new int[l];
    	//inizializza tutto a 0
    	//suppone che ci siano 0 elementi per ogni numero
    	for(int i = 0; i < l; ++i) {
    		c[i] = 0;
    	}
    	//scorre i numeri e incrementa il contatore del numero relativo
    	for(int i = 0; i < v.size(); ++i) {
    		++c[v[i]-mi];
    	}
    	//se un contatore è diverso da 0 il numero era presente, lo stampa
    	for(int i = 0; i < l; ++i) {
    		if(c[i]!=0) {
    			cout << i+mi << " " << c[i] << endl;
    		}
    	}
    	delete[] c;
    }
    
    
    int main() {
    	vector<int> v;
    	fstream file;
        file.open ("dati.txt",ios::in);
        if(!file)
        {
            cout << "errore apertura file!!!";
        }
        
        while (!file.eof())
        {
        	int e;
            file >> e;
            v.push_back(e);
        }
        
        for (int i=0;i< v.size() ;i++)
        	cout << "  "<< v[i];
        cout << endl << endl;
        
        
        counts(v);
        
        system("pause");
    	return 0;
    }
    Senza libreria standard. Ovviamente questa implementazione fa abbastanza schifo perché ho cercato di utilizzare solo costrutti semplici, non sapendo cosa tu avessi effettivamente fatto.
    codice:
    #include <iostream>
    #include <fstream>
    using namespace std;
    
    
    //definizione vettore espandibile
    
    
    const int initsize = 8; //dimensione iniziale del vettore
    
    
    struct intvect {
    	int size;   //backend size
    	int length; //used
    	int *data;
    };
    
    
    void init(intvect& v) {
    	v.size=initsize;
    	v.length=0;
    	//allocazione vettore
    	v.data = new int[v.size];
    }
    
    
    int get(const intvect& v, int i) {
    	if(i < v.length) {
    		return v.data[i];
    	}
    	else {
    		throw("Out of bounds");
    	}
    }
    
    
    int set(intvect& v, int i, int e) {
    	if(i < v.length) {
    		v.data[i] = e;
    		return v.data[i];
    	}
    	else {
    		throw("Out of bounds");
    	}
    }
    
    
    void expand(intvect& v) {
    	int *old = v.data;
    	//raddoppia la dimensione
    	v.size *= 2;
    	v.data = new int[v.size];
    	//copia i dati nel nuovo vettore
    	for(int i = 0; i < v.length; ++i) {
    		v.data[i] = old[i];
    	}
    	//libera la memoria
    	delete[] old;
    }
    
    
    int push(intvect& v, int e) {
    	//espande se neccessario
    	if(v.length >= v.size) {
    		expand(v);
    	}
    	//inserisce
    	v.data[v.length] = e;
    	++v.length;
    	return v.data[v.length-1];
    }
    
    
    int pop(intvect& v) {
    	if(v.length > 0) {
    		--v.length;
    		return v.data[v.length];
    	}
    	else {
    		throw("Out of bounds");
    	}
    }
    
    
    //supporto
    int min(const intvect& v) {
    	if(v.length < 1) throw("undefined");
    	int ret = v.data[0];
    	for(int i = 1; i < v.length; ++i) {
    		if(v.data[i] < ret) ret = v.data[i];
    	}
    	return ret;
    }
    
    
    int max(const intvect& v) {
    	if(v.length < 1) throw("undefined");
    	int ret = v.data[0];
    	for(int i = 1; i < v.length; ++i) {
    		if(v.data[i] > ret) ret = v.data[i];
    	}
    	return ret;
    }
    
    
    //counts
    
    
    void counts(const intvect& v) {
    	//crea un vettore di dimensione max-min+1
    	//ovvero la dimensione del range in input
    	int mi = min(v);
    	int ma = max(v);
    	int l = ma-mi+1;
    	int *c = new int[l];
    	//inizializza tutto a 0
    	//suppone che ci siano 0 elementi per ogni numero
    	for(int i = 0; i < l; ++i) {
    		c[i] = 0;
    	}
    	//scorre i numeri e incrementa il contatore del numero relativo
    	for(int i = 0; i < v.length; ++i) {
    		++c[v.data[i]-mi];
    	}
    	//se un contatore è diverso da 0 il numero era presente, lo stampa
    	for(int i = 0; i < l; ++i) {
    		if(c[i]!=0) {
    			cout << i+mi << " " << c[i] << endl;
    		}
    	}
    	delete[] c;
    }
    
    
    int main() {
    	intvect v;
    	init(v);
    	fstream file;
        file.open ("dati.txt",ios::in);
        if(!file)
        {
            cout << "errore apertura file!!!";
        }
        
        while (!file.eof())
        {
        	int e;
            file >> e;
            push(v, e);
        }
        
        for (int i=0;i< v.length ;i++)
        	cout << "  "<< get(v, i);
        cout << endl << endl;
        
        
        counts(v);
        
        //system("pause");
    	return 0;
    }
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  2. #12
    Utente di HTML.it
    Registrato dal
    Dec 2015
    Messaggi
    77
    Eventualmente per l'allocazione dinamica va bene anche così? Se va bene almeno un dubbio l'ho tolto di mezzo. Ora cerco di interpretare la parte dell'algoritmo riguardante le comparazioni,perchè così a primo impatto non è che mi è proprio tutto chiaro e cerco di postare qualcosa di più simile possibile al tuo algoritmo.

    codice:
    #include <iostream>#include <fstream>
    
    
    
    
    using namespace std;
    
    
    
    
    void leggi (char *nome,int *vettore,int dim);
    void stampa(int *vettore,int n);
    
    
    
    
    int main ()
    {
    	
    	char nome[30];
    	cout<<"Inserisci nome file: ";
    	cin>>nome;
    	
    	
    	fstream file;
    	int numeri;
    	file.open(nome,ios::in);
    	if(!file)
    	{
    		cout<<"File non trovato"<<endl;
    	}
    	
    	
    	 int dim=0;
    /*	 while(!file.eof())
    	 {
    	 	file>>numeri;
    	 	i++;
    	 }
    */
    
    
    	while (file>>numeri)
    	dim++;
    	
    	
    	cout << "La dimensione del vettore e': " << dim; 
    	int *vettore;
    	vettore = new int[dim];
    	
    	leggi(nome,vettore,dim);
    	cout << "Il vettore stampato e': ";
        stampa(vettore,dim);
        
    	file.close();
    	cout << "\n\n";
    	system("pause");
    }
    
    
    
    
    
    
    
    
    
    
    void leggi (char*nome,int *vettore,int dim)
    {
    	fstream file;
    	file.open(nome,ios::in);
    	if(!file)
    	{
    		cout<<"File non trovato"<<endl;
    	}
    	
    	 
    	 for(int i=0;i<dim;i++)
    	{
    	 	file>>vettore[i];
    	}
    		file.close();
    		
    			
    	
    	cout << "\n\n";
    }
    
    
    
    
    void stampa(int *vettore,int dim)
    {
        for(int i=0;i<dim;i++)
    	 {
    	 	cout<< " | " << vettore[i]<< " | ";
    	 }
    		
        cout << "\n\n";
    }

  3. #13
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,589
    Se ti va bene scorrere due volte il file sì
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  4. #14
    Utente di HTML.it
    Registrato dal
    Dec 2015
    Messaggi
    77
    Suppongo che per il mio livello principiante sia accettabile come cosa. Comunque del tuo codice non ho ben capito come collaborano insieme le funzioni int min,int max e void counts, cioè le prima due a cosa servono di preciso?

  5. #15
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,589
    Trova il minimo(massimo).
    Scorre l'array tenendo sempre l'elemento più piccolo(grande).
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  6. #16
    Utente di HTML.it
    Registrato dal
    Dec 2015
    Messaggi
    77
    ah ecco ora ho capito che hai fatto, trovando il massimo e il minimo ti sei dato un range dei dati da gestire. Ti prometto che l'ultimo dubbio è non ti rompo più, non ho ben capito dove fai le comparazioni tra i vari numeri, dai tuoi commenti nel programma penso che il problema stia qua,inoltre questa notazione ++c non l'ho mai vista ad essere sincero.

    codice:
    for(int i = 0; i < v.length; i++) {        ++c[v.data[i]-mi];
        }
    Ho notato inoltre che il programma che mi hai scritto ha un piccolo errore,in pratica mi aggiunge un numero in più alla sequenza esempio: 1 2 3 4 5. Quando eseguo il programma legge la sequenza 1 2 3 4 5 5 e perciò mi conta un numero in più che in realtà non c'è.

  7. #17
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,589
    Quote Originariamente inviata da Mrhide1 Visualizza il messaggio
    ah ecco ora ho capito che hai fatto, trovando il massimo e il minimo ti sei dato un range dei dati da gestire. Ti prometto che l'ultimo dubbio è non ti rompo più, non ho ben capito dove fai le comparazioni tra i vari numeri, dai tuoi commenti nel programma penso che il problema stia qua,inoltre questa notazione ++c non l'ho mai vista ad essere sincero.

    codice:
    for(int i = 0; i < v.length; i++) {        ++c[v.data[i]-mi];
        }
    Ho notato inoltre che il programma che mi hai scritto ha un piccolo errore,in pratica mi aggiunge un numero in più alla sequenza esempio: 1 2 3 4 5. Quando eseguo il programma legge la sequenza 1 2 3 4 5 5 e perciò mi conta un numero in più che in realtà non c'è.
    ++a è simile ad a++ l'unica differenza è che il primo fa l'incremento e poi restituisce il nuovo valore, mentre il secondo prima restituisce il nuovo valore e poi fa l'incremento. In quel contesto fanno esattamente la stessa cosa quindi, poiché il valore restituito non viene utilizzato.
    Non c'è nessun compare perché ad ogni numero nel range corrisponde una casella nell'array che viene usata per contare le volte che appare (l'incremento di uno sta a significare che appare "una volta in più di prima").

    Per quanto riguarda il problema in lettura, non ho fatto attenzione e ho preso il tuo codice dandolo per giusto. Il problema deriva dalla presenza di spazi a fine file, quindi non hai raggiunto l'eof ma ci sono ancora caratteri. Puoi risolvere così:
    codice:
        int e;
        while (file >> e)    {
            push(v, e);
        }
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  8. #18
    Utente di HTML.it
    Registrato dal
    Dec 2015
    Messaggi
    77
    No scusami ho sbagliato io nell'impostare la domanda,la differenza la so tra le due notazioni,quello che non ho capito � come fa quella parte di codice che ti ho indicato a far girare tutto bene. Mi da l'impressione che dici se becco il numero v.data[i]-mi incrementa l'occorrenza nella casella dell'array relativo a quel numero quindi passa 0 a 1 per esempio. Ah che poi in sostanza con il range in input hai fatto un p� una furbata perch� se i numeri sono 1 2 3 256 in realt� il tuo range � di 256 numeri ma imponendo la condizione di stampare tutti i numeri che hanno numero di occorrenze diverso da zero hai eliminato tutti i numeri da 4 a 255.

  9. #19
    Utente di HTML.it
    Registrato dal
    Dec 2015
    Messaggi
    77
    No scusami ho sbagliato io nell'impostare la domanda,la differenza la so tra le due notazioni,quello che non ho capito è come fa quella parte di codice che ti ho indicato a far girare tutto bene. Mi da l'impressione che dici se becco il numero v.data[i]-mi incrementa l'occorrenza nella casella dell'array relativo a quel numero quindi passa 0 a 1 per esempio. Ah che poi in sostanza con il range in input hai fatto un pò una furbata perchè se i numeri sono 1 2 3 256 in realtà il tuo range è di 256 numeri ma imponendo la condizione di stampare tutti i numeri che hanno numero di occorrenze diverso da zero hai eliminato tutti i numeri da 4 a 255.

  10. #20
    Bhe, la soluzione è molto semplice:
    - Leggi tutti i valori dal file e li metti in un array;
    - Leggi il primo valore dell'array e controlli tutti gli altri valori. Il numero di valori identici che hai trovato li metti in un altro vettore e il
    numero che hai letto prima lo salvi in un altro vettore ancora, onde evitare controlli su numeri già controllati.
    - Ripeti la cosa fino alla fine dell'array.

    Per spiegarmi meglio provo con una spiegazione più dettagliata dell'algoritmo:

    FILE1: 10, 11, 10, 10, 11, 6

    dichiaro vettore vet[] che contiene il valore di ogni numero letto dal file;
    dichiaro vettore occor[] che contiene il numero di corrispondenze trovate;
    dichiaro vettore val[] che contiene ogni valore dell'array vet ripetuto una volta;
    Leggo tutto il file "FILE1" e metto i valori in vet;
    leggo il valore di vet[1] (cioè 10) e controllo tutti gli altri elementi dell'array;
    il numero di corrispondenze trovate lo metto in occor[1] (3);
    il valore di vet[1] (e cioè 10) lo copio in val[1];
    prendo vet[2] e controllo che non sia uguale a qualsiasi valore contenuto in val.
    faccio la stessa cosa che ho fatto con vet[1] e la ripeto fino alla fine di vet;

    FINE

    Alla fine in val si avrà tutti i numeri del file ripetuti una sola volta e in occor la numerosità con la quale il relativo valore si ripete.

    Quindi:
    vet[]=10, 11, 10, 10, 11, 6
    val[]=10, 11, 6
    occor[]=3, 2, 1

    Quindi, nel file di output:

    FILE2:
    10, 3
    11, 2
    6, 1

    Credo di aver risposto alla tua domanda in modo soddisfacente.

    Fammi sapere se sei convinto o meno, o se non hai capito qualche cosa.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.