Newsgroup: it.comp.lang.c++
Titolo: fattoriale

Vorrei scrivere un programmino in C per calcolare il fattoriale di un
numero
utilizzando una funzione ricorsiva.
Ho provato ma non ci riesco, potete darmi una mano?
Mario

In questo newsgroup sei fuori argomento, prova su it.comp.lang.c .
Ciao,
Nicola

 Nicola
esiste una specifica funzione C++ per calcolare un fattoriale? non so qualcosa di molto complesso basato su classi, template ecc...?
è così tanto grave chiedere una cosa del genere su questo ng?
bah....
x Mario:
ecco _un_ modo:
int fatt(int n)
{
  return((n)? fatt(n-1) : 1);
}
ciao
xaero

 ha scritto nel messaggio news:3AC9EC44...@divalsim.it...


 bah....
A me era parso che la domanda fosse relativa al linguaggio C. Per questo OT.
Anche se la risposta in C e in C++ e' praticamente la stessa.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 Anche se la risposta in C e in C++ e' praticamente la stessa.
il motivo della mia risposta č che non si tratttava di un OT cosě grave...
anche se Mario ha detto 'devo fare un prg in C', la vera domanda č come calcolare il fattoriale.
allora se avesse scritto 'come si calcola il fattoriale?' nessuno avrebbe detto che č OT....

 wrote in message
news:9af212$4npke$1...@ID-51253.news.dfncis.de...

Ni. In realta' un algoritmo come quello e' talmente banale (e non direttamente
C++) che chiedere semplicemente "come si fa" e' quasi OT.
Lui diceva di aver provato senza riuscirci. L'ideale sarebbe stato chiedergli:
posta i tuoi tentativi e dicci cosa e' che ti suona strano (l'avrei fatto se non
fosse che sto seguendo il NG a spizziconi di tempo e quando ho visto il suo post
c'era gia' un intero thread!). In questo modo gli avresti insegnato il C++.
Dandogli la soluzione stile "pappa pronta" non hai fatto altro che "fargli i
compiti". E per questo esiste il CEPU.


 wrote in message 3AC9E7D2...@libero.it...

Ma tutta la discussione che avete fatto sul presunto Ot non e' Ot anch'essa
?

Allora il fattoriale di -6 è 1?
Ciao 	 
-- 
Posted from 
smtp3.libero.it
 [193.70.192.53] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Allora il fattoriale di -6 č 1?
non capisco se č una domanda ironica o no; cmq il x! č definito solo
per x appartenente ad N, quindi -6! non esiste.
Anto
--
Antonio Cuni, 18 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

 per x appartenente ad N, quindi -6! non esiste.
 
appunto. chiama la f. postata con n = -6 e vedi...

 appunto. chiama la f. postata con n = -6 e vedi...
#include <stdexcept>
template <class T>
T fatt( T n )
{
    if ( n<1 )
        throw domain_error("factorial is defined in N only");
    if ( n == 1 )
        return 1;
    T r = fatt(n-1);
    T f = n*r;
    if ( (f/n) == r )
        return f;
    throw overflow_error("factorial requires larger type");
}
--


 }
a voler essere kattivi e' giusto calcolare fatt(4.67)? oppure 
fatt('~')? o di un complex?

 
http://www.brainbench.com/transcript.jsp?pid=1301688
-- 
--
Luigi

 wrote in message news:1795061.b...@tin.it...

Per quanto riguarda fatt('~') direi di si! Almeno tanto quanto ha senso
calcolare '~'+'!'.
Ma a voler essere ancora piu' cattivi, mancavano gli std::
#include <stdexcept>
#include <cmath>
template <class T> bool inN( T n )
{
    return false;
}
template <>
bool inN<int>( int n )
{
    return n>0;
}
template <>
bool inN<unsigned int>( unsigned int n )
{
    return n>0;
}
template <>
bool inN<long>( long n )
{
    return n>0;
}
template <>
bool inN<unsigned long>( unsigned long n )
{
    return n>0;
}
template <>
bool inN<double>( double n )
{
    return n>0 && std::fmod(n,1.0)==0.0;
}
template <class T>
T fatt( T n )
{
    if ( !inN( n ) )
        throw std::domain_error("factorial is defined in N only");
    if ( n == 1 )
        return 1;
    T r = fatt(n-1);
    T f = n*r;
    if ( (f/n) == r )
        return f;
    throw std::overflow_error("factorial requires larger type");


calcolare '~'+'!'.
[OT, ma forse interessa a qualcuno]
Il fattoriale di un numero e' calcolabile come integrale
con la formula
          /+inf  n  -y
   F(n) = |     y  e   dy
          /0
(
per gli amanti di \LaTeX
  \begin{equation}
    F(x) = \int_{0}^{\infty}y^{x}e^{-y}dy
  \end{equation}
)
Con questa formula F(n)=n! per tutti i numeri interi non
negativi e la formula e' applicabile a tutti i numeri reali
positivi. A questa formula e' legata la importante funzione
Gamma di Eulero che e' definita come
             /+inf   x-1  -y
  Gamma(x) = |     y     e   dy
             /0
(
per gli amanti di \LaTeX
  \begin{equation}
    \Gamma(x) = \int_{0}^{\infty}y^{x-1}e^{-y}dy
  \end{equation}
)
Ovviamente Gamma(n)=F(n-1)=(n-1)! per tutti gli n interi non
minori di 1. Giusto per fare un esempio di fattoriale
"frazionario" si trova che Gamma(0.5) = sqrt(PI) che equivale
a dire che il fattoriale di 1.5 e' la radice di 3.141592654...
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

           /0
... snip spiegazioni e funzione gamma
Ricordavo di averlo letto da qualche parte, ma non avevo voglia di andare a
cercare le reference per citarlo.
Comunque ... benvenuta una funzione C++ che calcola la funzione gamma (e di
conseguenza il wrapper per i fattoriali reali) :-)


         return 1;
Anche qui non prevedi il caso 0! (che e' definito come 1) :-)
--
Leo-Panda
email: 
leo-...@libero.it
ICQ#: 105550412

A questo punto:
#(0 1 2 3 10 20 500) do:
 [ :each |
 Transcript
  show: each printString;
  show: '! = ';
  show: each factorial printString;
  cr]
nella finestra di trascript ottieni (gli acapo per il 500! li ho messi io a
mano):
0! = 1
1! = 1
2! = 2
3! = 6
10! = 3628800
20! = 2432902008176640000
50! = 30414093201713378043612608166064768844377641568960512000000000000
500! = 12201368259911100687012387854230469262535743428031928421924135883
858453731538819976054964475022032818630136164771482035841633787220781772
004807852051593292854779075719393306037729608590862704291745478824249127
263443056701732707694610628023104526442188787894657547771498634943677810
376442740338273653974713864778784954384895955375379904232410612713269843
277457155463099772027810145610811883737095310163563244329870295638966289
116589747695720879269288712817800702651745077684107196243903943225364226
052349458501299185715012487069615681416253590566934238130088562492468915
641267756544818865065938479517753608940057452389403357984763639449053130
623237490664450488246650759467358620746379251842004593696929810222639719
525971909452178233317569345815085523328207628200234026269078983424517120
062077146409794561161276291459512372299133401695523638509428855920187274
337951730145863575708283557801587354327688886801203998823847021514676054
454076635359841744304801289383138968816394874696588175045069263653381750
554781286400000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000
Un unico problema: non e' C++!
Ma dato che vogliamo essere cattivi potremmo anche dire che per calcolare il
fattoriale non conviene usare il C++!!!!


 wrote in message
9akcat$e2s$1...@e3k.asi.ansaldo.it...


#include <iostream>
using namespace std;
int fattoriale(int num);
int main()
{
     int num=10;
     cout<<"fattoriale di 10: ";
     int Res=fattoriale(num);
     cout<<Res<<endl;
     return 0;
}
int fattoriale(int num)
{
     int nRes;
     if(num==1) return 1;
     nRes=fattoriale(num-1)*num;
     return nRes;
}
Ciao Ciao