Newsgroup: it.politica
Titolo: A futura memoria...

)
------------
In ambito di ricerca, cosa che tu caro CICAP
non hai visto manco in fotografia, esistono un
mare di algoritmi che si possono sviluppare
***solo*** per mezzo della ricorsione.
Dimostrazione:
----------------------
Dato un programma ricorsivo, esiste un programma iterativo che
calcola la stessa funzione.
http://www.di.unito.it/~ronchi/didattica/FONDAMENTI/recursion.pdf
Si ringrazia lo studente Ampelio per aver regalato a questo NG una
delle piu'
grosse figure di merda di Pegasus che memoria umana possa ricordare.
Bye, bye...


Si vabbč, lo sborrone pegghy ne ha fatta un'altra delle sue.
Perň scusate, ci sono NG piů consoni a questi argomenti? Che so 
it.comp.os? Qualcuno ha paura di postare lě?
-- 
"Da parte mia non c'č mai stato sostengo all'evasione fiscale!"
http://www.youtube.com/watch?v=SfiO-n07FDQ

 
http://www.di.unito.it/~ronchi/didattica/FONDAMENTI/recursion.pdf
Si' vabe', si fa presto a prendere una frase ed ad estraniarla dal
discorso.
Pegaus parlava di diverso costo delle due strategie, cerchiamo di
semplificare in modo che anche tu possa capire.
Nessuno nega che tu possa andare da Milano a Roma a piedi, ma mi pare
piu' logico usare una macchina, il treno o un aereo.
Ora Pegasus ha detto una frase del tipo: "Ma sei matto ad andare a
Roma da Milano a piedi? Si puo' andare solo in treno o in aereo!!"
Lo sa benissiomo anche lui che si puo' andare a piedi, ma non ne vale
la pena!!
Questo era il senso del suo messaggio, mi pare, ti e' sfuggito?

>Questo era il senso del suo messaggio, mi pare, ti e' sfuggito?
Appunto.
Ma sai com'и... stanno esplorando in
questi giorni tutti i mezzi possibili ed
immaginabili per rigirartela come
vogliono.
Splendida anche la sparata di cicap
che mi "dimostra" che si puт usare
l'algoritmo di Dijkstra in modo iterativo...
e la dimostrazione sarebbe un pezzo
di codice in cui ad ogni ciclo si devono
controllare tutti i nodi successivi
del grafo (un pт inefficiente ma...
vabbииииииииии....)


Ho letto l'altro thread... a parer mio in realtà avete ragione (in 
parte) entrambi. Secondo me è sempre possibile "simulare" un 
comportamento ricorsivo con cicli come dice Cicap ma non è sempre la 
soluzione migliore proprio per la quantità di codice necessaria a 
simulare la ricorsione (quindi qui sono d'accordo con Pegasus).
Discorso inverso per l'implementazione di determinati algoritmi in 
linguaggi più ottimizzati per l'iterazione dove, ad esempio, la 
profondità della ricorsione è limitata perché in quel caso devi 
ovviamente prevedere codice per verificare se hai raggiunto il numero di 
iterazioni e, conseguentemente, aumentarlo (causando ovviamente 
overhead) o, ancora, dove le chiamate non sono propriamente veloci, tipo 
Java.


Mi trovi sostanzialmente d'accordo. T-student e' proprio un troll.

 vabbèèèèèèèèèè....)
ma sai di cosa parli????????? io credo di no :-)
Manco sai cose' l'algoritmo di dijkstra :-)
Una fra le decinaia di implementazioni dell' algoritmo
senza ricorsione, tanto per cambiare.....
Poi se la vuoi in C++/Phyton/Java... non hai che da cercare.
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
int allselected(int *selected)
{
     int i;
     for(i=0;i<MAX;i++){if(selected[i]==0){return 0;}}
     return 1;
}
void shortpath(int cost[][MAX],int *preced,int *distance)
{
    int selected[MAX]={0};
    int current=0,i,k,dc,smalldist,newdist;
    for(i=0;i<MAX;i++){ distance[i]=INFINITE;}
    selected[current]=1;
    distance[0]=0;
    current=0;
    while(!allselected(selected))
    {
        smalldist=INFINITE;
        dc=distance[current];
        for(i=0;i<MAX;i++)
        {
          if(selected[i]==0)
          {
             newdist=dc+cost[current][i];
             if(newdist<distance[i])
             {
                 distance[i]=newdist;
                 preced[i]=current;
             }
             if(distance[i]<smalldist)
             {
                smalldist=distance[i];
                k=i;
             }
         }
      }
     current=k;
     selected[current]=1;
    }
}
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

 ... Qualcuno ha paura di postare lì?
No, ci ho postato fino ad un mese fa (neanche). Ora non c'e'
nessuna discussione interessante.
Bye, bye...

 vabbèèèèèèèèèè....)
Inefficiente, ma non ricorsivo e dimostra la falsita' della
tua affermazione: hai bisogno dell'insegnante di sostegno
per capire che hai fatto una figura di merda?
Bye, bye...

 la tua affermazione
Come gia' detto, estraniando da un discorso una frase, si puo' fare
dire tutto a tutti.
Il senso non era difficile da capire e te lo avevo spiegato con
l'esempio di andare da Milano a Roma a piedi o in aereo.
Ma tu continui a trollare alla disperata.
HOP!

 dire tutto a tutti.
Cosa non hai capito del fatto che il periodo e' autocontenuto
(ovvero esprime un'affermazione vera, secondo il somaro alato,
indipendentemente dal resto del messaggio)?
Hai bisogno di un corso accelerato di italiano per legaioli?
Bye, bye...

 indipendentemente dal resto del messaggio)?
Che non e' cosi' solo perche' lo dici tu.
Hai scelto una frase eliminando il contesto in cui e' stat detta.
Facendo cosi' puoi fare dire tutto a tutti.
Sei un troll e anche di bassa qualita'.


>Sei un troll e anche di bassa qualita'.
Quoto.

 Quoto.
Quota pure stocazzo, ma spiegami cosa volevi dire. Ti ho
dato la possibilita' di arrampicarti sugli specchi: sfruttala.
Bye, bye...

 Hai scelto una frase eliminando il contesto in cui e' stat detta.
Rosicarda e' un cazzaro compulsivo.
Blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla
blablablablablablablablablablablablablablablablablablablablablablablablabla.
Indipendentemente dal resto del blabla, che tu sia un cazzaro
compulsivo
e' una verita' assoluta.
Bye, bye...

 Quoto.
Quoti cosa, imbecille? Se ti serve Rapisarda per sopravvivere sei
messo male, lasciatelo dire. Tu hai scritto un'affermazione che non
puoi in nessun modo rigirare:
========
esistono un mare di algoritmi che si possono sviluppare
***solo*** per mezzo della ricorsione.
========
Che è una balla colossale, e poi fai pure l'esempio di Dijkstra, che
normalemnte viene implementato e descritto attraverso algoritmi
iterativi. Poi ti inventi che il codice iterativo postato dal
sottoscritto non è efficiente. NEEEEEEEEE, peccato si parlasse
d'altro. Ma se anche fosse te ne ho postato un'altro, sempre
iterativo, esente da quel problema.
Quindi, se veramente pensi di avere minimamente ragione in quel thread
hai un grosso problema psicologico. Fatti curare il prima possibile.

 ha scritto nel messaggio 
news:3aed6165-07e4-4aca...@r10g2000vbc.googlegroups.com...


Bye, bye...
NESSUNA RISPOSTA, com'è OVVIO.
ROTFL!
C R E T I N O  FOREVER!!!

 simulare la ricorsione (quindi qui sono d'accordo con Pegasus).
Spiacente, la mia parte non corrisponde al vero. Riporto quanto detto
dal sottoscritto:
"La ricorsione è una tecnica estremamente elegante, ma certamente non
efficiente visto che fa uso massiccio delle chiamate a funzione"
Quindi quanto dici tu l'avevo già affermato io. Ora perchè mi sto
contrapponendo a piggy? Sempice, lui afferma che la ricorsione è una
tecnica più *efficiente* e non più elegante o che produce codice più
facile da mantenere. Quindi cerchiamo di non confondere le cose eh.
Inoltre si parlava di algoritmi ricorsivi che arrivano quasi o
totalmente ad esaurire lo stack. Ora ti chiedo, se ti trovi di fronte
ad una situazione del genere (a rischio di stack overflow) non sarebbe
forse il caso di pensare l'algoritmo diversamente?
E tanto per fugare ogni dubbio, ti dico che per lavoro mi trovo spesso
a lavorare su strutture ad albero non troppo profonde, e non mi faccio
alcuno scrupolo a usare la ricorsione.


ROTFL!
Urge creare IMMEDIATAMENTE una nuova sezione del Pegasus Fan Club:
PEGASUS e le sue fantasmagoriche FIGURE di MERDA!
http://groups.google.com/group/pegasus-fan-club/browse_thread/thread/a678f88d986beb1b
Link, suggerimenti, FIGURE di MERDA del passato del nostro CRETINO 
preferito,
sono sempre ben accette! 


Ma infatti è per quello che dico che, secondo me, avete una parte di 
ragione entrambi. Non è un discorso che si può fare in via teorica 
prescindendo dal linguaggio (e s.o.) usato.
In certi casi sicuramente sarebbe più opportuno ripensare l'algoritmo 
diversamente (es. se sto scrivendo codice in Python e so che la 
profondità della ricorsione è limitata per le mie esigenze o che il 
rischio di stack overflow è alto, piuttosto che chiamare "ad libitum" 
sys.setrecursionlimit con le ovvie ripercussioni (overhead) e rischi 
ripenso l'algoritmo con un'iterazione ma proprio perché è Python che mi 
invita ad un approccio diverso.
Diversamente se sto utilizzando un linguaggio funzionale puro forse 
l'iterazione è meno performante della ricorsione.

 sono sempre ben accette!
Questa non è niente male, ma quella sull' ASLR secondo me è la più
grossa che abbia mai fatto. Peccato sia difficile da riassumere...

>iterativo, esente da quel problema.
Veramente che tu me ne abbia postato un altro
non me lo ricordo. Mi deve essere sfuggito.
Continuo perň a farti la medesima domanda:
allocare dati in stack č piů veloce o meno
veloce che fare malloc()/free() ?
Vediamo come te la rigiri.

 Rosicarda e' un cazzaro compulsivo.
Ecco che, puntuale, quando non sai cosa rispondere, arriva l'insulto.

 wrote:
Però vedi... questa storia ci ha insegnato
che qui discutere è impossibile.
Adesso addirittura Vanacore ha scritto
un altro mex nel Pegasus fan club,
T-Stupid che interviene facendo finta
di non avere capito quello che volevo
dire, X05 a cui ripeto per 6 volte come
stanno le cose ed ancora continua a
fare finta di non capire, Bianchini che
viene a dire che non capisce il problema,
che è stato risolto 20 anni fa e quindi
Pegasus è un cretino, cicap che pretende
di farmi le pulci su ogni minimo errore,
mentre lui può scrivere tutte le cazzate
tecniche che vuole...
Questa storia ci ha dimostrato chiaramente
a quali livelli di malafede possono arrivare
queste persone.
Ed è inquietante.


http://groups.google.com/group/pegasus-fan-club/browse_thread/thread/a8d678737bc3806e/304928630a03c640#304928630a03c640
 

 Ed è inquietante.
Quoto!

 veloce che fare malloc()/free() ?
Non hai capito una mazza... e continui a non capire
una mazza....
a.

 stesse osservazioni che hai fatto qui.
Mai visto un essere vivente che piů di costui fosse l'esatta, precisa e 
calzante definizione
di "ipocrita fino al midollo"
Ancora complimenti al CRETINO di it.politica.
Ma che dico di it.politica?
Tutta usenet vorrebbe un CRETINO cosě, per fare mirabolanti palleggi!

 Ovviamente ai miei due precedenti inviti non hai risposto.
Pure io gliel'ho ricordato almeno dieci volte: se ha le palle e crede
veramente che il kernel linux sia buggato, e visto che non crede a
noi, che provi a riscrivere la stessa cosa su un NG adatto, magari
kernel.linux.
Inutile dire che non ha mai risposto.

 Vediamo come te la rigiri.
Vedi malloc sull'algoritmo c di Dijkstra?

 Vedi malloc sull'algoritmo c di Dijkstra?
Credevo all'inizio che questa epopea della programmazione fosse piu'
dovuta ad una tua pignoleria stramba (l'introduzione dell'ASRL nella
diatriba non e' stata una scelta felice, anzi mi ha portato a pensare
"guarda questo che tira fuori per avere ragione"), ma queste ultime
uscite di Pegasus sono dimostrazioni della sua mancanza totale di buon
senso, non e' questione di programmazione...
Ho l'impressione che il ciuco abbia grandi conoscenze informatiche
(piu' di quelle che ho io sicuro), ma gli manca la testa per saperle
usare.

 usare.
Gli manca la capacità di riassumere / centrare il punto. Questo è
effettivamente un problema non da poco.
Potrebbe cominciare ad allenarsi qui sul NG, ad esempio scrivendo post
leggibili con meno di 500 righe.

 it.comp.os? Qualcuno ha paura di postare lì
In effetti, prima di postare il suddetto teorema, avevo fatto notare
anch'io a Pegasus la stessa cosa.
Visto che la discussione - ampiamente OT - perdurava, ho sperato che
postando qualcosa di definitivo, la quetsione si chiudesse senza
ulteriori strascichi: mi sono sbaglato, evidentemente...
Purtroppo, a quanto pare, in certi casi neppure una dimostrazione
matematica è sufficiente a chiudere definitivamente certi deliri...
P:

>usare Linux con ASLR attivo.
cicap aveva assolutamente bisogno di trovare
qualcosa che gli giustificasse quell'aleatorio
sparato a vanvera per un buffer overflow.
Ed ha trovato l'ASLR che gli aggiunge
randomicità.
L'unico problemino è che ora stiamo vedendo
che sto comportamento non è tipico del C
come sosteneva il buon cicap, ma (se prima
c'è.. sotto Win7 devo ancora verificare con
Visual Studio), è un comportamento limitato
ad un numero ristretto di situazioni e sistemi
operativi, senza contare che in nessuna pubblicazione
abbiamo ancora visto parlare di randomizzazione
della size dello stack come feature.
(in un post su un forum di NetBSD se ne parla
come BUG).

 usare.
Più che altro gli manca la dignità... 


Penso che al momento il titolo di CRETINO di it.politica gli basti, come 
onorificenza ufficiale.
Non mettiamo altra carne a cuocere, Vegeta, Anna e Rhyne potrebbero 
rimanerci male... 

>essere riassuntivo, te ne prego)?
Supponiamo di avere una rete fatta in
questo modo.
Ci sono dei nodi di livello 0 (quelli di
livello più alto), che potremmo chiamare
I0,1 I0,2 I0,3 ... I0,n
Questi nodi di primo livello non sono
collegati direttamente tra loro come
in tutti i grafi, ma hanno una particolarità.
Tra il nodo di livello 0 I0,i e quello di
livello 0 I0,j c'è una sottorete che
li collega, composta da nodi di livello 1
(un livello più basso della gerarchia).
Segue che io posso spostarmi dal nodo
di livello 0 chiamato i a quello di livello 0
chiamato j, solo calcolando un cammino
più breve all'interno della sottorete i-j
composta da nodi di livello 1.
Ovviamente, ciascun ramo all'interno della
sottorete ha un suo costo di attraversamento.
Bene, il problema è quello di calcolare in modo
efficiente lo shortest path tra due nodi qualsiasi
di livello 0.
Ci sono 2 possibilità.
a) con l'algoritmo che conosci tu, tutta la gerarchia
va ignorata, ed i nodi si trattano tutti come se
fossero di livello 0. Siccome in questa situazione
i nodi possono essere decine di migliaia, ad
ogni iterazione devi lavorare su tutte le decine
di migliaia di nodi.
b) sfruttiamo la topologia gerarchica della rete.
Prima calcoliamo lo shortest path per tutte le
sottoreti che collegano il nodo di livello 0
chiamato i con il nodo di livello 0 chiamato j.
(quindi applichiamo n volte Dijkstra su
ciascuna sottorete di livello 1 per ogni coppia i,j
di livello 0 possibile).
Poi applichiamo nuovamente Dijkstra sui
singoli nodi di livello 0, in modo da determinare
lo shortest path TOTALE.
(In realtà le cose sono più complesse, il
Dijkstra di livello inferiore si fa solo quando
serve e non euristicamente per tutti i nodi
di livello superiore... ma qui voglio essere
sintetico come mi hai chiesto).
Bene, ora estendi il concetto, ed immaginati di
avere una rete con nodi ad n livelli di gerarchia.
Touchè...

 matematica è sufficiente a chiudere definitivamente certi deliri...
In genere si usa una cosa che si chiama "sedazione". 

 come BUG).
Quindi anche W7 è buggato. ROOOOOOOOOOOOOTFL!

>debba verificare su tutti il OS del mondo. E abbiamo trovato tutti i
Ma fammi il piacere.
A sentire te fino a qualche giorno fa sembrava
che fosse un concetto generale, proprio del
C, noto anche nei libri del 1980.
Qui invece abbiamo scoperto che è un effetto
collaterale di una implementazione di un
algoritmo di sicurezza su alcuni sistemi operativi
(e manco sulla maggioranza degli os).
E, soprattutto, non c'è una riga come una riga
di documentazione che abbiamo trovato che
giustifichi la randomizzazione della size dello
stack (che, ripeto, viola una mezza dozzina di
regole di buon senso e di buon funzionamento
di un sistema operativo).

 castoro :)
Ma no!
Lo sai che non ce ne eravamo proprio accorti? ;o) 

 Touchè...
Ti chiedo un info e tu rispondi touchè? Ma vai a cagare.

 di un sistema operativo).
Certo, Win7 è buggato? Rispondi se hai coglioni.

 leggibili con meno di 500 righe.
Che per l'appunto e' un problema di testa :)
La capacita' di riassunto e' anche una questione di intelligenza.

>parlare di comportamento casuale.
E certo che č cosě, lo vedrebbe un cieco.


Forse, in questo caso, sarebbe più appropriata una terapia elettro-
convulsivante, possibilmente ripetuta più volte...
P.

 grossa che abbia mai fatto.
Fidati, per uno che si vanta di "fare ricerca" (sempre che
il campo sia piu' ampio della ricerca dello stiperndio)
essere sputtanato da un teorema, non ha eguali: non e' da
tutti avere la dimostrazone matematica che si e' dei
tronfi cazzari, imbecilli fino al midollo. Il somaro alato
ha questa dimostrazione.
Bye, bye...

 un troll.
Senti... Partigiano di sta minkia, me lo dai il link alla
medaglia che ti avrebbe dato la Repubblica Italiana?
Bye, bye...

 Ed è inquietante.
Non molto inquietante, considerando i fatti pregressi.
Tieni presente che sia XVO5 che Cicap, danno il loro apporto
incondizionato a gente che usa insulto e somministrazione virtuale di
ricino ( = notizie sulla vita privata per nuocere agli interlocutori)
come unico mezzo di confronto con le voci scomode.
Non è inquietante, quindi, per chi queste cose le conosce e le ha
viste ormai da anni.
Ciò che risulta inquietante è che il resto di utenti del ng non
capisca bene lo svolgimento delle cose e che abbia bisogno di
ulteriori spiegazioni di comportamenti lampanti.

 Tieni presente che sia XVO5
Ehy cartomante, hai sbagliato a leggere nei fondi di
immondizia: Su I.P. non esiste nessun XVO5.
Cambia occhiali
Bye, bye...


E' proprio isso che pensi, invece
Come te, non merita alcuna forma di rispetto virtuale ( visto che,
come te,  favorisce stalker e violenza gratuita)

 convulsivante, possibilmente ripetuta piů volte...
Non funzionerebbe.
Casomai, bisognerebbe trapanare qualcosa di diverso del solito orifizio... 


http://www.youtube.com/watch?v=nc7Z5rAOEzk
 


Win 7 č buggato, svicolone compulsivo? 

>Ma fammi il piacere sto' cazzo.
[cite cicap]
I segmentation fault sono una bella rogna: possono saltar fuori come
anche no. Tutto dipende da come l'OS gestisce la memoria in quel
momento. Senza contare che se saltano fuori su una particolare
istruzione, in realtà il problema potrebbe stare in tutt'altra parte.
[/cite cicap]
Se tu avessi saputo come stavano davvero le
cose, avresti detto: in praticamente ogni sistema
operativo anche un segmentation fault avviene
in modo deterministico.
Salvo che... nel caso dei sistemi operativi dove
opera l'ASLR a causa della randomizzazione
dello stack.
Queste cose tu non le sapevi.
Semplicemente, per te programmando in C un
bel giorno può arrivarti il crash oppure no
su qualsiasi buffer overflow. Così, a caso.
La questione dell'ASLR l'hai tirata fuori
***dopo***.

 parlare di comportamento casutale.
E ti sbagli, perchè parti dal presupposto sbagliato. Infatti
inizialmente io parlavo di problemi legati alla programmazione con il
linguaggio C. Se non sbaglio parlavo di comportamenti imprevedibili e
difficoltà di debugging (un buffer overflow ad esempio può causare
errori in punti molto successivi).
Poi più avanti ho fatto delle prove sul mio OS. E il comportamento
risultava realmente di tipo aleatorio, e a mia insaputa era causato
dal'ASRL. A quel punto ho parlato anche di comportamento aleatorio
(mai detto però che si debba verificare su TUTTI i sistemi).
Quindi non ho MAI tirato fuori l'ASRL per giustificare delle mie
affermazioni, è l'esatto contrario.

 [/cite cicap]
Questa parte è assolutamente corretta. Inutile che ti attacchi ad
affermazioni corrette.
Puoi andare.
Non hai risposto: Windows 7 è buggato?

>Non hai risposto: Windows 7 è buggato?
Prima vedo il comportamento che dici tu,
poi studio se è come dici tu e poi ti rispondo.
Finora non abbiamo una riga come una
di documentazione che parli di stack
size randomizzata. E questo è un fatto.

>affermazioni, è l'esatto contrario.
Certo, cicap, ed io sono il presidente della
Repubblica Italiana.

 poi studio se è come dici tu e poi ti rispondo.
Cioè poi vedi come arrampicarti sugli specchi.

 ha scritto nel messaggionews:a7672a64-4c0d-4f53...@u26g2000yqu.googlegroups.com...

No tu sei un coglione, è lampante ormai.

>No tu sei un coglione, è lampante ormai.
No, cicap.
Qui malgrado tutte le tue sceneggiate
continue si è visto chiaramente chi
è il coglione. Ossia tu e sempre e
solo tu.
E ti assicuro che si è visto anche malgrado
l'intervento di tutti i tuoi vari amichetti e
tutte le commedie che hai fatto durante
tutte le discussioni.

 l'intervento di tutti i tuoi vari amichetti
ROTFL
(fatti curare)


La inserisco fra le rosicate? ;o) 

>(fatti curare)
Sì nel frattempo continua a credere che la
gente normale non veda nessun problema
di disonestà intellettuale in una
situazione così.
cicap, dieci giorni prima:
[cite cicap]
questo comportamento aleatorio è noto *a
tutti* i programmatori C
[/cite]
(A TUTTI eh....)
Ed eccoci alla situazione attuale, ossia:
- Il comportamento aleatorio *non c'è* **su tutti**
i Windows precedenti a Vista, compreso
Windows XP, 2000 per non parlare dei 9x;
- su Vista e 7 c'è solo abilitando esplicitamente
l'ASLR a compile time (quindi normalmente non c'è
manco lì, io nei miei programmi magari
non uso Visual Studio ma gcc, o se lo uso
l'ASLR non lo abilito),
- non c'è neanche su tutti i kernel
Linux che hanno l'ASLR disattivato
- non c'è neanche su Haiku, FreeBSD, QNX
e chissà cosa altro.
Ossia il comportamento aleatorio noto
"a tutti" (cicap dixit) i programmatori C non si
presenta nel 60-70% dei sistemi operativi nel
mondo.
Ma tutto normale... per carità....
la ragione ce l'hai tu....
(ma vai a quel paese)


Fai pure...questo "ti assicuro che gli altri sanno, vedono, ridono" lo
ripete ogni due per tre quando non sa più che pesci pigliare ;)

>ripete ogni due per tre quando non sa più che pesci pigliare ;)
Parla uno che ogni tre secondi fa sceneggiate
del tipo "Pegasus non capisce...", "Pegasus
non conosce la differenza...", naturalmente
infilandoci in mezzo quello che fa comodo a
te di volta in volta, nella speranza così che
chi segue non percepisca da che parte sta
la ragione (ossia dalla mia parte, per intenderci).
E di commedie così ne hai fatte per 10 giorni
di fila.

 wrote:
[cut]
Hey tapino, sei riuscito a trovare le palle per scrivere in un NG
attinente a Linux le stesse idiozie che continui a propinarci qua,
oppure continui a caccarti sulle braghe?

 Parla uno che ogni tre secondi fa sceneggiate
UEEEEEEEEEE gli altri mi attaccano, UEEEEEEEEEEE i tuoi amichetti 
intervengono UEEEEEEEEEEEEE i sinistri sono organizzati 
UEEEEEEEEEEEEEEEEEEEEEEEEE tutti mi danno del coglione 
UEEEEEEEEEEEEEEEEEEEEE UEEEEEEEEEEEEEEEEEE UEEEEEEEEEEEEEEEE 
UEEEEEEEEEEEEEEEEE UEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
BOOOOOM!

 Windows XP, 2000 per non parlare dei 9x;
Ti ho gia' parlato di un mio programma che crashava su una
macchina XP e sulle altre no? E che per debuggarlo e' stato
un bagno di sangue, te l'ho detto?
Non e' mica colpa di qualcuno se tu la tua macchina la usi
solo per vedere le foto di Anna nuda... Qualcun'altro usa
software un tantino piu' rognosi di powerpoint.
Bye, bye...
P.S. Ovviamente facendo le stesse operazioni, in modo da
     chiamare LO STESSO codice buggato, che sia chiaro
     fesso.


STRAROTFL!
..sta per piangere...
E mammina? Dov'è mammina?
"mammina dice che devo stare lontano dai comunisti, ecco!"  (semicit.) 


http://groups.google.com/group/pegasus-fan-club/browse_thread/thread/a8d678737bc3806e/13d7af11488e09fa#13d7af11488e09fa

 affermazioni, è l'esatto contrario.
Dovrei rileggermi il thread (non che ne abbia voglia), ma quando e'
venuta fuori sta storia mi era sembrata forzata. Per il resto della
discussione credo che in diversi situazioni ci sia uno scontro
abbastanza inutile.
Che Pegasus non sia capace di ammettere di aver detto inesattezze e'
palese e non fa che dimostrarlo, ma non capisco perche' tu continui a
rispondergli.
Saranno 500 messaggi che vi ripetete le stesse cose...

 Saranno 500 messaggi che vi ripetete le stesse cose...
----- Original Message ----- 
From: Andrea Vanacore
To: 
ab...@libero.it
Sent: Tuesday, July 27, 2010 11:25 AM
Subject: SPAM fastidioso e continuo su ng. non idoneo
Gentile Utente,
La ringraziamo per la Sua segnalazione.
La informiamo che stiamo prendendo i dovuti provvedimenti
nei confronti dell'utente segnalato.
Voglia accettare le nostre scuse per il disturbo arrecatoLe.
Cordiali Saluti
Abuse Staff
Wind Telecomunicazioni S.p.A
E-Mail: 
Ab...@libero.it
 

 avere un comportamento aleatorio.
[/cite cicap]
Quando persino X05 gli dice che è una
sciocchezza piuttosto grossa, guarda subito
come vola immediatamente a rigirartela:
[cite cicap]
Caro X05, secondo me tu non hai compreso un granché di quel thread,
visto soprattutto quanto scrivi sotto. Non sei stato l'unico ad onor
del vero, ed è pure normale vista la dimensione e confusione che si è
generata.
[/cite cicap]
(Cazzo doveva comprendere X05 ? Che lì c'è scritto che
nella pratica non sappiamo quando ci risponde
sqrt(x) perchè esiste il clock e la componente rumore ?
Quello c'è scritto lì e quello capisce chi legge.)
--------------------------------------------------
E dopo tutte queste trovate del caro cicap,
te ne esci tu con "ma è chiaro che è Pegasus
che non sa ammettere di avere detto delle
inesattezze, ma non capisco perchè cicap
continui a rispondergli".
Povero cicap... ti spara che una funzione deterministica
può darti un risultato random a causa del clock e
poi è Pegasus a dire le inesattezze.... sigh...
Ma per favore.
Ma nemmeno a Napoli...

 Questo è come inizia il flame
AHAHAHAH le solite cinquemila righe che nessuno leggerà mai.
Ma dicci buffone, hai scritto su un NG di kernel linux le fesserie che
continui a propinarci qua, oppure non hai i coglioni?

>AHAHAHAH le solite cinquemila righe che nessuno leggerą mai.
Ma vai a quel paese..

 Ma vai a quel paese..
Che fai scappi? Rispondi per una volta a questa:


>che continui a propinarci qua, oppure non hai i coglioni?"
Sì sì, dopo ci vado... e magari chiedo anche
su it.comp.lang.c della funzione deterministica
che non restituisce sempre un risultato preciso
("è solo una ovvietà teorica") perchè nella
pratica:
"siccome dipende dal
clock e da altri fattori esterni (secondo lo stesso Pegasus c'è anche
una componente rumore che introduce ulteriore randomicità) si può
avere un comportamento aleatorio."
(perla di cicap da tramandare ai posteri)
Per me la discussione si chiude qui.
Tanto ormai che sei un cretino si è
capito in tutto il NG.
Tu fai quello che vuoi.

 capito in tutto il NG.
Infatti questo in thread che si chiama "a futura memoria", parla delle
mie o delle tue cretinate?
ROTFL
Mi raccomando, facci sapere!

Pegasus :
[cut]
Ma quante volte occorre spiegartelo che nessuno caga post cosi' lunghi?
Oltre a non capire una sega, HAI SFRANTUMATO I COGLIONI!

 ha scritto nel messaggio news:rp.1658.ip@x05...

Anche perchè in presenza di post lunghi
ed argomentati, pieni di dati e di riscontri,
gli attivisti politici di sinistra di questo ng hanno
difficoltà a manipolare le carte in tavola,
ossia a fare l'unica cosa che sanno fare
nella vita.



Sbagli -almeno- due volte.
La prima nel non accettare che ti possano prendere per il culo ANCHE
soggetti che votano a destra. Non hai ancora capito che tifare per una
parte politica e' diverso dal dare SEMPRE ragione a chi tifa come te
(non dico "vota" perche' non sei al livello decisionale richiesto per
una votazione: tu entri nella cabina elettorale con la sciarpa nera e
la croce della Vandea al collo stantuffando una Vuvuzela con tutto il
fiato che hai nei polmoni, e' quasi certo).
La seconda nel non accettare il dato di fatto che post lunghi su
usenet NON vanno bene. E' una questione di medium (e dieci con questa
che te l'ho scritta): non puoi presentare "Heimat" ad un concorso per
cortometraggi in CG, o se lo fai accetti che alla seconda scena la
gente ti venga a cercare con il forcone e la torcia accesa,
inneggiando a Chthuluh e a sacrifici umani.
Giovanni
-- 
There is a party, everyone is there.
Everyone will leave at exactly the same time.
When this party's over it will start again.
It will not be any different, it will be exactly the same.
Heaven, Talking Heads

 Ma nemmeno a Napoli...
No, CRETINO.
In effetti, mai visto un FROCETTO MALATO di MENTE come te.
Nemmeno a Napoli 

 l'iterazione è meno performante della ricorsione.
Solo per curiosità, a quali linguaggi stai pensando? Di linugaggi
funzionali non ne conosco molti, ma mi viene in mente come spesso
esprimono i cicli for:
[1..10].foreach(f);
non credo che si possa dire che è meno performante di una ricorsione,
in ogni caso.

 continui a propinarci qua, oppure non hai i coglioni?
Scommetto 1000 euro che no, non l'ha fatto.
Chissà perchè, eh? :-) 

 Tu fai quello che vuoi.
"Conclusione: it.politica, se lo conosci lo eviti, se
 lo conosci non ti uccide."
Pegasus, CRETINO ufficiale di it.politica 2009,
Pasqua 2010 


Gentile Utente,


 soggetti che votano a destra. Non hai ancora capito che tifare per una
Solito giochetto:
- cancelliamo il discorso fatto
- cancelliamo perchè Pegasus lo ha fatto
- ribaltiamo la realtà contro Pegasus
- siccome Pegasus per difendersi argomenta
sempre in modo precisissimo quello che
succede, ovviamente i suoi mex si allungano
(deve fare i cite cicap per impedirgli di
cambiare le carte in tavola come vuole,
deve dare i link per giustificare quello
che egli dice, deve mettere i cite perchè
sennò il cretino di sinistra di turno fa
finta di leggere la cosa sbagliata nella
pagina, deve contestare le cazzate punto
per punto, deve impedire che il suo
pensiero venga manipolato e mistificato
da tutte le parti... ovvio che poi i messaggi
si allungano, mica è colpa mia).
Che facciamo allora ? Semplice, invitiamo
Pegasus a scrivere meno, così cicap e gli
altri possono manipolare ancora meglio.
Giovanni, vaffanculo.
Grazie.
(te la sei cercata)

 nella vita.
* * * * * *
Io su it.politica parlavo spesso di questionirelative a tecnologia,
ricerca scientifica,
economia (rapporto inflazione/disoccupazione,curva di Phillips)..
E guardate dove siamo arrivati. Roba da manicomio.
Io penso di avere capito il perchè, sotto sotto sotto, è accaduto
tutto questo.
La questione è semplicissima: la persona di sinistra è convinta, ipso
facto, di essere
"la kultura". Qualcuno gli ha insegnato che solo perchè si dichiara di
sinistra lei sa
tutto. Lei è acculturata.
Ora, io, in tanti anni di frequentazione del NG, ho visto cosa
producono tutti questi
uomini "di kultura" che sarebbero i sinistri di it.politica:
- c'è Kanzlerei che ciancia di umanisti atei che sarebbero quelli che
si sono liberati
dalle pastoie della religione (arriva Pegasus che cita Lorenzo Valla,
e Coluccio Salutati,
e si scopre che il sinistro di turno aveva copiato la definizione da
un sito inglese
che si riferiva ad un movimento, gli umanisti, nato in Inghilterra nel
1800. Risultato: il
sinistro vorrebbe cianciare degli umanisti italiani, e poi si scopre
che manco sa come
si chiamano, o quando sono vissuti, figurati averli letti).
Pegasus, ingrato e sconoscente, gli va a rompere le uova nel panaro...
- c'è il sinistro che dice che il nucleare èuna scelta sbagliata
perchè ci sono i costi
di arricchimento. Arriva Pegasus, ingrato e sconoscente, e cita i
reattori CANDU
(il sinistro manco sa che esistono i CANDU, perchè lui è la Kultura
no ?). kanzlerei allora
si produsse in una discussione con me in cui rigirò la frittata ben
CINQUE volte
per coprire il fatto che si potevano usare i CANDU (alla fine, tra le
tante perle, ilCanada
sarebbe uno stato canaglia, perchè quel pochissimo trizio che si
ottiene nel
moderatore del reattore, potrebbe essere usato per la bomba H
(ROFTL)).
- c'è il sinistro che è convinto che la disoccupazione sia una
conseguenza di
Berlusconi (e di chi sennò ?). Arriva Pegasus, ingrato e sconoscente,
e si mette a parlare
di grafici della curva di Phillips, inflazione e disoccupazione,
politica monetaria della
BCE, shock asimmetrici non compensati (tutto corretto tralaltro,
guardate ciò che
succede in Grecia adesso...). Ed i poveri sinistri restano a
guardare...
- c'è il sinistro che si scambia pacche sulle spalle con altri
sinistri, sul fatto che
i Vangeli furono inventati chissà quando, diciamo nel 200 d.C. o giù
di lì, che i
dogmi furono inventati a Nicea (questo era Ernesto).
Ancora Pegasus, ingrato e sconoscente, inizia a citare passi delle
lettere di
Ignazio di Antiochia, morto nel 107 d.C.,dove già si parla di
verginità della Madonna,
di Spirito Santo, di un solo Dio in tre persone, e dove ci sono
migliaia di
citazioni letterali dei Vangeli di Matteo e Giovanni.
Non solo: cita i papiri Magdalen e Rylands, il papiro 7Q5, la tesi
Carmignac e della
scuola di Madrid.
Cosa dobbiamo concludere ?
* * * * *
CHE SEI UN CRETINO!

 Sol
http://groups.google.com/group/pegasus-fan-club/browse_thread/thread/a8d678737bc3806e/13d7af11488e09fa#13d7af11488e09fa
 

>impossibile.
Certo.
Infatti i malloc() sono ad overhead nullo.
(roftl)

 
http://groups.google.com/group/pegasus-fan-club/browse_thread/thread/a8d678737bc3806e/13d7af11488e09fa#13d7af11488e09fa
Ecco bravo Andrea, mettici anche
un bel vaffanculo contro di te da parte
mia nel Pegasus fan club.

 ha scritto nel messaggionews:38c6b16f-dcf0-49fa...@f6g2000yqa.googlegroups.com...

Vedi malloc sugli algoritmi di Dijkstra che ti sono stati postati?
Vuoi la rivincita eh!
AHAHAHAHAHAH


Pirla perche diavolo dovresti usare delle malloc?
Se l' algoritmo ricorsivo non richiede malloc
non le richiedera' neanche l' equivalente iterativo.
Ma ci sei o ci fai?
ABC

>Vuoi la rivincita eh!
Due domande, a te che sei un grande
esperto:
a) me lo implementi senza le malloc un
Dijkstra ricorsivo su più livelli di
gerarchia ?
b) presente il problema dell'uscita
dell'uomo da un labirinto ? me lo
implementi con le iterazioni senza
malloc/free ?
Grazie.
(ora prende un altro calcio in faccia)


Certo... come no.
Me lo implementi il problema dell'uscita
dell'uomo dal labirinto senza le malloc ?
Ah... tu **non sai** quanto al massimo può
essere lungo il percorso. Importante.
Allora: me lo implementi ?

 (ora prende un altro calcio in faccia)
Ma davvero? Dove?

 essere lungo il percorso. Importante.
Come no? Se è lungo 100 mila nodi, il tuo algoritmo ricorsivo funziona
secondo te?

>riusarla durante l'algoritmo?
Ceeeeeeeeeeeeeeeeeeertooooooooooo
Basta solo sapere quanti sono gli
elementi di iterazione che possono
essere al massimo coinvolti
**A PRIORI** (cioè prima
di eseguire l'algoritmo...)
MANNAGGIA: Questo in generale
noi non lo sappiamo però....
Ma sicuramente Too-stupido ha
un teorema anche per questo...

 in ogni caso.
Mi restituite i miei soldi sudati in fabbrica per piacere?
Così mi tolgo dai coglioni.

 mia nel Pegasus fan club.
HOP! HOP! HOP!
"E questa è la quarta persona che sarà
 processata al Tribunale di Messina
 per diffamazione ed ingiurie."
HOP, CRETINO, HOP! 

 Allora: me lo implementi ?
La ricorsione consuma lo stack come un castoro rosica il legno
(metafora non casuale). Diventa piu' affidabile usare il malloc in un
ciclo almeno l'unico limite e' dato dalla capacita' del sistema di
fornire memoria ad un processo, invece la lunghezza dello stack non
puo' essere modificata run-time.
IMHO se si puo' evitare la ricorsione e' meglio, l'ammetterei solo se
si sa in anticipo che la ricorsione sara' di pochi "cicli".

 di eseguire l'algoritmo...)
Ti faccio una domanda. Da una struttura dati che contiene le
informazioni globali del tipo:
nodi.push(nodo);
cosa ti aspetti che succeda sul HEAP in corrisponde di
quell'operazione?

>puo' essere modificata run-time.
E questo è corretto.
C'è però un problema: malloc diventa onerosa
quando si tratta di allocare un numero molto
grande di piccoli blocchi di memoria (tantovero
che si usano memory manager speciali in
quel caso come il Varangozov Memory
Manager).
C'è un esempio devastante di questo problema:
si chiama Python. (Se volete vi spiego come
fare la prova, così ve ne rendete conto da voi)
Quindi, ragionando:
a) allocare in stack non costa nessun ciclo macchina,
e quindi è molto più veloce. Alla fine l'algoritmo
ne guadagna in velocità
b) allocare ogni stato precedente del sistema (si veda
il problema dell'uomo che deve uscire dal labirinto)
con una malloc ad ogni iterazione (alla fine avrai una
pila in memoria, che ti simula lo stack), ti permette di
usare tutta la memoria ram a tua disposizione (siamo
d'accordo, è pacifico), ma purtroppo è più lento a
causa dell'overhead dovuto a malloc()/free().
Questo è un problema che io ho affrontato varie
volte tralaltro: sui sistemi embedded si sente
notevolmente.
Segue che, se si vuole la velocità, conviene allocare in
stack (dunque ricorsione). Se si vuole un numero di
iterazioni pari a tutto quello che consente la memoria
disponibile si alloca invece con malloc ma si
perdono prestazioni.
Pertanto, chi è dunque più veloce ? :)

 notevolmente.
Pegasus dixit: "perchè non hai mai programmato su
sistemi embedded, dove lo stack è poco"
ROTFL! Allora pirlasus, ma ti ci hai programmato o no? Perchè qua ti
stai contraddicendo alla grande.

 nella vita.
Pocca mado' quanto sei duro!
SONO DI DESTRA, te l'avro' scritto 70 volte. Ma neanche cose cosi' 
semplici ti entrano nella zucca?

>stai contraddicendo alla grande.
Mi sto chiedendo a quale livello di cretineria
possa arrivare tu. Ogni giorno superi un nuovo
livello.
Sì, lo stack è poco (la quantità la stabilisci
tu, ma sono centinaia di kb, non Mb), ma
malgrado questo tu ti implementi degli
algoritmi ricorsivi che usano bene quel
poco stack che hai e che coniugano il
problema di avere la velocità su un
processore a 300 Mhz ed il problema
di gestire il tutto su 64 kb di stack.
Lo sanno fare i programmatori che fanno
ricerca su sistemi embedded (tu non fai
testo, ovviamente).

 Grazie.
Quoto di cuore :))

 ha scritto nel messaggio 
news:2d014e67-3c47-4671...@q22g2000yqm.googlegroups.com...

Quando ce vò... ce vò...

 o
Sei troppo cretino per essere di sinistra.
E per parlare con me.

 ebbe l'ardire di scrivere:

Al massimo puoi "cuotare" da culo, as usual.
Angelis, quando non ci capisci un cazzo (spesso) taci.
Giovanni
-- 
"We have a better-than-zero chance of
successfully intercepting, I believe,
an inbound warhead."
Gen. Obering, US Army. 

 ebbe l'ardire di scrivere:

Ma smettila, bimbetto viziato, che diventi cieco.


 di gestire il tutto su 64 kb di stack.
Perchè invece non ammetti che tutto dipende dalla taglia del problema
e la finisci di arrampicarti sugli specchi?

>più efficiente, ma molto più complicato da programmare.
[/cite cicap]
In C, eseguire una malloc significa caricarsi
l'overhead di eseguire del codice per sapere
se va eseguito sbrk() o meno (in alcuni sistemi
potrebbe essere necessario, in certi casi,
persino un context switch eseguito dall'sbrk() ).
Una funzione che richiama sè stessa, invece,
ha quasi zero overhead:
- salvataggio registri in stack
- long call
- aggiornamento SP per creare lo spazio per
le variabili locali
Stop.
Segue che, salvo casi particolarissimi, la ricorsione
è più veloce dell'iterazione, non più lenta.
Hai detto l'ennesima fesseria.
Stop.

 Stop.
ROTFL
1. un algoritmo con ciclo non deve per forza usare malloc
2. se anche serve malloc, può usare preallocazioni e buffering per
ridurre ***drasticamente*** il numero di malloc
3. tu hai fatto immani figure di merda, dichiarando che ci sono
algoritmi fattibili solo ricorsivamente e per giunta facendo due
precisi esempi: Dijkstra e PyrSegmentation.
4. sei stato smerdato su Dijkstra
5. hai risposto "sul il pyrSegmentation non dite nulla"?
6. sei stato smerdato ANCHE sul pyrSegmentation
7. forse è il caso che sparisci

 le variabili locali
x 2 ovviamente.

>7. forse č il caso che sparisci
yawn....
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.143.4148&rep=rep1&type=pdf
[cite]
During this stage, the image volume is split up into
eight partitions recursively based on an octree
structure. The root of the octree corresponds to the
whole image volume and each node of the octree
represents a partition of the image volume. We define
the initial image volume to be composed of 2 " x 2 " ~ 2 ~
vosels where tti < n. In each level except level 0, the
volume of the partition of the corresponding node is
1/8 of that of its father. That is, in level L, the
partitions are of dimension 2nZx2n-Lx2m-L.
Let xP={ XNWF, XNEF, XSWF. XSEF. XNWB,
X N ~ B , XsWB and XSEB ) denotes the set of
partitions of a volume X and XV be the texture feature
vector of a partition X. The following pseudo code
describes the recursive splitting process.
Initially, x represents the whole image
volume.
Splitting-test( x )
{
if (3xi exP I 8(X7, xV) > H )
{
s is split up into eight partitions;
Vxi exP, do **Splitting-test( xi )**;
}
else return;
}
where F denotes the Euclidean distance function
and H is a threshold value. The calculation of the
testure feature vector is shown in the nest section.
Through this process, the three dimensional image
is split into eight partitions recursively until no more
heterogeneous texture partition is detected. The
calculation of testure features is described in the
following section
[/cite]
O ancora:
http://www.cvc.uab.es/icdar2009/papers/3725a833.pdf
Paragrafo Steerable Pyramids, pag. 2
ROFTL
[cite]
The recursive (pyramid) coonstruction of a
pyramid is achieved by inserting a copy of the shaded
portion of the diagram at the location of the solid
circle
[/cite]
Ora esco. Per gli altri punti ti prendo a
calci dopo....
Pegasus prende la mira
GOAAAAAAAAAAAAAAAAAAALLLLLL 

 Pegasus prende la mira
E prende un calcione in culo dal compagno di squadra, il quale gli fa
notare che la porta sta dall'altra parte del campo.

>più efficiente, ma molto più complicato da programmare.
[/cite]
Nel linguaggio C (in Java potrebbe essere differente,
per via dell'execution trace che viene mantenuto,
ma in C è assolutamente così), una chiamata a
funzione ***è*** assolutamente ***poco costosa***.
Non **molto** costosa come sostieni tu.
**Poco** costosa, capito ?
E la medesima situazione c'è anche in C++ e credo
in Delphi.

[..]
Ma se la ricorsione e'  piu' efficiente, che senso ha la TCO?

 funzione ***è*** assolutamente ***poco costosa***.
Non è così. La chiamata a funzione è un'operazione relativamente
onerosa, sicuramente più onerosa di un iterazione in un ciclo while.
E' lampante sull'esempio fattoriale.
Il fattoriale ha una caratteristica: tante iterazioni (o chiamate
ricorsive) e una moltiplicazione piu' un if nel corpo della funzione.
All'opposto ci sta un problema che richiede poche iterazioni e un
corpo di funzione costoso.
Nel primo caso è assolutamente vietato usare la ricorsione, nel
secondo se viene comodo è assolutamente consigliato. Solo che nel
secondo caso non è più un problema di performance, ma di mantenibilità
del codice.

>corpo di funzione costoso.
Il caso fattoriale è fuorviante perchè lì la
ricorsione non ha bisogno di memorizzare
gli stati passati del sistema.
Siccome gli stati passati del sistema sarebbero
0,1,2,3,4,5..n, e noi già lo sappiamo a priori, lì
la ricorsione diventa solo un problema di
eleganza e noi possiamo benissimo
sostituirla con l'iterazione. Ecco perchè
tu puoi fare:
fact=1;
int t;
for (t=1; t<=n; t++)
{
    fact = fact*t;
}
Ossia, una iterazione che non ha bisogno di malloc/free.
In questo caso l'iterazione può essere più veloce,
specie se mettiamo un register davanti a quel fact.
Quando invece abbiamo la necessità di salvare la
storia precedente del sistema, questo discorso si
ribalta.
Prendiamo il caso dell'algoritmo dell'uomo che deve
uscire dal labirinto. Lì, quando l'uomo si infila in
un vicolo cieco, ha bisogno di tornare sui suoi
passi. Quindi, "da qualche parte" deve essere
memorizzata la sequenza di passi che sono stati
fatti, in modo da potere tornare indietro. Ed ecco
di nuovo comparire il discorso che facevamo:
o salvi in stack, o salvi in heap e ti carichi
l'overhead di malloc e free.

 Angelis, quando non ci capisci un cazzo (spesso) taci.
Sono qui che aspetto il tuo intervento risolutore, tranquillo.

Sono qui che aspetto il tuo intervento risolutore, tranquillo.
Gia' fatto, ma te come sempre non capendoci un cazzo l'hai rivoluta
stiacciare.
Oh, adesso non andar a dire che era Nutella: abbi almeno questo
barlume di dignita'.


 calcola la stessa funzione.
Il fatto che "esista" non significa ne che sia sempre possibile
"trovarlo" ne che sia umanamente possibile implementarlo,
Cretino.

 Dai... sparisci con queste ovvietà del cazzo.
Lo capisco ... ce l' hai con me perche' ogni volta che t' azzardi
a scrivere qualcosa di tuo, dimostro platealmente e
incontrovertibilmente la tua estrema poverta' mentale.
Ma e' un problema tuo, non mio.


Uffa però... io, un povero destro non
acculturato, devo sostenere la finale dei
mondiali con un super esperto
informatico del calibro di CICAP....
... e voi amici miei non venite a fare
neanche un pò di tifo sugli spalti....
Uffa... non è giusto però....
:)))))))))))))))))))))))))))))))

 Uffa... non è giusto però....
Be', giochi da cani ed hai gia' incassato 5 o 6 pappine.
Se permetti anche il piu' accanito dei tifosi avrebbe abbandonato gli 
spalti gia' da un pezzo.
Tu pero' continua, non t'avvilire.


Tu come osservatore non fai testo,
perchè hai il distorsore ottico
incorporato...

 incorporato...
Non hai la credibilita' sufficiente per essere portatore di opinioni 
oltre la tua.
Hai scritto una tale quantita' di amenita' da far rabbrividire un 
programmatore alle prime armi. Non vale neanche la pena entrare in 
discussioni tecniche con te.
Le sciocchezze che hai scritto le hai esposte maldestramente e in 
assoluta incapacita' di sintesi mischiando concetti che tra loro non 
avevano collegamento.
Nel tentativo di parlare di cose che sai hai messo a nudo soprattutto 
cio' che NON sai.
Una prece.

 wrote:

Tu hai capito l'innovazione tecnicale. Bravo!

 neanche un pò di tifo sugli spalti....
Assieme a Radicale, ti bacio il culo anche io! 
;-))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

 informatico del calibro di CICAP....
Leggimi bene, per favore (mi sembra che t' ho
sempre consigliato bene, no ?) :
1)
Cicap e' bravo, ed ammetterlo non puo' farti che
salire di punteggio. Anche se ovviamente nessuno
te lo dira' apertamente (tranne me) ma stai tranquillo
che ne prenderanno atto. Cicap piu' di tutti.
(non e' cattivo, ha cuore, e' preparato, ha i suoi limiti
come tutti, non e' stupido. Damme retta io lo so.)
Prima regola : dare a Cesare quel che e' di Cesare,
o piu' volgarmente : si voi magna', devi fa' magna'.
Quindi : cercate di sforzarvi di capire ognuno il punto
di vista dell' altro. Ne rimarrete entusiasti entrambi.
2)
Non hai bisogno del mio aiuto e cmq mi pare che
te ne dia, no ? Ma attenzione : solo perche' son
d' accordo con te. Altrimenti nisba. Io non do' ragione
a prescindere. Io non faccio il tifo per NESSUNO.
3)
non badare a X05. Ti darebbe torto pure se dicessi che
1 + 1 = 2. Lo fa apposta. Si diverte cosi' ... E' un' anima
semplice alla fin fine.

 ;-))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
ECCOLO !
Non mi ricordo mai il tuo nick !
Il mio fantastico, adorabile, oggettivo, intelligente
e pure simpatico zero-alpha - zero ! :D
Dovresti farti vedere piu' spesso. Difficilmente
(anzi, mai) non ho imparato qualcosa leggendoti.

 Tu hai capito l'innovazione tecnicale. Bravo!
Basta conoscere qualche fondamento di matematica.
(e avere un po', manco tanta, di intelligenza)
In quel campo, se ne trovano di continuo di problemi
simili. La matematica e' maestra, perche' ti costringe
a ragionare in un modo che altrimenti te lo sogni.
No ?
Comunque dimmi di piu', sono curioso, lo sai.

 ha scritto nel messaggio 
news:1jmhv7p.oeas1f1jgxxs9N%alessard...@gmail.com...



Come dice vossia...
yawn... 

 ha scritto nel messaggio 
news:6ab6ef28-d657-46f6...@z10g2000yqb.googlegroups.com...

Quoto.

 yawn...
Questa evitala, e' da bambini.
Ultimi consigli: non fare piu' post chilometrici e non affrontare 
discussioni troppo tecniche su ng non appropriati.
Anche se ti sembro un nemico, non lo sono affatto.

 ha scritto nel messaggionews:8b181091-4b4a-4bf3...@j8g2000yqd.googlegroups.com...

Tra mallc(1) e malloc(100) non cambia null
Invece se la mem è paginata.
Non ci sono problemi a riscrivere iterativamente
Senza malloc gli alg.che hai postato.
Se lu trovi espressi su dei paper come ricorsivi
È perché sono più compatti, ed è più semplice
Mostrarne certe proprietà... Banalmente che terminino.

 Giovanni
Tu affermi sia nutella, quella che bazzichi, e ti turi il naso 10
volte su dieci.
Io no.

 l'overhead di malloc e free.
Di questo abbiamo già parlato sopra.
Però ragionandoci, ti devo dare ragione quando affermi che la
ricorsione in C è piuttosto performante. A mio avviso *non* è comunque
più performante dell'iterazione.
Ho fatto qualche prova con la visita di alberi n-ari. Ebbene, la
ricorsione risulta efficiente, ma un buon algoritmo iterativo
programmato con le ottimizzazioni del caso riesce a battere
l'algoritmo ricorsivo. E ricordati che per iterare c'è bisogno di una
struttura stack che mantega delle informazioni.
Il problema più grosso della ricorsione rimane la limitatezza dello
stack. A proposito, se la rendo unlimited con il comand "ulimit", ho
notato che puoi usare stack a gogo, ma l'algoritmo ricorsivo risulta
spesso più lento di quello iterativo. Immagino che sia dovuto
all'overhead introdotto sull'OS da una massiccio uso della memoria
stack (nuove pagine da assegnare, eccetera) che con l'algotirmo
iteativo non c'è. Quindi ha senso solo per un uso "sano" dello stack.
Se l'algoritmo non ti consente questo, allora è conveniente andare di
iterazione.