Funzione ricorsiva che restituisce un insieme differenza

di il
14 risposte

Funzione ricorsiva che restituisce un insieme differenza

Ciao a tutti dovrei progettare una funzione che ha come parametri di ingresso due insiemi e restituisce la loro differenza calcolata ricorsivamente
Questo è quello che siamo riusciti a fare ma continua a dare sto benedetto errore di segmentazione:

typedef struct insieme
 {
	double *arr;     /*array che andrà a contenere gli elementi dell'insieme*/
	int dim;	 /*variabile per il numero di elementi dell'insieme*/
	int ind;	 /*variabile indice per muoversi all'interno dell'array*/
 } insieme_t;


insieme_t * differenza (insieme_t ins1,       /*variabile per rappresentare il primo insieme*/
					    insieme_t ins2)      /*variabile per rappresentare il secondo insieme*/
  {
    insieme_t * ins_diff = NULL;     /*variabile per restituire alla main l'insieme differenza*/
   
	if( (ins1 . ind) < (ins1 . dim) )
	{
		for (ins2 . ind = 0; (ins2 . ind) < (ins2 . dim); ins2 . ind ++)
			if((ins1 . arr[ins1 . ind]) != (ins2 . arr[ins2 . ind]))
			{
				if(ins_diff  == NULL)
				{
					ins_diff -> dim = 1;
					ins_diff -> ind = 0;
					ins_diff -> arr= (double *) calloc( 1, sizeof(double));
					ins_diff -> arr[ins_diff -> ind] = ins1 . arr[ins1 . ind];
					ins1 . ind ++;
					ins_diff -> arr= (double *) calloc( 1, sizeof(double));
					ins_diff -> arr[ins_diff -> ind] = ins1 . arr[ins1 . ind];
					ins1 . ind ++;
					differenza(ins1, ins2);
				}
				else
				{
	               	ins_diff -> dim ++;
	               	ins_diff -> ind = ins_diff -> dim --;
	               	ins_diff -> arr = (double *) realloc(ins_diff -> arr, ins_diff -> dim * sizeof(double));
	               	ins_diff -> arr[ins_diff -> ind] = ins1 . arr[ins1 . ind];
	               	ins1 . ind ++;
	               	differenza(ins1, ins2);
	            }
			}
		ins1 . ind ++;
		ins_diff = differenza (ins1, ins2);
	}
	ins1 . ind = 0;
	ins2 . ind = 0;
	ins_diff -> ind = 0;
	return(ins_diff);
}

14 Risposte

  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Una cosa FONDAMENTALE nella definizione di una funzione ricorsiva e' usare una struttura dati RICORSIVA.
    Il VETTORE/ARRAY NON E' una struttura dati ricorsiva, ma, ad esempio, lo e' la LISTA, la quale PUO ESSERE IMPLEMENTATA mediante un array, ma anche in n-mila altri modi diversi.

    Una lista e' definita RICORSIVAMENTE nel seguente modo:
    
    [] e' una lista (la lista VUOTA)
    [a|L]  e' una lista composta da un elemento, seguito da una lista
    
    Esempio:
    
    L = [a,b,c] = [a|[b,c]] = [a|[b|[c]]] = [a|[b|[c|[]]]]
    
    Ora ti servono una serie di funzioni per la sua manipolazione
    
    cons(a, L) = [a|L]   : aggiungi a alla lista L
    first([a|L]) -> a     : estrai il primo elemento della lista
    rest([a|L]) -> L      : ritorni la lista MENO il primo elemento
    
    L = cons(first(L),rest(L))
    
    Esempio:
    
    cons(a,[b,c]) -> [a,b,c]
    first([a,b,c]) -> a
    rest([a,b,c]) -> [b,c]
    
    first([]) ERRORE
    rest([]) ERRORE
    
    Ora ti serve una funzione RICORSIVA per controllare se un elemento e' presente in una lista
    
    contains(a, L):
        if L == [] then return false
        if a == first(L) then return true
        return contains(a, rest(L))
    
    Quindi ti serve una funzione per calcolare la differenza
    
    difference(S, L):
       if S == [] then return []
       if contains(first(S), L) then return difference(rest(S), L)
       return cons(first(S), difference(rest(S), L)
    
    Ora sta a te convertire questo PSEUDOCODICE nell'equivalente C.
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Raga la variabile ins_diff DEVE essere static: è già stato spiegato tremila volte, non è che se ci riprovate al tentativo 3001 le cose funzionano come per magia
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Weierstrass ha scritto:


    Raga la variabile ins_diff DEVE essere static: è già stato spiegato tremila volte, non è che se ci riprovate al tentativo 3001 le cose funzionano come per magia

    Ci ho provato a metterla static ma da sempre errore di segmentazione
    Secondo me dobbiamo farla con le liste come dice @migliorabile anche se nelle lezioni di questo fantastico professore non ci sono state spiegate... Che dire... Sono rimasti 3-4 giorni per consegnare e mi sa proprio che lo daremo al secondo appello.
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Esistono I LIBRI su cui studiare!

    Non puoi sperare che un professore travasi la sua conoscenza in qualche modo miracoloso modo nella TUA testa e MIRACOLOSAMENTE sarai in grado di risolvere QUALUNQUE esercizio.

    Ma PRIMA di scrivere il codice, bisogna AVER CAPITO tutto il resto!

    Nota che non ci sono contatori, non ci sono variabili statiche, ci sono SOLO PARAMETRI PASSATI ALLE FUNZIONI
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Zack909 ha scritto:


    Weierstrass ha scritto:


    Raga la variabile ins_diff DEVE essere static: è già stato spiegato tremila volte, non è che se ci riprovate al tentativo 3001 le cose funzionano come per magia

    Ci ho provato a metterla static ma da sempre errore di segmentazione
    Secondo me dobbiamo farla con le liste come dice @migliorabile anche se nelle lezioni di questo fantastico professore non ci sono state spiegate... Che dire... Sono rimasti 3-4 giorni per consegnare e mi sa proprio che lo daremo al secondo appello.
    Questo perché sei nel panico. L'insieme differenza si ottiene facilmente da quello intersezione
    struct insieme
    {
      double *  a;
      int       l;
    };
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
    
        if(ret == NULL){   
            ret = (insieme *)malloc(sizeof(insieme));
            if(ret != NULL){
                k = ret->l = step;
                if(k > 0){
                    ret->a = (double *)malloc(k*sizeof(double));  
                    if(ret->a != NULL){
                        while(k--)
                        	ret->a[k] = i1.a[k];       
                    }
                    else 
                        ret = NULL;
                }
            }
        }    
        
        step--;
        return ret;   
    }
    insieme * differenza(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        insieme * intersez = NULL;    
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    differenza(i1, i2);
                }
    
        if(ret == NULL){   
            intersez = (insieme *)malloc(sizeof(insieme));
            if(intersez != NULL){
                k = intersez->l = step;
                if(k > 0){
                    intersez->a = (double *)malloc(k*sizeof(double));  
                    if(intersez->a != NULL){
                        while(k--)
                            intersez->a[k] = i1.a[k];       
                    }
                    else 
                    	intersez = NULL;
                }
            }
            if(intersez != NULL){
                ret = (insieme *)malloc(sizeof(insieme));  
                if(ret != NULL){
                    k = ret->l = i1.l - intersez->l;
                    if(k > 0){
                        ret->a = (double *)malloc(k*sizeof(double));  
                        if(ret->a != NULL){
                            j = i1.l;
                            while(k--)
                                ret->a[k] = i1.a[--j];  
                        }
                        else 
                            ret = NULL;
                    }
                }
            }
        }    
        
        step--;
        return ret;   
    }
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    migliorabile ha scritto:


    Esistono I LIBRI su cui studiare!

    Non puoi sperare che un professore travasi la sua conoscenza in qualche modo miracoloso modo nella TUA testa e MIRACOLOSAMENTE sarai in grado di risolvere QUALUNQUE esercizio.

    Ma PRIMA di scrivere il codice, bisogna AVER CAPITO tutto il resto!

    Nota che non ci sono contatori, non ci sono variabili statiche, ci sono SOLO PARAMETRI PASSATI ALLE FUNZIONI
    Io non mi aspetto che il professore travasi la conoscenza ma che almeno nel programma ci siano le liste, dato che a quanto pare servono.
    Nel libro non c'è traccia delle liste, mi arrangerò, grazie comunque
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    migliorabile ha scritto:


    Nota che non ci sono contatori, non ci sono variabili statiche, ci sono SOLO PARAMETRI PASSATI ALLE FUNZIONI
    Tutto giusto, ma se hai seguito le precedenti puntate, il professore aveva esplicitato che non vuole la soluzione secondo quel modello... di conseguenza ci sono le variabili static, che nessuno giustamente gli aveva suggerito dall'inizio
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Weierstrass ha scritto:


    Zack909 ha scritto:


    Weierstrass ha scritto:


    Raga la variabile ins_diff DEVE essere static: è già stato spiegato tremila volte, non è che se ci riprovate al tentativo 3001 le cose funzionano come per magia

    Ci ho provato a metterla static ma da sempre errore di segmentazione
    Secondo me dobbiamo farla con le liste come dice @migliorabile anche se nelle lezioni di questo fantastico professore non ci sono state spiegate... Che dire... Sono rimasti 3-4 giorni per consegnare e mi sa proprio che lo daremo al secondo appello.
    Questo perché sei nel panico. L'insieme differenza si ottiene facilmente da quello intersezione
    struct insieme
    {
      double *  a;
      int       l;
    };
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
    
        if(ret == NULL){   
            ret = (insieme *)malloc(sizeof(insieme));
            if(ret != NULL){
                k = ret->l = step;
                if(k > 0){
                    ret->a = (double *)malloc(k*sizeof(double));  
                    if(ret->a != NULL){
                        while(k--)
                        	ret->a[k] = i1.a[k];       
                    }
                    else 
                        ret = NULL;
                }
            }
        }    
        
        step--;
        return ret;   
    }
    insieme * differenza(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        insieme * intersez = NULL;    
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    differenza(i1, i2);
                }
    
        if(ret == NULL){   
            intersez = (insieme *)malloc(sizeof(insieme));
            if(intersez != NULL){
                k = intersez->l = step;
                if(k > 0){
                    intersez->a = (double *)malloc(k*sizeof(double));  
                    if(intersez->a != NULL){
                        while(k--)
                            intersez->a[k] = i1.a[k];       
                    }
                    else 
                    	intersez = NULL;
                }
            }
            if(intersez != NULL){
                ret = (insieme *)malloc(sizeof(insieme));  
                if(ret != NULL){
                    k = ret->l = i1.l - intersez->l;
                    if(k > 0){
                        ret->a = (double *)malloc(k*sizeof(double));  
                        if(ret->a != NULL){
                            j = i1.l;
                            while(k--)
                                ret->a[k] = i1.a[--j];  
                        }
                        else 
                            ret = NULL;
                    }
                }
            }
        }    
        
        step--;
        return ret;   
    }
    Come sempre perfettamente funzionante!! Grazie mille, ora dobbiamo fare "semplicemente" una funzione che fa l'unione dei 2 insiemi differenza(differenza simmetrica), basta richiamare 2 volte la funzione differenza invertendo gli insiemi e poi fare un'unione giusto?
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Zack909 ha scritto:


    Come sempre perfettamente funzionante!! Grazie mille, ora dobbiamo fare "semplicemente" una funzione che fa l'unione dei 2 insiemi differenza(differenza simmetrica), basta richiamare 2 volte la funzione differenza invertendo gli insiemi e poi fare un'unione giusto?
    In realtà i due insiemi sono già ordinati nel modo corretto, quindi con grande fantasia...
    insieme * differenza_simmetrica(insieme i1, insieme i2)
    {
        int k, j, i;
        double temp;
        insieme * intersez = NULL;    
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    differenza_simmetrica(i1, i2);
                }
    
        if(ret == NULL){   
            intersez = (insieme *)malloc(sizeof(insieme));
            if(intersez != NULL){
                k = intersez->l = step;
                if(k > 0){
                    intersez->a = (double *)malloc(k*sizeof(double));  
                    if(intersez->a != NULL){
                        while(k--)
                            intersez->a[k] = i1.a[k];       
                    }
                    else 
                    	intersez = NULL;
                }
            }
            if(intersez != NULL){
                ret = (insieme *)malloc(sizeof(insieme));  
                if(ret != NULL){
                    k = i1.l - intersez->l;
                    i = i2.l - intersez->l;
                    ret->l = k + i;
                    if(ret->l > 0){
                        ret->a = (double *)malloc(ret->l*sizeof(double));  
                        if(ret->a != NULL){
                            j = i1.l;
                            while(k--)
                                ret->a[k] = i1.a[--j]; 
                            k = i1.l - intersez->l;
                            j = i2.l;
                            while(i--)
                                ret->a[k + i] = i2.a[--j];                          
                        }
                        else 
                            ret = NULL;
                    }
                }
            }
        }    
        
        step--;
        return ret;   
    }
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Weierstrass ha scritto:


    Zack909 ha scritto:


    Come sempre perfettamente funzionante!! Grazie mille, ora dobbiamo fare "semplicemente" una funzione che fa l'unione dei 2 insiemi differenza(differenza simmetrica), basta richiamare 2 volte la funzione differenza invertendo gli insiemi e poi fare un'unione giusto?
    In realtà i due insiemi sono già ordinati nel modo corretto, quindi con grande fantasia...
    insieme * differenza_simmetrica(insieme i1, insieme i2)
    {
        int k, j, i;
        double temp;
        insieme * intersez = NULL;    
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    differenza_simmetrica(i1, i2);
                }
    
        if(ret == NULL){   
            intersez = (insieme *)malloc(sizeof(insieme));
            if(intersez != NULL){
                k = intersez->l = step;
                if(k > 0){
                    intersez->a = (double *)malloc(k*sizeof(double));  
                    if(intersez->a != NULL){
                        while(k--)
                            intersez->a[k] = i1.a[k];       
                    }
                    else 
                    	intersez = NULL;
                }
            }
            if(intersez != NULL){
                ret = (insieme *)malloc(sizeof(insieme));  
                if(ret != NULL){
                    k = i1.l - intersez->l;
                    i = i2.l - intersez->l;
                    ret->l = k + i;
                    if(ret->l > 0){
                        ret->a = (double *)malloc(ret->l*sizeof(double));  
                        if(ret->a != NULL){
                            j = i1.l;
                            while(k--)
                                ret->a[k] = i1.a[--j]; 
                            k = i1.l - intersez->l;
                            j = i2.l;
                            while(i--)
                                ret->a[k + i] = i2.a[--j];                          
                        }
                        else 
                            ret = NULL;
                    }
                }
            }
        }    
        
        step--;
        return ret;   
    }

    Grazie Infinite!! Non so come fai a farle in così poco tempo
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Zack909 ha scritto:


    Non so come fai a farle in così poco tempo
    E' un mago ...
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Zack909 ha scritto:


    Weierstrass ha scritto:


    Zack909 ha scritto:


    Come sempre perfettamente funzionante!! Grazie mille, ora dobbiamo fare "semplicemente" una funzione che fa l'unione dei 2 insiemi differenza(differenza simmetrica), basta richiamare 2 volte la funzione differenza invertendo gli insiemi e poi fare un'unione giusto?
    In realtà i due insiemi sono già ordinati nel modo corretto, quindi con grande fantasia...
    insieme * differenza_simmetrica(insieme i1, insieme i2)
    {
        int k, j, i;
        double temp;
        insieme * intersez = NULL;    
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    differenza_simmetrica(i1, i2);
                }
    
        if(ret == NULL){   
            intersez = (insieme *)malloc(sizeof(insieme));
            if(intersez != NULL){
                k = intersez->l = step;
                if(k > 0){
                    intersez->a = (double *)malloc(k*sizeof(double));  
                    if(intersez->a != NULL){
                        while(k--)
                            intersez->a[k] = i1.a[k];       
                    }
                    else 
                    	intersez = NULL;
                }
            }
            if(intersez != NULL){
                ret = (insieme *)malloc(sizeof(insieme));  
                if(ret != NULL){
                    k = i1.l - intersez->l;
                    i = i2.l - intersez->l;
                    ret->l = k + i;
                    if(ret->l > 0){
                        ret->a = (double *)malloc(ret->l*sizeof(double));  
                        if(ret->a != NULL){
                            j = i1.l;
                            while(k--)
                                ret->a[k] = i1.a[--j]; 
                            k = i1.l - intersez->l;
                            j = i2.l;
                            while(i--)
                                ret->a[k + i] = i2.a[--j];                          
                        }
                        else 
                            ret = NULL;
                    }
                }
            }
        }    
        
        step--;
        return ret;   
    }

    Grazie Infinite!! Non so come fai a farle in così poco tempo
    Era facile dai, è quasi uguale a prima
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    Provo a darti una mano ...

    funzione di differenza
    
    
    				
    elem_insieme_t *controllo_diff(elem_insieme_t *insieme1_p,	
    				
    				elem_insieme_t *insieme2_p)
    {
    	
    
    			
    	elem_insieme_t *diff_p,	
    			
    			*ins1_p,
    			
    			*ins2_p;	
    
    
    	ins1_p = insieme1_p;
    	ins2_p = insieme2_p;
    	diff_p = NULL;
    
    	
    	if ((ins1_p == NULL) && (ins2_p == NULL))
    	{
    		
    		diff_p = NULL;
    	}
    	
    	else if ((ins1_p != NULL) && (ins2_p == NULL))
    	{
    		
    		diff_p = ins1_p;
    	}
    	
    	else if ((ins1_p == NULL) && (ins2_p != NULL))
    	{
    		
    		diff_p = NULL;
    	}
    	
    	else
    	{
    	
    		diff_p = controllo_diff(ins1_p->elem_succ_p, ins2_p);
    		/* controlla se il valore di ins1_p non e' presente in ins2_p */
    		if(cerca_in_lista(ins2_p, ins1_p->valore) == 0)
    		{
    		
    			inserisci_in_lista(&diff_p, ins1_p->valore);
    		}
    
    	}    
    
    	return(diff_p);
    }	
    
    
    funzione di cerca in lista
    
    
    			
    int cerca_in_lista(elem_insieme_t *testa_p,	
    			   double valore)
    {
    	
    
    		
    	int presente;	
    					
    	elem_insieme_t *elem_p;		
    
    	
    	elem_p = testa_p;
    	presente = 0;
    
    
    	if (elem_p == NULL)
    	{
    		
    		presente = 0;
    	}
    	
    	else if (elem_p->valore == valore)
    	{
    	
    		presente = 1;
    	}
    	
    	else
    	{
    		
    		presente = cerca_in_lista(elem_p->elem_succ_p, valore);
    	}
    
    	return(presente);
    
    }
    
    funzione di inserimento in lista
    
    	
    int inserisci_in_lista(elem_insieme_t **testa_p,
    				
    			double valore)					
    {
    	
    
    			
    	int 	inserito;
    					
    	elem_insieme_t *corr_p,	
    			
    			*prec_p,
    			
    			*nuovo_p;		
    
    		
    	for (corr_p=prec_p= *testa_p;
    		((corr_p != NULL) && (corr_p->valore < valore));
    		prec_p = corr_p, corr_p = corr_p->elem_succ_p);
    
    	
    	if ((corr_p != NULL) && (corr_p->valore == valore))
    
    		inserito = 0;
    
    	
    	else
    	{
    		inserito = 1;
    		
    		nuovo_p = (elem_insieme_t *) malloc(sizeof(elem_insieme_t));	
    		nuovo_p->valore = valore;
    		nuovo_p->elem_succ_p = corr_p;
    
    		
    		if (corr_p == *testa_p)
    			*testa_p = nuovo_p;
    
    		 
    		else
    			prec_p->elem_succ_p = nuovo_p;
    	}
        
    	return(inserito);
    
    }
    
    Questo codice l'ho utilizzato per la consegna di un progetto di programmazione alla facoltà di urbino, se stai facendo lo stesso progetto, stai attento.

    Ho omesso i commenti, se ti servono delle spiegazioni te le posso dare. Non fare copia e incolla, non ha senso e non capisci nulla.

    Jack
  • Re: Funzione ricorsiva che restituisce un insieme differenza

    @Zak909 se confronti l'implementazione di @Zenek con quella che ti avevo scritto io all'inizio, noterai che

    SONO ESATTAMENTE LA STESSA COSA

Devi accedere o registrarti per scrivere nel forum
14 risposte