Citazione:

---

Messaggio inserito da Premoli

ciao!!!

credo di non aver capito quello che volevi fare...
Il programma genera dei numeri che però non dipendono dall'input infatti anche lasciando lo stesso "student_id" i numeri che vengono generati cambiano (tralasciando le volte che il programma va in loop), quindi ora mi chiedo dato che i numeri sono casuali c'era bisogno di fare tutto quello per generarli?
non sarebbe stato più immediato fare

for(i=0; i<di quanti numeri vuoi generare ( 6 visto che li vuoi giocare al lotto? ); i++)
lotteria[i] = un numero a caso tra 1 e 90...


ma probabilmente non ho capito io cosa volevi fare...

---

Citazione:

---

Messaggio inserito da Premoli

Prima di tutto eviterei di usare quel goto che è veramente brutto

Per il resto ragionerei così (se ho capito bene quello che vuoi fare):

prima di tutto devo verificare che con i numeri della matricola riesco effettivamente a generare 6 numeri.
Ad esempio metti caso che un utente abbia questa matricola (1 1 1 1 1 1) è evidente che si possono generare solo 2 numeri diversi 1 e 11.

poi all'interno di un ciclo che va da i=0 fino a i<6 (diciamo che sono sei i numeri che voglio generare) prendo a caso una cifra della matricola e la salvo in una variabile quindi faccio in questo modo

per numeri a una cifra:
x = matricola[rand() % 6];

per numeri a due cifre:
moltiplicherò x per 10 e estrarrò un altro numero della matricola che andrò a sommare a x, in questo modo sono sicuro che anche il numero a due cifre è composto da numeri presenti nella matricola

fatto questo, controllo (con un qualsiasi algoritmo) che non ci sono numeri uguali nel vettore che sto creando se non ci sono ripetizioni vado avanti altrimenti faccio tornare indietro di una posizione l'indice del vettore e sovrascrivo l'ultimo valore...

Questo è quello che mi è venuto in mente ora, probabilmente si può sensibilmente ottimizzare...

---

Citazione:

---

Messaggio inserito da coma

Chiedo scusa ai moderatori se mi son permesso di eliminare il post che avevo precedentemente creato, però ho ritenuto che fosse corretto farlo in quanto, stamattina, in seguito ad un lieto riposo, ho ricevuto l'zione e son riuscito a porre rimedio all'orrendo goto che avevo inserito, procedendo in una modulizazzione molto più precisa, che mi ha dato modo di rendere il codice più leggibile e lineare.
Questo è il codice -> http://pastebin.com/7Z3LydBK

Ora però, vien fuori il problema dell'efficienza della sua esecuzione ed è qui che purtroppo subentrano i problemi più grossi visti i risultati che ho preso la briga di riportarvi qui sotto e che, obiettivamente, risultano, nonostante la mia inesperienza in questo campo, particolarmente alti.

alex@darknet:~/C$ time ./student_id
THE NUMBERS THAT YOU WILL USE TO THE LOTTERY :

[1] [2] [3] [4] [5] [6]
5 6 51 8 1 78


real 0m5.640s
user 0m5.630s
sys 0m0.000s

Ho provato ad adottare la ricerca dicotomica, ma con scarsi risultati, nonostante abbia adottato come funzione di ordinamento l'ottima qsort() e non un algoritmo creato da me.
Idee?
PS
Ringrazio FullMetalJacket che, nonostante la sua perenne freddezza, ha finalmente chiarito un dubbio che mi era venuto, riguardante la ormai convenzione di tutti i programmatori di non adottare il goto e che è giustificata appunto da una teoria formale rappresentata appunto dal Teorema di Böhm-Jacopini.
Grazie mille!!:)

---

Citazione:

---

Messaggio inserito da ivan

Citazione:

---

Messaggio inserito da coma

Chiedo scusa ai moderatori se mi son permesso di eliminare il post che avevo precedentemente creato, però ho ritenuto che fosse corretto farlo in quanto, stamattina, in seguito ad un lieto riposo, ho ricevuto l'zione e son riuscito a porre rimedio all'orrendo goto che avevo inserito, procedendo in una modulizazzione molto più precisa, che mi ha dato modo di rendere il codice più leggibile e lineare.
Questo è il codice -> http://pastebin.com/7Z3LydBK

Ora però, vien fuori il problema dell'efficienza della sua esecuzione ed è qui che purtroppo subentrano i problemi più grossi visti i risultati che ho preso la briga di riportarvi qui sotto e che, obiettivamente, risultano, nonostante la mia inesperienza in questo campo, particolarmente alti.

alex@darknet:~/C$ time ./student_id
THE NUMBERS THAT YOU WILL USE TO THE LOTTERY :

[1] [2] [3] [4] [5] [6]
5 6 51 8 1 78


real 0m5.640s
user 0m5.630s
sys 0m0.000s

Ho provato ad adottare la ricerca dicotomica, ma con scarsi risultati, nonostante abbia adottato come funzione di ordinamento l'ottima qsort() e non un algoritmo creato da me.
Idee?
PS
Ringrazio FullMetalJacket che, nonostante la sua perenne freddezza, ha finalmente chiarito un dubbio che mi era venuto, riguardante la ormai convenzione di tutti i programmatori di non adottare il goto e che è giustificata appunto da una teoria formale rappresentata appunto dal Teorema di Böhm-Jacopini.
Grazie mille!!:)

---

mitico STU che ci illumini! Eroe dei tempi che furono.

---

Citazione:

---

Messaggio inserito da noname

Ciao!

Nel tuo caso specifico, dato che i numeri generabili sono davvero pochi, puoi evitare l'uso di algoritmi di ricerca allocando semplicemente un array di 99 byte e inizializzandolo a zero. Quando generi un numero, diciamo 53, vai alla posizione 52 e vedi se c'è uno zero (numero non ancora generato) e in tal caso setti ad uno. In realtà i numeri generabili dipendono da quante cifre diverse ci sono nella matricola ma allocare 99 byte ti semplifica la vita. Volendo puoi anche usare le operazioni sui bit, e ti basterebbero 99 bit per mantenere le stesse informazioni. In ogni caso il guadagno di queste ottimizzazioni, nel caso ci fosse, sarebbe irrisorio dati questi input e queste poche iterazioni.

---

Citazione:

---

Messaggio inserito da noname

Stai facendo benissimo, è così che si impara :)

Dovresti mantenere in memoria un array di 99 elementi, preferibilmente del tipo più piccolo che hai a disposizione. In C tipicamente un char equivale ad un byte. A te interessa mantenere solo informazioni sulla presenza di un elemento, 1 o 0, e per questo ti basterebbe solo un bit per elemento, ma senza complicarti la vita puoi usarne 8 ;)

Quindi:

char generated_numbers[99];

da 0 a 98 setti l'array a 0

generi un numero (che sarà compreso tra 1 e 99 inclusi)
se generated_numbers[numero - 1] è uguale a 0 il numero non è stato ancora generato e setti l'elemento dell'array ad 1
altrimenti generi un altro numero

in questo modo eviti qualsiasi ricerca facendo solo un lookup nell'array

La stessa cosa si può fare utilizzando le operazioni sui bit su array di soli 13 byte.

---

Citazione:

---

Messaggio inserito da noname

Con un approccio decente un programma del genere termina in una frazione di secondo. Il tuo approccio non è male nonostante non ci siano garanzie sul tempo di esecuzione, tralasciando bug e input ostili. Per cui ci deve essere un problema e il maggior indiziato è senza dubbio il modo in cui usi il generatore di numeri casuali. E infatti è lì... :)

---

Citazione:

---

Messaggio inserito da noname

No è un problema d'uso. Inizializzi il generatore con lo stesso seme (il tempo) ad ogni chiamata di funzione. Se la funzione viene chiamata più volte in un secondo, il seme è lo stesso, e la sequenza di numeri "casuali" è la stessa. Praticamente ritorni per ogni secondo sempre lo stesso numero. Prova a vedere se è vero con una printf.

---