Calcolo fattoriale in C\C++

[DirtyDeeds]

Per chiudere: il programma è valido solo in C, non in C++, perché il C++ probisce la chiamata ricorsiva della funzione main. Se si compila il programma con g++ con l'opzione "pedantic", questa è la risposta:

Codice: Seleziona tutto

>g++ -pedantic fact.c
fact.c: In function 'int main(int, char**)':
fact.c:3:49: warning: ISO C++ forbids taking address of function '::main' [-Wpedantic]


Il funzionamento del programma è il seguente: il numero di argomenti passati nella riga di comando definisce il numero di cui si vuole calcolare il fattoriale. Alla chiamata, argc == n+1, perché argc conta tra gli argomenti anche la stringa del comando.

Quindi, se argc == 1 o argc == 2, vuol dire che si vuole il fattoriale di 0 o di 1 e il programma ritorna 1. Se argc > 2, allora il valore di ritorno diventa:

Codice: Seleziona tutto

n*main(n,0)

da confrontarsi con

Codice: Seleziona tutto

n*fatt(n-1)

del programma in [11]. Il motivo per cui main va richiamata con argomento pari a n è perché vogliamo argc == n+1.

Alla fine della ricorsione, il valore del fattoriale è ritornato nel codice di uscita. Sotto Windows, tale codice viene memorizzato nella variabile d'ambiente errorlevel, che può quindi essere interrogata con

Codice: Seleziona tutto

echo %errorlevel%

Così, poi, capisce anche il linguaggio naturale:

Codice: Seleziona tutto

>fact calcolami il fattoriale di cinque
>echo %errorlevel%
120

[PietroBaima]

Signori... dal fattoriale alla intellegenza artificiale

(come sempre grande DirtyDeeds )

[DirtyDeeds]

Stamattina mi sono svegliato con questa versione in testa:

Codice: Seleziona tutto

int main(int argc, char *argv[])
{
    return argc < 2 ? -1 : **(argv+1)-'0' < 2 ? 1 : ((**(argv+1))---'0')*main(2,argv);
}


Peccato funzioni solo tra 0 e 9 (ma forse ho già in mente come modificarla perché accetti qualunque valore, sempre in una riga ).

[TardoFreak]

Great TF

ci stiamo avvicinando al ioccc

Sono riuscito a recuperarlo. Mi ha sempre affascinato perché il BASIC è stato il primissimo linguaggio che ho imparato (escluse le calcolatrici programmabili) ma non ho mai avuto tempo/voglia di fare le sostituzioni.
Per chi avesse voglia di perderci un po' di tempo questo è il sorgente.
Si inzia con il sostituire tutti gli "R" con "999", i "_" con "return" e via dicendo.

Codice: Seleziona tutto

#define O(b,f,u,s,c,a)b(){int o=f();switch(*p++){X u:_ o s b();X c:_ o a b();default:p--;_ o;}}
#define t(e,d,_,C)X e:f=fopen(B+d,_);C;fclose(f)
#define U(y,z)while(p=Q(s,y))*p++=z,*p=' '
#define N for(i=0;i<11*R;i++)m[i]&&
#define I "%d %s\n",i,m[i]
#define X ;break;case
#define _ return
#define R 999
typedef char*A;int*C,E[R],L[R],M[R],P[R],l,i,j;char B[R],F[2];A m[12*R],malloc
(),p,q,x,y,z,s,d,f,fopen();A Q(s,o)A s,o;{for(x=s;*x;x++){for(y=x,z=o;*z&&*y==
*z;y++)z++;if(z>o&&!*z)_ x;}_   0;}main(){m[11*R]="E";while(puts("Ok"),gets(B)
)switch(*B){X'R':C=E;l=1;for(i=0;i<R;P[i++]=0);while(l){while(!(s=m[l]))l++;if
(!Q(s,"\"")){U("<>",'#');U("<=",'$');U(">=",'!');}d=B;while(*F=*s){*s=='"'&&j
++;if(j&1||!Q(" \t",F))*d++=*s;s++;}*d--=j=0;if(B[1]!='=')switch(*B){X'E':l=-1
X'R':B[2]!='M'&&(l=*--C)X'I':B[1]=='N'?gets(p=B),P[*d]=S():(*(q=Q(B,"TH"))=0,p
=B+2,S()&&(p=q+4,l=S()-1))X'P':B[5]=='"'?*d=0,puts(B+6):(p=B+5,printf("%d\n",S
()))X'G':p=B+4,B[2]=='S'&&(*C++=l,p++),l=S()-1 X'F':*(q=Q(B,"TO"))=0;p=B+5;P[i
=B[3]]=S();p=q+2;M[i]=S();L[i]=l X'N':++P[*d]<=M[*d]&&(l=L[*d]);}else p=B+2,P[
*B]=S();l++;}X'L':N printf(I)X'N':N free(m[i]),m[i]=0   X'B':_ 0 t('S',5,"w",N
fprintf(f,I))t('O',4,"r",while(fgets(B,R,f))(*Q(B,"\n")=0,G()))X 0:default:G()
;}_ 0;}G(){l=atoi(B);m[l]&&free(m[l]);(p=Q(B," "))?strcpy(m[l]=malloc(strlen(p
)),p+1):(m[l]=0,0);}O(S,J,'=',==,'#',!=)O(J,K,'<',<,'>',>)O(K,V,'$',<=,'!',>=)
O(V,W,'+',+,'-',-)O(W,Y,'*',*,'/',/)Y(){int o;_*p=='-'?p++,-Y():*p>='0'&&*p<=
'9'?strtol(p,&p,0):*p=='('?p++,o=S(),p++,o:P[*p++];}

Io vi saluto perché oggi, giusto per rimanere in tema, mi aspetta un' intensa giornata di programmazione in C al solo scopo di guadagnarmi da vivere, quindi niente di poetico.

[carloc]

A me ha colpito questo codice

Codice: Seleziona tutto

main(int riguing,char**acters){puts(1[acters-~!(*(int*)1[acters]%4796%275%riguing)]);}

che da solo (il programma è tutto lì) "riconosce"il partito di appartenenza degli ultimi 31 presidenti USA

che in se non sarebbe niente di che, ma dove è la tabella?

Edit: link era errato, corretto!

[DirtyDeeds]

che in se non sarebbe niente di che, ma dove è la tabella?

devi scrivergliela nella riga di comando

[carloc]

mmm mi pare che quello che devi scrivere sia il nome del presidente e i nomi dei due partiti, nel senso proprio di due etichette da visualizzare. La tabella invece dovrebbe essere compresa...

[DirtyDeeds]

La tabella invece dovrebbe essere compresa...

No, direi proprio di no. Credo che il trucco stia in questo. Partiamo da

Codice: Seleziona tutto

1[acters]

questa equivale a

Codice: Seleziona tutto

acters[1]

che è un puntatore al primo argomento inserito nella riga di comando. Questo puntatore viene convertito a un puntatore ad intero .Il risultato della conversione può dipendere dal tipo di interi, numero di byte e forma little endian o big endian, ma se si assume una certa architettura, ogni presidente darà un numero.

Dopo di che, questo numero viene preso e ci vengono fatti sopra dei conti. Il punto cruciale dovrebbe essere la divisione con resto per 4796 e 275. Probabilmente l'autore si è fatto una tabella di questo genere:

Pres1 int1 R
Pres2 int2 D
Pres3 int3 R
...

e poi ha ricavato una formuletta che gli desse come risultato 0 o 1 a seconda della corrispondenza intero indice del partito.

Alla fine viene stampata la stringa corrispondente a

Codice: Seleziona tutto

acters[1-risultato]

dove risultato è il risultato dei conti, che dovrebbe essere negativo (-1 o -2) perché c'è una complementazione.

Insomma, volendo veramente capire il codice bisognerebbe sbattersi per farsi la tabella di conversione da presidente a intero (basta anche un programmino), però l'idea dovrebbe essere quella.

[carloc]

... Dopo di che, questo numero viene preso e ci vengono fatti sopra dei conti. Il punto cruciale dovrebbe essere la divisione con resto...

...Insomma, volendo veramente capire il codice bisognerebbe sbattersi per farsi la tabella di conversione da presidente a intero (basta anche un programmino), però l'idea dovrebbe essere quella.

Si si un po' "a senso" intendevo quello con "tabella compresa" anche se l'equivalenza

Codice: Seleziona tutto

1[x]=x[1]

mi era ignota e non mi lasciava capire i dettagli della cosa

[DirtyDeeds]

anche se l'equivalenza

Codice: Seleziona tutto

1[x]=x[1]

mi era ignota e non mi lasciava capire i dettagli della cosa

Codice: Seleziona tutto

a[b]

è sempre equivalente a

Codice: Seleziona tutto

*(a+b)

Tra l'altro questa equivalenza viene usata due volte apposta per offuscare il codice. Per renderlo più chiaro, potremmo riscriverlo così:

Codice: Seleziona tutto

main(int argc, char *argv[])
{
   int id = *((int*)argv[1]);
   puts(argv[1-~!(id%4796%275%argc)]);
}