Matematicamente.it

Quindi il problema nel primo codice è che la funzione ricorsiva ritornava true(1) o false(0)?

Se lo scopo era quello di contare i vari inserimenti negativi, sì, quello era uno dei problemi.

Per quanto riguarda il tuo codice non capisco il passaggio if(n)...

if(n) coincide con if(n!=0). Mi spiego meglio...
Le condizioni delle istruzioni di controllo (if, while, ...) sono delle espressioni logiche e come tali possono assumere solo due valori: vero (1) e falso (0). Il risultato di un'espressione logica è quindi una quantità booleana.
Tornando ad if(n), essendo la condizione costituita da una variabile intera e dovendo essere valutata come un'espressione logica, quello che avviene è un casting implicito da int a bool. Ebbene le regole di casting da int a bool prevedono che 0 coincide con false e tutti gli altri possibili valori (sia positivi che negativi) con true.

...e poi il return (n>0)==ric(). La tua logica credo sia diversa dal contare "i segni meno" della sequenza.

Consideriamo per esempio la sequenza di inserimenti -5 3 -7 0; risolvendo la ricorsione a ritroso avremo che:
- per n=0 la funzione ritorna 1 (poiché l'if viene saltato);
- per n=-7, valutando l'espressione logica (n>0)==ric(), la funzione ritorna 0==1, ossia 0;
- per n=3 la funzione ritorna 1==0, ossia 0;
- per n=-5 la funzione ritorna 0==0, ossia 1.
In pratica una volta incontrato un valore negativo, l'unico modo affinché la funzioni ritorni nuovamente 1 è quello di incontrare un nuovo valore negativo... e quindi in definitiva il risultato della ricorsione sarà 1 soltanto se il numero di inserimenti negativi è multiplo di 2.

Ma il mio metodo è proprio da buttare? Se volessi fare una funzione ricorsiva che mi conti i negativi e poi controlli che la somma sia pari o dispari?

Se intendi una funzione del tipo bool ric(void), allora la vedo difficile!

@Super squirrel: a dare una soluzione ero capace pure io, ma come vedi non hai risolto granché. Cerca di attenerti al regolamento.

@Nick: la tua idea è buona, devi però implementarla correttamente. Prova a eseguire a voce il tuo codice con la sequenza 1 0, controlla se ottieni il risultato corretto e in caso contrario cerca di capire dov'è che le cose vanno male e perché.

Grazie ad entrambi intanto per la pazienza...non sono un tipo facile xD
Comunque rileggendo il mio primo codice ho capito davvero che non ha alcun senso...
Per rifarlo da capo ho pensato ad una cosa del genere

Codice:

#include <stdio.h>

int ric()
{
    int n;
    scanf("%d", &n);
    if(n==0) return 1;
    else{
        if(n<0) return -1*ric();
        else return 1*ric();
    }
}

int main()
{
    if(ric()==1) printf("TRUE");
    else printf("FALSE");
    return 0;
}

Questa volta dovrebbe andare...più che altro ho giocato sul 1 e -1...non saprei come farlo col true(1) e false che però è "identificato" da 0.

P.s. Invece se posso utilizzare due funzioni potrei tenermi anche il secondo codice che ho pubblicato. O sbaglio?

Stai usando delle moltiplicazioni, quel codice non è accettabile

Come ti dicevo, basta fare return ric o return not ric.

Argh...giusto
Nel frattempo ci ho riprovato di nuovo. Butto qui solo un'idea dato che ancora non lo provo

Codice:

int ric()
{
//salto un attimo tutte le dichiarazioni che servono
if(n==0) return 0;
else{
        if(n<0)
       {
                neg=1+ric();
                if(neg%2==0) return 0;
                else return -1;
       }
       else return ric();
}
}       

Quello di primo era corretto... ritornava 1 in caso di prodotto positivo e -1 in caso di prodotto negativo (seguendo invece l'indicazione di @Raptorista avresti avuto 1 e 0 al posto di 1 e -1).

nick_10 ha scritto:Nel frattempo ci ho riprovato di nuovo. Butto qui solo un'idea dato che ancora non lo provo

Il problema è che se la funzione deve essere del tipo bool ric(void), non c'è modo di tenere il conto degli inserimenti negativi...
il codice che hai postato prima (così come quello da me postato) funziona perché il valore di ritorno della generica chiamata ricorsiva ritorna il "segno" del prodotto fino a quel punto. In pratica, proprio perché non è possibile tenere il conto degli inserimenti negativi attraverso una variabile neg, ci si limita a confrontare il segno del prodotto fino a quel momento con il segno di n nell'attuale chiamata ricorsiva.

Quello di prima non andava bene perché ho usato delle moltiplicazioni...e in questo esercizio non posso utilizzarle.

La bozza che ho scritto come ultima cosa l'ho sistemata e pare vada bene.

Vabbè io ci rinuncio!

@nick_10: potresti cercare di fare un po' più di attenzione quando qualcuno cerca di aiutarti
Comunque, mi sembra che sei arrivato abbastanza vicino alla soluzione e che ci stia provando. Ti mostro come l'avrei fatto io

Codice:

#include <stdio.h>
#include <stdbool.h>

bool ric()
{
    int n;
    scanf("%d", &n);
    if (n == 0)
        return true;
    else
    {
        if (n < 0)
            return !ric();
        else
            return ric();
    }
}

int main()
{
    if (ric() == true)
        printf("Prodotto positivo");
    else
        printf("Prodotto negativo");

    return 0;
}


Il file stdbool.h è parte dello standard C99, quindi dovresti poterlo usare senza problemi. All'atto pratico definisce delle macro per bool, true e false, niente di più.

Ok..
Ma cosa c'è che non va nell'ultima cosa che ho postato? E' per caso il fatto che uso una funzione con prototipo int...
e quindi restituirà un intero?