algoritmi

[eafkuor]

Se non vi dispiace volevo postare un mio lavoro sugli algoritmi (e' un po' lunghino).
Fatemi sapere
Ciao

-----------------------
Il bello di essere intelligente e' che puoi divertirti a fare l' imbecille, ma se sei un imbecille non puoi fare il contrario.
Woody Allen

[Admin]

Non ci dispiace, magari dacci in anticipo una breve sintesi. Così chi dalla sintesi pensa che il tema gli interessi può leggersi tutto il resto.

Antonio Bernardo

[gattomatto]

Ciao eafkuor,
quanto scrivi mi incuriosisce. Piacerebbe anche a me avere qualche dettaglio in più.

Caspita, leggo che hai solo 15 anni! Le mie capacità programmatorie quando avevo la tua età consistevano nel bullarmi con i miei amici dei risultati di un listato del genere:

Codice:

10 PRINT"CIAO!"
20 GOTO 10


Ehe he! Mi sa che sei il terrore dei tuoi professori

Ciao Ciao

[Highrender]

Ciao eafkuor,

e bentornati a tutti anche in questa sezione del forum.
Anche per me non ci sono problemi, penso sarebbe interessante sapere cosa hai trattato nel tuo lavoro sugli algoritmi.

Highrender

"La miglior battaglia è quella che vinciamo senza combattere" - (Sun Tsu)

[eafkuor]

Ok lo posto

Riassunto: In questo lavoro vengono descritti ed analizzati gli algoritmi di ricerca e ordinamento maggiormente utilizzati in programmazione. Il linguaggio usato per implementare questi algoritmi e' il c, ma ovviamente chiunque puo' tradurre questi algoritmi in un altro linguaggio. Vengono inoltre descritte brevemente le principali strutture dati, ma eventuali implementazioni vengono lasciate al lettore.

Nel prossimo post c'e' l' articolo completo.

P.S. La parte sulle strutture dati praticamente non c'e' [:D]



-----------------------
Il bello di essere intelligente e' che puoi divertirti a fare l' imbecille, ma se sei un imbecille non puoi fare il contrario.
Woody Allen

[eafkuor]

p.p.s non e' un lavoro molto originale ma non ne avevo trovati altri in italiano cosi' ho pensato di scriverne uno mio, dato che avevo una certa esperienza (si fa per dire) sull' argomento.




ALGORITMI E STRUTTURE DATI
by eafkuor

SOMMARIO

- Disclaimer
- Introduzione
- Bibliografia

* PARTE 1 - ALGORITMI
· Definizione di Algoritmo e Introduzione
- ALGORITMI DI ORDINAMENTO
· Introduzione
· Bubble Sort
· Ordinamento per Selezione
· Ordinamento per Inserimento
· Shell Sort
· Quick Sort
· Conclusioni
- ALGORITMI DI RICERCA
· Ricerca Sequenziale
· Ricerca Binaria

* PARTE 2 - STRUTTURE DI DATI
· Introduzione
· Le Code
· Gli Stack
· Le Liste Concatenate

· Conclusioni finali





- Disclaimer

Io, eafkuor, l' autore, pubblico questo testo al solo scopo
informativo e didattico. NON mi ritengo responsabile di eventuali
danni causati a cose o persone dall' utilizzo delle tecniche
qui descritte.



- Introduzione

Questo lavoro ha lo scopo di aiutare i "profani" a familiarizzare con
gli algoritmi e le strutture di dati che maggiormente vengono usate
oggigiorno in programmazione. Le nozioni apprese con la lettura di
questo testo potranno essere ampliate e approfondite dal lettore
stesso. Ritengo inoltre che queste informazioni siano molto utili
per lo sviluppo delle applicazioni piu' disparate da parte del
lettore. Gli algoritmi e le strutture di dati sono i soli e unici
componenti dei programmi: i dati memorizzati ordinatamente vengono
elaborati dagli algoritmi definiti dal programmatore.



- Bibliografia

"Linguaggio C terza edizione" di Herbert Schildt, McGrawHill

Mi sento di ringraziare Paola Bertolazzi che mi ha stimolato
nello studio degli argomenti oggetto di questo testo.



***PARTE 1 - ALGORITMI***

· Definizione di Algoritmo

Un algoritmo non e' altro che una sequenza di istruzioni adatte a
risolvere un problema nel suo caso generale. Un algoritmo deve
essere in grado di risolvere un solo tipo di problema, con qualche
piccola variazione (a questo servono le strutture decisionali come la
arcinota if/else), in cui l' unica cosa che cambiano sono i dati.
Facciamo un esempio, definendo l' algoritmo per calcolare l' area di
un triangolo sapendo la base e l' altezza. L' algoritmo sara':

area=base*altezza/2;

semplicemente. Possiamo vedere che risolve un solo tipo di problema
e che funziona anche se i dati (base e altezza) cambiano, dando
ovviamente risultati differenti. Ma la procedura non cambia. Il metodo
di risoluzione rimane lo stesso. Una delle piccole variazioni di cui
vi parlavo prima potrebbe essere(supponendo che ad inserire i dati sia
l' utente):

if(!base || !altezza){ //Prima controllo i dati
printf("Inserire dei valori diversi da zero\n");
exit(0);
}
area=base*altezza/2; //Poi li faccio elaborare all' algoritmo

Come vedete la variazione ha l' effetto di bloccare il processo di
risoluzione del problema (in alcuni casi), ma altre volte queste
variazioni possono solo modificare una parte dell' algoritmo in modo
da permettergli di proseguire senza problemi. Per esempio:

//Qui viene preso l' input dall' utente...
if(!base) base=10;
if(!altezza) altezza=5;
area=base*altezza/2;

Qui invece di bloccare l' algoritmo i due if servono a modificare i dati
nel caso sia necessario farlo. Se l' utente inserisce dei valori adatti
per la base e l' altezza bene, altrimenti vengono cambiati con quelli di
default.
In ultima analisi un algoritmo non e' altro che un metodo, una sequenza
di istruzioni, una procedura per risolvere un tipo di problema.



- ALGORITMI DI ORDINAMENTO


· Introduzione

Esistono fondamentalmente tre tipi di algoritmi di ordinamento: per
scambio, per selezione e per inserimento. Analizzeremo tutte e tre
queste categorie, sebbene il quick sort, senza dubbio il miglior
algoritmo in generale, sia un algoritmo di scambio. E' utile conoscere
anche gli altri algoritmi perche' in situazioni particolari possono
rivelarsi migliori del quick sort. Per analizzare un algoritmo di
ordinamento a grosse linee bisogna prendere in considerazione tre
fattori:

1 La velocita' nel caso generale
2 La velocita' nel caso migliore/peggiore
3 L' esibizione di un comportamento generale

Un algoritmo puo' comportarsi bene in un caso generale (come il quick
sort) ma le sue prestazioni possono degenerare quando ha a che fare con
dei casi particolari. Quando un algoritmo lavora di meno su array gia'
quasi ordinati e di piu' su array poco ordinati, si dice che ha un
comportamento naturale.



· Bubble sort

Che bel nome vero? Peccato che il Bubble Sort sia uno dei peggiori
algoritmi mai concepiti. Si tratta di un algoritmo di scambio (proprio
come il quick sort). Ad ogni ciclo interno vengono effettuati dei
confronti e se necessario i due elementi adiacenti vengono scambiati di
posto. Ecco un semplice codice che implementa il Bubble Sort:

void bs(int array[], int count){

int a, b, temp;

for(a=1;a<count;++a) //Il ciclo esterno viene ripetuto count-1 volte
for(b=count-1;b>=a;--b){ //Ogni volta l' array viene scansionato
if(array[b-1]>array[b]){ //Confronta i due elementi
temp=array[b-1]; /*qui i due elementi*/
array[b-1]=array[b];/*vengono scambiati*/
array[b]=temp; /*con l' ausilio di temp*/
}
}

}

I due argomenti dell funzione bs() sono l' array da ordinare (array)
il numero di elementi contenuti in array (count). E' necessario
eseguire la scansione dell' array count-1. Quindi se dopo un certo
numero di scansioni l' array sara' gia' ordinato verranno eseguite
tutte le altre inutilmente. Sarebbe utile inserire una ulteriore
variabile di controllo, in modo da terminare il procedimento in caso
l' array sia gia' ordinato(e che quindi non sia avvenuto nessuno
scambio) prima della fine delle scansioni. Basta modificare il codice
come segue:

void bs(int array[], int count){

int a, b, temp, controllo=0;

for(a=1;a<count;++a)
for(b=count-1;b>=a;--b){
if(array[b-1]>array[b]){
controllo=1;
temp=array[b-1];
array[b-1]=array[b];
array[b]=temp;
}
if(!controllo)return; //non e' avvenuto nessuno scambio
else controllo=0;
}

}


In questo modo pero' si introducono ulteriori operazioni ad ogni ciclo.
Prendendo in considerazione la versione non migliorata, sia n il numero
degli elementi dell' array, il numero dei confronti e' sempre:

1/2(n^2-n)

Il ciclo esterno viene eseguito infatti (n-1) volte, e il ciclo interno
in media (n/2) volte, quindi moltiplicando(le parentesi sono messe per
comodita'):

(n-1)(n/2)=(n^2)/2-(n/2)=(n^2-n)/2
che equivale a
1/2(n^2-n)


Quel n^2 ci deve preoccupare; vuol dire che il numero di confronti
aumenta dell' ordine ^2 all' aumentare di n (numero di elementi).
Si dice quindi che la complessita' computazionale in tempo e' n*n,
trascurando 1/2 e il -n, semplicemente perche' l' ordine di grandezza
e' di n^2. Per chi ama la matematica, se n e' il numero di elementi,
la complessita' computazionale in tempo Ct sara':

Ct=n^2

Ovviamente piu' la complessita' computazionale e' alta e piu' tempo ci
vuole per ordinare l' array, comunque il tempo impiegato e' diverso per
ogni processore, quindi serve introdurre il concetto di complessita'
computazionale



· Ordinamento per Selezione

A mio avviso questo tipo di algoritmo non e' molto superiore al Bubble
Sort, infatti il numero di confronti e' sempre 1/2(n^2-n). L' unica
differenza e' che in media il numero di scambi e' inferiore. Il
funzionamento e' molto semplice: inizialmento viene selezionato il
valore piu' basso, che viene scambiato con il primo valore. Poi
viene selezionato il valore piu' basso tra i rimanenti, che viene
scambiato con il secondo, e cosi' via... Eccone una semplice
implementazione.

void sl(int array[], int count){ //Gli argomenti sono gli stessi

int a, b, c, controllo, temp;

for(a=0;a<count-1;++a){
controllo=0;
c=a;
temp=array[a];
for(b=a+1;b<count;++b){
if(array[b]<temp){
c=b;
temp=array[b];
controllo=1;
}
}
if(controllo){
array[c]=array[a];
array[a]=temp;
}

}

}



· Ordinamento per Inserimento

Finalmente qui vediamo qualche piccolo miglioramento. Il numero di
confronti puo' variare da n-1 a n^2, a seconda dell' ordinamento
iniziale dell' array. Quindi e' un algoritmo che esibisce un
comportamento naturale. Questo algoritmo e' eccezionale quindi se gia'
sappiamo che l' array sara' gia' quasi ordinato. Il suo funzionamento
e' questo:
prima di tutto ordina i primi due elementi, poi prende il terzo e lo
mette in una posizione corretta rispetto agli altri due. Poi prende il
quarto e lo posiziona correttamente rispetto agli altri tre, e cosi'
via fino ad aver ordinato tutto l' array. Ecco il codice:

void is(int array[], int count){

int a, b, temp;

for(a=1;a<count;++a){
temp=array[a];
for(b=a-1;(b>=0)&&(temp<array[b]);b--)
array[b+1]=array[b];
array[b+1]=temp;
}

}

In questo caso la complessita' computazionale in tempo e'
n-1<=Ct<=n^2
e varia a seconda dell' ordine iniziale.



· Shell Sort

Finalmente arriviamo ad un algoritmo molto piu' efficiente dei
precedenti. Il suo funzionamento e' facile da comprendere, ma non e'
facile capire perche' riesca sempre ad ordinare degli array.
Si confrontano prima di tutto gli elementi distanti tre posizioni tra di
loro, e se necessario li si scambia di posto. Poi quelli a due posizioni
e infine quelli adiacenti. Invece che fare 3, 2, 1 posizioni si potrebbe
fare 7, 5, 3, 2, 1, l' unica regola e' che si finisca sempre con 1(ossia
elementi adiacenti). Sono da evitare le potenze di due dato che
rallentano l' algoritmo. Per esempio se devo ordinare l' array

4 7 3 8 2 11

confronto tutti gli elementi distanti tre posizioni, quindi:

4 con 8, e non li scambio
7 con 2, e li scambio
3 con 11, e non li scambio
avro' quindi

4 2 3 8 7 11 quindi, prendendo quelli a due posizioni di distanza

confronto
4 con 3, e li scambio
2 con 8, e non li scambio
3 con 7, e non li scambio (il 3 gia' era da scambiare)
8 con 11, e non li scambio

avro'

3 2 4 8 7 11

ora quindi confronto tutti quelli adiacenti:

3 con 2, e li scambio
2 con 4, e non li scambio (cmq il 2 sarebbe gia' stato cambiato prima)
4 con 8, e non li scambio
8 con 7, e li scambio
7 con 11, e non li scambio (il 7 gia' era da scambiare)

e avro' finalmente l' array ordinato:

2 3 4 7 8 11

fantastico. Ecco il solito programmino (anzi la solita funzioncina)
che utilizza lo shell sort. Come vedete sfrutta la sequenza 9, 5, 3,
2, 1.

void shs(int array[], int count){

int i, j, gap, k, a[5], x;

a[0]=9; a[1]=5; a[2]=3; a[3]=2; a[4]=1;

for(k=0;k<5;k++){
gap=a[k];
for(i=gap;i<count;++i){
x=array[i];
for(j=i-gap;(x<array[j])&&(j>=0);j=j-gap)
array[j+gap]=array[j];
array[j+gap]=x;
}
}
}


Con un po' di pazienza si capisce il funzionamento del programmino...
Sempre con n pari al numero degli elementi dell' array, la complessita'
computazionale in tempo e' uguale a n^1.2 (il comportamento naturale non
c'e', ma chissenefrega =).



· Quick Sort

Questo e' in generale il migliore algoritmo di ordinamento. Tant' e'
che la funzione qsort() della libreria standard lo usa =).
Per prima cosa viene selezionato un valore a caso (possibilmente
un valore medio), dopodiche' tutti gli elementi
inferiori a questo valore "campione" vengono messi da una parte,
tutti quelli superiori dall' altra. Cosi' avremo diviso l' array
in due parti, per ognuna delle quali il processo precedente verra'
ripetuto ricorsivamente. E cosi', via, in 4, 8, 16 parti ecc.. finche'
l' array non sara' ordinato. Faccio un esempio; evendo l' array

4 3 7 2 9 5

e scegliendo come campione il valore 2, avremo:

4 3 2 7 9 5

poi, per ognuna delle due parti {4,3,2} e {7,9,5}
scegliero' come campione il secondo valore, quindi avro':

2 3 4 5 7 9

cioe' l' array ordinato.

//left deve essere 0, right il numero degli elementi meno uno
void qs(int array[], int left, int right){

int i, j, x, y;

i=left; j=right;
x=array[(left+right)/2] //l'elemento a caso "campione"

do{
while((array[i]<x)&&(i<right))i++;
while((x<array[j])&&(j>left))j--;

if(i<=j){
y=array[i];
array[i]=array[j];
array[j]=y;
i++;j--;
}

}while(i<=j)

if(left<j)qs(array[], left, j);
if(i< right)qs(array[], i, right);

}

Qui in media il numero di confronti e'

n log n

e quello di scambi

n / 6 log n

se per errore come "campione" si sceglie il valore piu' alto si puo'
arrivare ad un tempo n^2. Quindi bisogna usare un metodo migliore
per scegliere il valore campione, per esempio prendendo dei valori a
caso e scegliendo quello che piu' si avvicina alla media.
Per chi non sapesse cosa sono i logaritmi, basta sapere che n log n
si dice logaritmo di n in base n. E il logaritmo di un numero r in
base n, e' il numero p a cui bisogna elevare la base n per avere quel
numero r. Per esempio il logaritmo di 100 in base 10 e' 2, perche' 2
e' la potenza a cui bisogna elevare la base 10 per avere 100, infatti
10^2=100. La complessita' computazionale del quick sort e' quindi
inferiore anche a quella dello shell sort.



· Conclusioni

Abbiamo analizzato i piu' diffusi algoritmi di ardinamento e li abbiamo
utilizzati per ordinare array numerici. Quasi mai pero' ci troveremo
davanti a questo tipo di dati. Per ordinare caratteri il procedimento
sara' lo stesso. Per ordinare le strutture bastera' scegliere la chiave
di ordinamento, e in base a questa spostare l' intera struttura.
Bisognera' di solito scegliere anche una seconda chiave di ordinamento,
nel caso in cui due strutture avessero la prima uguale, si procederebbe
ad ordinarle usando la seconda. Ma il cuore dell' algoritmo non cambia.
Lo stesso vale per gli algoritmi di ricerca discussi in seguito.
Comunque, anche se il quick sort e' in generale l' algoritmo migliore,
se sappiamo ad esempio che l' array e' gia' quasi ordinato, possiamo
scegliere anche un altro algoritmo, oppure possiamo farlo anche nel caso
di array molto corti. In questi casi la ricorsione diminuisce le
prestazioni del quick sort eccessivamente.



- ALGORITMI DI RICERCA


Esistono due metodi di ricerca, la ricerca sequenziale e quella binaria.


· Ricerca Sequenziale

Se l' array in cui bisogna ricercare l' elemento non e' ordinato,
siamo condannati ad eseguire una scansione completa dello stesso per
poter trovare l' elemento desiderato. La scrittura di codice che
utilizzi questo metodo e' veramente banale, tuttavia eccovelo:

int ricseq(int array[], int count, int chiave){ //count e' la lunghezza
//dell' array
int t;

for(t=0;t<count;++t)
if(chiave==array[t])return t;//restituisce la posizione dell' elemento
//cercato

return -1; //nel caso non ci sia un elemento uguale alle chiave
}


Be' penso non ci sia niente da dire. Viene eseguita nel peggiore dei
casi una scansione esaustiva. Purtroppo non c'e' altro metodo
per cercare una chiave in un array disordinato. La complessita'
computazionale varia da 1 a n.



· Ricerca binaria

Se l' array e' ordinato siamo veramente fortunati. Possiamo eseguire
una ricerca binaria diminuendo notevolmente la complessita'
computazionale in tempo. Si prende l' elemento centrale. Se l' elemento
cercato e' minore, si considera la parte sinistra dell' array,
altrimenti quella destra. Se l' elemento centrale e' la chiave abbiamo
gia' finito. Si prende l' elemento centrale della parte considerata e
cosi' via. Ecco una funzione che utilizza la ricerca binaria su vettori
ordinati.

int rb(int array[], int count, in chiave){

int low, high, mid;

low=0;high=count-1;

while(low<=high){
mid=(low+high)/2;
if(chiave<array[mid])high=mid-1;
else if(chiave>array[mid])low=mid+1;
else return mid;
}
return -1;

}

Un algoritmo efficiente e anche facile da implementare. Per caso vi
ricorda il quick sort? =) Comunque la complessita' computazionale
varia da 1 a n log 2 (logaritmo di n in base due). Nel caso peggiore,
con un array di 1024 elementi verranno eseguiti solo 10 confronti(e
ho detto nel caso peggiore)!!!



***PARTE 2 - STRUTTURE DI DATI***

· Introduzione

Non tutte le strutture dati che esistono ce le immaginiamo esattamente
come sono realmente in memoria. Partiamo dalle variabili di tipo bool
(solo in c++): esse sono esattamente come ce le immaginiamo. Infatti
occupano un solo bit di memoria. Saliamo un po' di livello. Un int
si avvicina molto alla realta'; noi ci immaginiamo magari un 5, ma in
realta' abbiamo (in memoria) 00000101. Ma con l' immaginazione non ci
allontaniamo ancora troppo dalla realta'. Prendiamo un double, ci
allontaniamo con la mente ancora di piu' dalla reale rappresentazione
del numero in memoria. Per non parlare di quando abbiamo a che fare
con vere e proprie strutture di dati, come le struct o le union. Qui
la nostra immaginazione e' completamente diversa dai veri e propri
dati memorizzati dal nostro computer. Di conseguenza anche per il modo
in cui accediamo ai dati la nostra immaginazione si allontana dalla
realta'. Per una bool basta cambiare o leggere il bit, per le strutture
dati servono operazioni piu' complesse.
I dati reali sono connessi ad un "motore" che controlla
il modo in cui si accede ai dati stessi. I motori per l' elaborazione
delle strutture dati organizzate sono le code, gli stack, le liste
concatenate e gli alberi binari. Parleremo (brevemente) dei primi tre,
dato che gli alberi binari sono piu' comlessi, e questa e' solo una
guida introduttiva. In pratica questi sono 4 modi di "trattare" i dati,
un po' come i protocolli. In questa parte quindi non sara' mostrata
alcuna implementazione di questi metodi, che sara' lasciata come
compito al programmatore, ma mi limitero' a definire le regole da
applicare quando si usano questi metodi. D' altro canto la loro
implementazione non e' assolutamente un compito difficile...



· Le code

Una coda e' una serie di informazioni in cui gli accessi seguono
l' ordine FIFO (First In First Out). Il primo elemento che verra'
inserito nell' elenco, sara' il primo ad essere estratto. Ovviamente
una coda sara' implementata come un array, e ci dovranno essere due
puntatori, il primo puntera' alla prossima locazione libera di memoria,
il secondo puntera' al primo oggetto ad estrarre.
Se, finito lo spazio per la coda, il puntatore al prossimo elemento
punta al primo elemento dell' array, si parla di coda circolare.
Quando un elemento viene letto ovviamente deve essere cancellato, per
permettere la lettura del prossimo elemento.



· Gli stack

Mentre una coda funziona secondo il FIFO, uno stack usa il funzionemento
LIFO (Last In First Out), ossia il primo elemento ad essere memorizzato
sara' l' ultimo ad essere estratto. Servira' avere un puntatore all'
elemento corrente da estrarre. Bisogna fare attenzione a non superare
i limiti inferiore e superiore dell' array, altrimenti si avra' un
overflow (superamento del limite superiore durante un' operazione di
scrittura) o di underflow (superamento del limite inferiore durante un'
operazione di lettura). Anche qui l' operazione di lettura comporta
quella di cancellazione, per gli stessi motivi delle code.



· Le Liste Concatenate

Le liste concatenate permettono un accesso molto piu' flessibile ai
dati. Un' operazione di lettura non comporta quella di cancellazione,
inoltre ogni oggetto della lista conterra' un puntatore al successivo.
Ovviamente una lista concatenata sara' un array di strutture, ognuna
delle quali conterra' un collegamento alla successiva (e, in caso,
alla precedente). Si possono inserire i nuovi oggetti semplicemente
aggiungendoli alla fine, oppure si possono inserire in una posizione
corretta per mantenete un certo ordine. In questo caso sara' quindi
necessario modificare il puntatore precedente e quello successivo (se
si utilizzano i puntatori ai precedenti elementi della lista)
all' oggetto inserito. In caso contrario si potra' ordinare la lista
di tanto in tanto con uno degli algoritmi di ordinamento discussi
nella parte prima.



· Conclusioni finali

Siamo arrivati alla fine di questa non troppo lunga discussione.
Gli argomenti trattati non presentano grossi problemi di comprensione
da parte di chi conosce gia' un po' di programmazione. Ogni programma
dovrebbe fare buon uso degli algoritmi e delle strutture di dati.
Una buona organizzazione dei dati consente agli algoritmi di lavorare
piu' facilmente (nonche' la possibilita' di scrivere algoritmi meno
ingarbugliati), e dei buoni algoritmi permettono di eseguire le
operazioni piu' comuni con piu' scioltezza e velocita'. Insomma,
una giusta miscela di questi due componenti assicura un programma
efficiente e funzionale.




by eafkuor
[email protected]

-----------------------
Il bello di essere intelligente e' che puoi divertirti a fare l' imbecille, ma se sei un imbecille non puoi fare il contrario.
Woody Allen

[sandrino]

salve ragazzi, vorrei sapere se qualcuno di voi può essermi d'aiuto.
ho 2 codici a 15 cifre di cui calcolando l'algoritmo delle 15 cifre si ottiene un codice a 8 cifre.

35511600358508-5 > 08664131
questo è quello risolto,ora metto il 2° codice di 15 cifre e se qualcuno può aiutarmi a trovare il risultato ottenuto dall'algoritmo e i passaggi che bisogna fare x arrivare al risultato,ve ne sarei molto grato.
35511600387893-6 eccolo.
grazie.

[Anto]

Sto preparando Algo1 e quindi GRAZIE !
E se qualche volta postassi qualche esercizietto ?[:D]
Saluti!

[sandrino]

cioè?

[eafkuor]

<blockquote id="quote"><font size="1" face="Verdana, Arial, Helvetica" id="quote">quote:<hr height="1" noshade id="quote"><i>Originally posted by sandrino</i>


ho 2 codici a 15 cifre di cui calcolando l'algoritmo delle 15 cifre si ottiene un codice a 8 cifre.
<hr height="1" noshade id="quote"></font id="quote"></blockquote id="quote">
???
forse vuoi dire che hai un numero(di 15 cifre), dal quale e' stato ricavato un altro numero(di 8 cifre), ma non sai con quale algoritmo, e vuoi trovare quest' algoritmo per poi applicarlo al secondo numero di 15 cifre?

-----------------------
Il bello di essere intelligente e' che puoi divertirti a fare l' imbecille, ma se sei un imbecille non puoi fare il contrario.
Woody Allen