[C] Dubbio esercizio funzione ricorsiva

[nick_10]

Buonasera a tutti!
Ho un dubbio sullo svolgimento di questo esercizio:
"Si scriva in C una funzione ricorsiva che legge in input una sequenza di interi che termina quando viene immesso zero (che non fa parte della sequenza), e restituisce true se il prodotto di tutti gli elementi letti è un intero positivo, altrimenti restituisce false, senza utilizzare la moltiplicazione".
Io ho fatto il seguente codice

#include <stdio.h>
typedef enum {false, true} boolean;
boolean ric(){
    int neg=0,m;
    scanf("%d",&m);
    if(m!=0){
        if(m<0) neg=1+ric();
        else neg=ric();
    }
    if((neg%2==0)) return true;
    else return false;
}

La mia idea è quella di contare i numeri negativi che appaiono nella sequenza e poi verificare la sua parità.
Però non funziona

[nick_10]

Sì funziona!

[Raptorista1]

E allora va bene. Non sarà il più bel pezzo di codice mai scritto, ma non importa.

[nick_10]

Su questo sono d'accordissimo
Mi scuso per aver fatto perder la pazienza ad entrambi e soprattutto aver scoraggiato @SuperSquirrel

[Raptorista1]

Io non ho perso la pazienza per niente, sono contento se hai capito qualcosa. Il mio pezzo di codice ti è chiaro?

[nick_10]

Sisi perfetto. Più che altro è la prima volta che vedo un esercizio fatto cosi

Poi per di più questa discussione mi è stata utilissima per capire a fondo la ricorsione...andavo un po' a caso e senza logica prima.
Grazie ad entrambi

[Raptorista1]

Bene! Se hai altre domande non esitare a porle!

[Super Squirrel]

@nick_10
in effetti un pochino mi ero scoraggiato!

Scherzi a parte, mi fa piacere vedere che hai colto il punto, ossia che la cosa fondamentale è avere ben chiara la logica di quello che si sta facendo.
A tal proposito può essere utile analizzare il codice in questione (ho ipotizzato che al solito neg sia una variabile intera inizializzata a 0, anche se in questo caso l'inizializzazione non è obbligatoria):

int ric()
{
    int neg = 0;
    int n;
    scanf("%d", &n);
    if(n != 0)
    {
        if(n < 0)
        {
            neg = 1 + ric();
            if(neg % 2 == 0)
            {
                return 0;
            }
            return -1;
        }
        return ric();
    }
    return 0;
}

Vediamo se ho interpretato bene... se tale funzione ritorna 0 allora il prodotto è positivo, altrimenti il prodotto è negativo, giusto?
Innanzitutto concentriamoci sulla variabile neg... dal momento che essa può essere modificata solo dall'assegnazione neg=1+ric(); e poichè la funzione può ritornare 0 o -1, implica che la suddetta variabile può assumere solo i valori 0 e 1. Quindi anche in questo caso la variabile neg non va a contare gli inserimenti negativi così come ti eri prefissato di fare.

Valutiamo ora il corpo di if(n<0):
- ric()=-1 ==> neg=0 ==> (neg%2==0)=true ==> return 0;
- ric()=0 ==> neg=1 ==> (neg%2==0)=false ==> return -1;

Quindi il frammento di codice

if(n < 0)
{
    neg = 1 + ric();
    if(neg % 2 == 0)
    {
        return 0;    
    }
    return -1;
}

è perfettamente equivalente a

if(n < 0)
{
    return -1-ric();
}

o più semplicemente a

if(n < 0)
{
    if(ric() == 0)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}

Riprendiamo ora il codice di @Raptorista. Il frammento

if(n < 0)
{
    return !ric();
}

equivale a

if(n < 0)
{
    if(ric() == true)
    {
        return false;
    }
    else
    {
        return true;
    }
}

A questo punto noterai che il tuo codice è perfettamente identico a quello di @Raptorista, con l'unica differenza che il tuo per prodotti parziali positivi e negativi ritorna rispettivamente 0 e -1, mentre l'altro 1 e 0.

La logica è quella che ti ho spiegato già in precedenza, e si basa sul fatto che la funzione possa ritornare solo 2 valori, di cui uno associato ad un prodotto parziale positivo ed uno associato ad un prodotto parziale negativo.
Ipotizziamo che questi due valori siano P (che sta per Positivo) e N (che sta per Negativo). Una volta associato all'inserimento nullo il valore "neutro" (ossia per n=0 ==> return P), avremo che il ritorno della funzione passerà da P a N e viceversa ogni volta che la funzione ricorsiva incontra un valore negativo.

Spero di essere stato chiaro e che questo lungo post possa averti aiutato a capire meglio la soluzione di questo esercizio!

[nick_10]

Perfetto! Non so come ringraziarvi. Grazie mille ad entrambi