Fattoriale

[Oromis92]

sfida (semplice!):
scrivere un programma che calcoli il fattoriale (o una buona approssimazione)
senza usare algoritmi ricorsivi XD

ecco la mia soluzione
[ot]

#!/usr/bin/perl
$pi = 3.141592653589793238;
$e = 2.718281828459045235;

sub fatt {
$num = shift;
if ($num<0) {
print "Only positive and intere numbers!\n\n";
} else {
$num = int($num);

if($num==0) {print "$num! = 1\n\n"}
else {$aaa = ((sqrt(2*$pi*$num))*(($num/$e)**$num)); print "$num! ~$aaa\n\n"}
}
}

print "please insert number: ";
$num = <>;
&fatt($num);

[/ot]

con questo metodo riesco a calcolare fino al fattoriale di 170...

 

[kr1pn0$]

ecco il mio in ruby

###########################
#     Calcola il fattoriale di un numero            #
#                                       by kr1pn0$            #
###########################
def fattoriale n
    if n==0 
      1
    else
      return n*fattoriale(n-1)
    end
end
puts "Inserisci un numero: "
numero = gets.chomp.to_i
puts fattoriale(numero)
fine = gets

[ot]usando la stessa tecnica di oromis[/ot]

 

[imported_opocaj]

Con un for è ricorsivo? Nel caso no ecco qui:
[Python]

#!/usr/bin/python
num=int(raw_input("Inserisci il numero di cui trovare il fattoriale: "))
global fatt
fatt=1
for i in xrange (1, num+1):
    fatt*=i
print fatt

 

[Oromis92]

No, così non è ricorsivo, anche se con numeri molto grandi impiega un' eternità xD
kripnos: io ho usato l'approssimazione di Sterling, che non calcola il numero esatto, ma una sua buona approssimazione.

per ricorsivo intendevo:

n! = 1 se n=0
n! = n*((n-1)!) se n>0

ovviamente il fattoriale si usa solo con numeri interi positivi e 0

 

[kr1pn0$]

appunto....

 

[Eijin]

Questo il mio in python, spero non sia ricorsivo così ò.ò

a=input("Inserisci il numero")
conta=range(a)
for i in conta:
    if i==0:
        a=a
    else:
        a=a*i
print a

 

[Oromis92]

No che non è ricorsivo. Diventa ricorsivo quando usi una funzione che chiama se stessa

 

[imported_ShuraBozz]

non se se avete un concetto di ricorsione, certamente basato sulle funzioni...
Ecco il mio senza ricorsione in C
[OT]

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define PI 3.141592653589793238
#define E 2.718281828459045235

float fattoriale(int num);

main()
{
      int fat;
      printf("Inserisci il numero di cui calcorare il fattoriale\n");
      scanf("%d",&fat);
      fat=(int)fat;
      if(fat<0)
          printf("Attenzione non %c possibile calcolare il fattoriale di un numero negativo\n",138);
      else
          printf("Il fattoriale del numero %d %c all'incirca %f\n",fat,138,fattoriale(fat));
      system("pause");
}

float fattoriale(int num){
    if(num>1){
        return (sqrt(2*PI*num)*pow(num/E,num));
    }
    else if(num==0 || num==1){return 1;}
}

[/OT]

Per farvi un esempio di ricorsione invece con poche modifiche si può ottenere questo:
[OT]

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int fattoriale(int num);

main()
{
      int fat;
      printf("Inserisci il numero di cui calcorare il fattoriale\n");
      scanf("%d",&fat);
      fat=(int)fat;
      if(fat<0)
          printf("Attenzione non %c possibile calcolare il fattoriale di un numero negativo\n",138);
      else
          printf("Il fattoriale del numero %d %c all'incirca %d\n",fat,138,fattoriale(fat));
      system("pause");
}

int fattoriale(int num){
    if(num>1){
        return num*fattoriale(num-1);
    }
    else if(num==0 || num==1){return 1;}
}

[/OT]

 

[Eijin]

Ah ok, ma allora era abbastanza facilotto l'esercizio

 

[imported_ShuraBozz]

sinceramente non era la difficoltà quanto il calcolo che era particolare sta volta, poi tu l'hai fatto col for ma è lento, anche se secondo me visto ciò che avete detto sarebbe più difficile farlo con la ricorsione

PS: krip perchè hai cambiato il tuo esercizio?

 

[Oromis92]

Infatti... Adesso krip l'ha fatto ricorsivo