[C] Codice che calcola ricorsivamente l'n-esimo numero di Fibonacci usando un processo separato per ogni chiamata

Qwert999

Nuovo Utente
9
0
ciao a tutti questo è il mio codice che calcola il numero di fibonacci passato come argomento dal terminale ....


C:
#include <stdio.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <dirent.h>
#include <stdarg.h>
#include<string.h>

    int fibonacci(int i) {   
        
        if (i < 0) return -1; /* F(i) non e' definito per interi i negativi! */

      if (i == 0) return 0;   else if (i == 1) return 1;
        
        else return fibonacci(i-1) + fibonacci(i-2);
        }


    int main(int argc, char *argv[]) {

                int a= atoi(argv[1]);
               // int a= argv[1]-0;
                printf("Calcolo fibonacci di %d \n", a);
                printf("L' %so numero di Fibonacci e' %d.\n", argv[1],fibonacci(a));


          }
Qualcuno potrebbe aiutarmi a scrivere il codice usando per ogni chiamata un processo distinto ?
 

Qwert999

Nuovo Utente
9
0
ahahah scusami non credevo potesse arrivare a grandi complessità , comunque considerando che ho iniziato ad approcciare ora questi argomenti mi basta un programmino di facile comprensione senza arrivare a strafare chissacosa sennò ci capirei ben poco
 

BrutPitt

Utente Attivo
299
300
Invece fa parecchia differenza. Tra pipe, memoria condivisa, redirezionamento dell'I/O, file temporanei, socket, i livelli di difficoltà cambiano parecchio.
Personalmente penso che sia un semplice esercizio sull'utilizzo del fork... credo che gli basterebbe utilizzare il valore numerico della funzione come valore di uscita del processo... e da li' calcolare il numero di fibonacci

Brevemente:
Invece di utilizzare il return, per (i-1) e (i-2) creare due processi con fork che chiamino la funzione (recursivamente) e terminino con quei valori... la somma dei valori di uscita (similmente a come stai facendo adesso col valore di ritorno) ti da il numero di fibonacci.
 
Ultima modifica:

BrutPitt

Utente Attivo
299
300
potreste mostrarmi un esempio sul codice che ho fatto ?
Un esempio significherebbe fare l'esercizio, perche' e' moto semplice... :)
Ti sei guardato fork? (e' necessario che tu lo faccia)

Provo comunque a darti un instradamento:

C:
            pid_t pidA = fork(); // chiami fork

            if (pidA == 0) // per quel processo
            {
                fibonacci(i-1);
                exit(i-1);
            }
Stessa cosa per i-2
A quel punto, devi "recuperare" i valori di ritorno dei due processi... ed utilizzare la somma come valore di uscita exit() dei processi ricorsivi.... ed invece "ritornare" (return) dalla funzione (sempre con la somma del valore restituito dai processi) nel caso tu sia in presenza processo principale (ossia quello del main()).
 

Andretti60

Utente Èlite
3,944
2,665
Scusa ma non capisco, non esiste un “numero di Fibonacci”, Fibonacci è una serie di numeri.

a riguardo avere una chiamata per “processo”: i processi sono solo in Unix, in Windows la cosa più vicina sono i Thread. Che comunque entrambi sono complessi da usare, e rischiosi da implementare se non si hanno idee chiare.
 
  • Mi piace
Reactions: BrutPitt

BrutPitt

Utente Attivo
299
300
Concordo con te... ma temo che sia il classico esercizio impregnato su determinati e vincolanti argomenti.
In questo caso ricorsione e fork (almeno cosi' ho interpretato, parlando esplicitamente di processo e non di thread) abbinati alla successione di Fibonacci.
 
Ultima modifica:

pabloski

Utente Èlite
2,468
658
redo che gli basterebbe utilizzare il valore numerico della funzione come valore di uscita del processo... e da li' calcolare il numero di fibonacci
Il motivo per cui non l'ho considerato come soluzione, è che, almeno su Linux, il valore di ritorno viene arrotondato a 8 bit. E c'è il problema che questo comportamento è dipendente dall'ABI, per cui non si può essere sicuri che il programma si comporterà alla stesso modo ovunque.
 
Ultima modifica:
  • Mi piace
Reactions: BrutPitt

BrutPitt

Utente Attivo
299
300
Hai ragione, ci stavo pensando stamattina... che il procedimento e' valido al massimo per i=14 (ossia per un ritorno inferiore agli 8 bit).
 

Andretti60

Utente Èlite
3,944
2,665
Hai ragione, ci stavo pensando stamattina... che il procedimento e' valido al massimo per i=14 (ossia per un ritorno inferiore agli 8 bit).
Uh?
Il massimo numero su 8 bit è 255 (senza segno)
Post automaticamente unito:

Scusate ma un fork() all’interno di una funziona ricorsiva non funzionerà mai...
 

Qwert999

Nuovo Utente
9
0
Ho provato a farlo...Così credo dovrebbe andar bene...Utilizzo a ogni chiamata un processo distinto giusto ?
ps considerate 'n' compreso tra 0 e 10

C:
#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include<sys/wait.h>


size_t fibonacci( size_t n )
{
 pid_t pid1, pid2;
 size_t fib;
 int status;

 switch ( n )
 {
  case 0:  return 0;
  case 1: 
  case 2:  return 1;
  default: break;
 }

 pid1 = fork();

 if ( pid1 == 0 ) exit( fibonacci( n - 1 ));
 else if ( pid1 < 0 ) {
 printf("ERRORE");
 exit(EXIT_FAILURE);
}

 pid2 = fork();

 if ( pid2 == 0 ) exit( fibonacci( n - 2 ));
 else if ( pid2 < 0 ) {
 printf("ERRORE");
 exit(EXIT_FAILURE);
}
 if ( waitpid( pid1, &status, 0 ) == -1 ) {
   printf("ERRORE");
 exit(EXIT_FAILURE);}

 fib = WEXITSTATUS( status );

 if ( waitpid( pid2, &status, 0 ) == -1 ) {
 printf("ERRORE");
 exit(EXIT_FAILURE);}

 return fib + WEXITSTATUS( status );
}







int main(int argc, char *argv[])
{
  
            int a= atoi(argv[1]);
            printf("Calcolo fibonacci di %d \n", a);
            printf("L' %so numero di Fibonacci e' %d.\n", argv[1],fibonacci(a));
  
                  
      }
 

Entra

oppure Accedi utilizzando

Discussioni Simili