Newsgroup: it.comp.lang.c
Titolo: Casuali DISTINTI, aiutooo :-(((

Ho un piccolo problema sulla generzione di un certo numero di numeri
casuali in un intervallo di interi.
Il mio problema è che devo generare 70 numeri casuali DISTINTI interi
nell'intervallo 0-300 (di interi) in C.
Dopo un giro in rete ho capito che esiste una formula di statistica che
può essere implementata in C e garantisce che i numeri siano
assolutamente DISTINTI.
Tuttavia non sono sicuro che la cosa stia propio in questi termini e non
so come implementare.
Qualcuno lo ha già fatto?
Mi potreste spiegare come fare?
Grazie
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 nell'intervallo 0-300 (di interi) in C.
Ci sono 2 soluzioni sceme sceme:
1) per generare 70 numeri:
(ripetere 70 volte)
generi un numero tra 0 e 300 e vai a vedere
se lo hai gia' generato: se cosi' e' allora lo scarti.
2) metti in un array di 301 posizioni (int T[301]) i numeri tra 0 e 300.
poi quando ti servono 70 numeri mescoli l'array
(scambiando ogni posizione con una posizione a caso)
e poi consideri i primi 70 numeri.
Sulla mia macchina e' piu' efficiente la soluzione 1.
(Naturalmente dipende dalle grandezze 70 e 300, fossero 200 numeri
distinti su 300 allora la seconda soluzione sarebbe certamente
piu' efficiente).
ciao,
g.

 e poi consideri i primi 70 numeri.
Innanzitutto ti ringrazio.
Dunque, la seconda soluzione sono costretto/a a scartarla poichè mi alza
la
complessità.
Per la prima, la soluzione mi obbligherebbe ad allocare un vettore di
300 elementi da usare come "flag" per controllare se è stato generato.
Poi, ogni volta che genero un numero un numero x controllo nel vettore
"flag"
alla posizione x se il valore flag[x] è uguale a 1 o a zero.
Se è 1 allora vul dire che lo ho già generato e ne genro un altro, se è
0 allora il numero va bene e cambio il valore del vettore flag[x]=1.
Vorrei però evitare di allocare questo vettore.
Mi chiedevo se esisteva una funzione che generasse numeri casuali
distinti.
Non possono nemmeno suddividere i 300 in sottointervalli distinti e
scegliere
casualmente un numero in ognuno dei sottointervalli distinti, poichè
in questo modo avrei numeri distinti ma ordinati, dato che il vettore di
300 numeri li contiene ordinati.
In pratica è un casino e sono fottuto !!!
Cmq, grazie


 In pratica è un casino e sono fottuto !!!
Non disperare !
Mi piacerebbe sapere se questo e' un esercizio o un problema reale.
L'approccio puo' essere diverso nei due casi.
(per esempio: non puoi veramente usare 300 bytes di flag ??
  Perche' ?
  Deve essere una operazione velocissima oppure no ?
  Sulla mia macchina (un athon1400) le tre soluzioni possibili ci mettono
  circa (in secondi)
0.08 (quella con i flag),
0.17 quella che non usa i flag e confronta con tutti i numeri passati)
0.27 quella che mescola
per estrarre 10,000 volte i 70 numeri casuali. E' troppo lento per la
tua applicazione ?)
Inoltre aiuterebbe sapere "quanto casuali" devono essere i numeri.
Se i numeri non devono essere troppo casuali, allora posso
(o meglio: puoi, se si tratta di un esercizio...)
pensare a qualche trucchetto con i numeri primi per generare 70 numeri
distinti senza memoria dei numeri passati e quindi piu' velocemente.
Ma non saranno proprio casuali come quelli generati con la rand().
(Tra l'altro, vista la semplicita' del problema, non ho pensato
a cercare in rete qualche soluzione iper-furba ed efficiente...
tu l'hai cercata ?)
ciao,
g.

 Grazie
Prego ciao,
SoloOcchi
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 		 while (controllo = 0);
Qui hai messo un assegnamento (controllo = 0) ?
Volevi mettere un test (controllo == 0) ??
Non ho controllato il resto del programma.
Comunque al primo poster avevo gia' proposto tre metodi scemi
per generare 70 numeri distinti tra 0 e 299 (estremi compresi:)
e metterli in int K[70]
void Metodo1(int *K)
{
   char flg[300];
   int i,r;
   for (i=0; i<300; i++) flg[i]=0;
   for (i=0; i<70; i++)
    {
      while (flg[r=rand()%300]);
      flg[r]=1;
      K[i]=r;
    }
}
void Metodo2(int *K)
{
    int i=0,j,r;
    while (i<70)
    {
      K[i++]=(r=rand()%300);
      for (j=0; j<i-1; j++)
        if (K[j]==r) {i--; break;}
    }
}
void Metodo3(int *K)
{
   int T[300],i,t,r;
   for (i=0; i<300; i++) T[i]=i;
   for (i=0; i<300; i++)
       {r=rand()%300; t=T[r];T[r]=T[i];T[i]=t;}
   for (i=0; i<70; i++) K[i]=T[i];
}
ciao,
g.

 } while (numero > 300);
Questa e' la piu' grande schifezza mai vista....
Oltre tale schifezza il tuo programma e' tutto una cosa inguardabile e....
non funziona nemmeno!
Al limite scrivi una cosa del genere:
<CODE>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
int main()
{
    int nums[301];
    int n,i;
    srand((unsigned)time(NULL));
    memset(nums,0,301*sizeof(int));
    for(i=0;i<70;++i){
        while(nums[n=rand()%301])
            ;
        nums[n]=1;
        printf("%d - ",n);
    }
    return 0;
}
</CODE>
Ok, inizializzo le 301 posizioni (0-300) a 0 con memset (si puo' fare in
altri modi!).
Poi x 70 volte, cerco un numero casuale fino a che nums[numero] ritorna 0
(all'inizio qualsiasi numero). Appena lo trovo esco dal ciclo e setto
nums[numero] a 1 per fare in modo che non esca piu'! Lo stampo a video!
Ovvio che se invece di 70 numeri distinti nell'intervallo 0-300 ne vogliamo
70 nell'intervallo 0-69 funzionera' ma .... non e' proprio l'ideale!
Se invece vogliamo 70 numeri distinti nell'intervallo  0-30 ad esempio,
questo programma si piantera'!
Per questo motivo e' bene controllare i valori prima di lanciare tale
algoritmo (e vedere se e' possibile fare tale cosa o farebbe piantare il
programma). Al limite puoi mettere anche un controllo che esce dal ciclo se
capisce che si e' piantato.
Lysa (o chi altro), questa e' la soluzione piu' semplice... per numeri
nell'intervallo 0-300 va benone, tanto un array di 300 int o char non costa
nulla! Per la tua funzione che li genera senza memorizzare quali sono
usciti... ora non mi sovviene nulla. Per allocare meno bytes potresti avere
(in questo caso) un array di 70 elementi (uscite precedenti) e controllare
che il numero generato da rand() non sia gia' uscito.... Tuttavia questa
alternativa mi piace meno!
SoloOcchi, davvero il tuo listato mi ha lasciato l'amaro in bocca....
Tommy

 }
Il mio metodo, pare essere sputato il tuo... ;-)
nel caso specifico di Lysa flg dovrebbe avere 301 elementi, ma il tuo metodo
va benone per generare 70 numeri da 0 a 299. Poi nel caso specifico di Lysa
bastera' cambiare i 300 in 301.
E' buffo il fatto che memset a parte (che tra le altre cose non mi piace
piu' di tanto usare) i due frammenti di codice siano identici!
Tommy
P.S. questione di stile:
quando ho un while(...); che non fa nulla, io tendo a scrivere:
while(...)
    ;
oppure:
while(...){
}
oppure while(...){}
trovo che:
while(...);
possa confondere a volte se uno legge il codice distrattamente.

 Questa e' la piu' grande schifezza mai vista....
Mi accorgo di aver esagerato con il tono e ti chiedo scusa per questo....
(mi e' venuto senza accorgermi).
Tommy

         while(nums[n=rand()%301])
e questo
non e' che siano dei capolavori di programmazione...
IMHO ovviamente...
C:\>iao Angelo


 e metterli in int K[70]
Me li leggo volentieri :)
ciao e grazie,


 Tommy
Grazie per le dritte ciao,


 Tommy
Ciao e grazie,


>                       ;
Questo invece che problema avrebbe?!?
Preferivi 2 righe, 3 forse? Ok, questione di stile, ma che a che vedere con
"non e' che siano dei capolavori di programmazione..."
Sei il fratello maggiore di SoloOcchi? Ti sei messo sulla sua difensiva?
Beh, a me sta bene, ma dai motivazioni validi almeno.
Tommy

che a che vedere con
        ^
HA

 complessità.
Tecnicamente la prima soluzione è NP.
Vuoi calcolarmi la sua complessità :)?

 quando bastava fare rand()%300....
Vi ricorso che usare l'operazione di modulo per la generazione di numeri 
random è una soluzione piuttosto infelice per la qualità del risultato :)
Ma tanto lo sapete tutti

 > non e' che siano dei capolavori di programmazione...
non ti sembra scarsamente leggibile? Non era meglio riscrivere il
codice in modo da avere qualcosa del tipo
  n = rand()%301;
  while(nums[n])
     n = rand()%301;
Ficcare tutto in usa riga fa molto programmatore figo, ma
rende il codice scarsamente leggibile.


 rand()%301
per i limiti della rand() (i bit meno significativi dei numeri generati sono
poco casuali.).... mi spiace questa fa parte dello standard... Per prodotti
professionali usero' librerie/funzioni esterne, per rispondere al NG uso
quello che mi da lo standard.
Usare trucchetti come:
rand()/(RAND_MAX/..... etc...
li lascio a voi!
E poi se la rand() e' limitata prenditela con il C e non con me ;-)
Tommy

Tommy wrote:
ho letto il tuo programma.. io avrei fatto cosi':
int main()
{
	int nums[301];
	int i;
	srand((unsigned)time(NULL));
	for(i=0;i<70;i++)
	{
		nums[i]=rand()%301;
		printf("%d - ",nums[i]);
	}
 
return 0;
}
P.S. mi sto ancora documentando su srand che non ho capito.. per il resto
che ne pensi? sarebbe una soluzione accettabile? (funziona)
ciao,
soloOcchi


 	}
Se riesci a garantire che il codice precedente inizializzi
SEMPRE e COMUNQUE nums[] con numeri tutti diversi, corri a
giocare al superenalotto: il prossimo 6 e' tuo :-)
C:\>iao Angelo


 poco casuali.)
Che vuoi... mon sempre e' possibile /dev/random :-)


 rende il codice scarsamente leggibile.
In molti casi si, in questo in particolare no. Ad essere sincero a me non
piace la tua versione con un rand() fuori dal ciclo ed uno dentro il
ciclo... oh, che dirti, questione di gusti.
Il fatto che faccia programmatore figo, lascia stare... sono parecchi anni
che programmo in C e non voglio apparire di certo figo mettendo tutto su di
una sola riga... Nel caso specifico, personalmente lo trovo piu' leggibile.
Io ODIO i cicli do{}while(); ma... piuttosto che avere ripetizioni.... Le
ripetizioni mi fanno venire gli occhi rossi, beh, anche il do-while!
Ecco come era il mio codice:
for(i=0;i<70;++i){
        while(nums[n=rand()%301])
            ;
        nums[n]=1;
        printf("%d - ",n);
}
Beh, l'ho riscritto come piace a te ;-)
i=0;
while(i<70){
      n=rand();
      n%=301;
      while(nums[n]!=0){
            n=rand();
            n%=301;
      }
      nums[n]=1;
      printf("%d - ",n);
      ++i;
}
Spero tu lo possa trovare piu' leggibile...
Scherzi a parte, questo e' un esempio in cui spezzando il codice su piu'
righe e.... appare meno leggibile!
Ricordati che non sempre avendo un codice lungo questo e' piu' leggibile,
anzi a volte gli occhi si perdono tra le troppe righe.
Il modo migliore per avere codice leggibile e' usare funzioni con nomi
significativi. Ma per un programmino cosi' piccolo....
Tommy

 che ne pensi? sarebbe una soluzione accettabile? (funziona)
No, mi dispiace non funziona. Forse intendi compila senza errori, questo si,
ma NON funziona.
In questo modo stampi 70 numeri (OK), nel range 0-300 (OK), ma non puoi
avere affatto la certezza che siano distinti! Magari quando lo hai eseguito
tu lo erano, ma prova piu' volte e vedrai che non e' sempre cosi'!
tu metti rand()%301 in nums[i] e poi lo stampi, rand()%301 non genera
affatto numeri distinti.
Inoltre tu hai
int nums[301];
quando poi usi solo i primi 70 elementi, forse ti conveniva dargli size 70!
Tommy

 C:>iao Angelo
Ciao,
SoloOcchi


 Spero che questa soluzione sia almeno decente *_*
Si, quest'ultima sembra funzionare... (al contrario di tutte le precedenti).
Beh, almeno questo thread ti e' servito a migliorarti ;-)
Tommy

 Tommy
ciao e grazie,
soloOcchi :)


 ------------------------------------------------------------------
Questa soluzione mi sembra che vada bene
e questo e' anche il momento ideale per un esempio di goto !!
(alla faccia dei programmatori della domenica !!!)
for (i=0; i<70; i++)
{
genera_candidato:
     r=rand()%300;
     for (j=0; j<i; j++)
       if (r==array[j]) goto genera_candidato;
     array[i]=r;
}
Questo sopra e' un esempio di uso di goto che rende il
programma ad un tempo piu' leggibile, piu' semplice
e piu' corrispondente all'algoritmo che uno ha in mente
( genera un numero e scartalo se l'hai gia' generato),
senza usare variabili ausiliarie (controllo).
ciao,
g.

 nell'intervallo 0-300 (di interi) in C.
 int y=time(0),i;
 for(i=0; i<70; ) {
  y = (30*y) % 307;
  if(y < 302) { i++; USA(y-1); }
 }
USA() è il codice in cui usi il numero *pseudo* casuale tra 0-300. I 70
numeri sono distinti.
Il programmino mi sembra piuttosto efficiente (scarti solo i numeri da
302 a 306).
Se t'interessa il funzionamento ti basta sapere che si tratta di un
generatore a congruenza lineare avente per modulo un numero primo (307).
Il moltiplicatore (30) è una radice primitiva modulo 307, ovvero 30 è un
generatore di Z307* (il gruppo moltiplicativo dei numeri interi modulo
307).
y=0 non è ammesso (come puoi facilmente verificare) per cui devi
sottrarre 1 a y.
Con questi parametri il periodo del generatore è massimo (cioè 307-1).
Cristiano

  }
;-) grazie per la risposta. Ero sicuro di aver visto gia' da qualche parte
qualche codice del genere, ma non mi ricordavo piu' bene. Credo fosse
proprio quello che cercava Lysa.
Tommy

 [...]. Credo fosse proprio quello che cercava Lysa.
Speriamo... :-)
In realtà, non sapendo a che gli serve, quel metodo potrebbe non andar
bene.
Infatti la sequenza di numeri è sempre la stessa, variando la y iniziale
vari soltanto il punto in cui inizia la sequenza.
Ad esempio, con y iniziale uguale a 1 hai: 29, 285, 290, ... Con y
iniziale uguale a 2 hai: 59, 264, 274, ..., 173, 0, 29, 285, 290, ... e
la sequenza si ripete esattamente allo stesso modo.
Per risolvere (parzialmente) il problema, potrebbero essere usati tutti
e 96 i generatori disponibili per il modulo 307, si avrebbero così 96
sequenze diverse.
Sentiamo se Lysa ci dice qualcosa...
Cristiano

 Sentiamo se Lysa ci dice qualcosa...
E volendo potresti anche usare prendere uno dei primi "10" numeri primi
validi, a "random" ne prendi uno quando entri nella funzione e poi calcoli i
sui generatori e ne prendi uno sempre a caso, no?
Allora ti chiedo una cortesia, potresti ricordarmi come sapere quali sono i
suoi generatori validi per questo scopo?
Tommy

 sono i suoi generatori validi per questo scopo?
E` necessaria un po' d'aritmetica modulare.
Zp è l'insieme dei numeri interi da 0 a p (numero primo).
Il gruppo moltiplicativo di Zp (Zp*) comprende tutti gli elementi da 1 a
p.
L'elemento 'a' è un generatore di Zp se l'insieme delle potenze (modulo
p) {a^1, a^2, ..., a^(p-1)} è uguale a Zp*.
Queste sono le 'chiacchiere'. :-) In pratica, per numeri così piccoli,
io trovo i generatori per tentativi.
Tenendo presente che l'ordine di un generatore in Zp è uguale a p-1,
calcolo l'ordine di tutti gli elementi da 1 a p-1; quelli che hanno
ordine p-1 sono generatori.
L'ordine di un elemento 'a' in Zp è il più piccolo numero 'o'>0 tale che
    a ^ o = 1 mod p
Un possibile metodo è:
int p=307,o,a;
 for(a=1; a<p; a++) { // Elementi di Zp
  for(o=1; o<p; o++) // Trova l'ordine di a
   if(ME(a,o,p) == 1) { // Ordine trovato
    if(o == p-1) GENERATORE
    break;
   }
 }
ME() calcola a^o mod p. Un'implementazione puramente didattica (a causa
degli overflow), ma pur sempre valida per i nostri piccoli numeri,
potrebbe essere:
int ME(int a,int k,int n) // a^k mod n
{
 if(k==0) return 1;
 int b=1,A=a; if(k&1) b=a;
 do {
  k>>=1; A=(A*A)%n;
  if(k&1) b=(A*b)%n;
 } while(k);
 return b;
}
Può sembrare tutto molto complesso e lento, ma la velocità di calcolo di
tutti i generatori è molto alta per cui è possibile calcolarli anche in
modo dinamico senza dover allocare un vettore di generatori.
Cristiano

Volevo semplicemente chiarire un punto che spero sia
interessante non solo per me.
L'originatore del messaggio (dopo qualche tentativo) ci ha
chiesto di generare 70 numeri casuali distinti tra 0 e 300,
senza utilizzare array di supporto.
Ora vorrei chiarire perche' rispondere alla sua domanda
in modo sensato e' difficile (su it.scienza.informatica ha
detto che qui su it.comp.lang.c ha ricevuto solo risposte "inutili",
il che mi ha dato un po' di dispiacere, visto che insieme ad altri
mi ero prodigato per aiutarlo)
Dobbiamo innanzitutto definire meglio cosa intendiamo
per "70 numeri casuali distinti tra 0 e 300".
Secondo me il metodo migliore e' quello operativo:
dimentichiamoci dei profondi concetti di casualita'
e pseudocasualita', e limitiamoci a chiedere che
la nostra funzione generi una sequenza 70 numeri distinti tali che
(1) a priori la funzione puo' generare qualsiasi sequenza,
cioe' non ci sono sequenze "proibite".
(2) ogni sequenza e' (approssimativamente) equiprobabile,
cioe', in pratica, non e' che invocandolo 3 volte ottengo
sempre la sequenza 1,2,3..,70. ...
Supponiamo di avere a disposizione una fonte di casualita'
(che poi sara' la funzione rand()%300  o (rand()>>3)%300 o quel che
  preferite ) che per semplicita' possiamo assumere sia perfetta.
La domanda che ci poniamo e' allora: e' possibile scrivere
una funzione che soddisfa le condizioni (1) e (2) e che
non usa "memoria ausiliaria" ?
Penso si possa dimostrare facilmente che la risposta e' NO.
Cerchiamo di capire cosa intendiamo per "memoria
ausiliaria".
Il richiedente ha cassato le nostre proposte di usare:
(A) un array di 300 flag per stabilire quali numeri erano
gia stati "estratti". (I flag possono essere int, char o anche bit
impacchettati dentro un unsigned char)
(B) un array di 70 numeri (per memorizzare quelli gia' estratti
   e confrontarli con l'estratto successivo)
(C) un array di 300 numeri (da scambiare in modo casuale per poi
considerare i primi 70)
Tutte queste proposte erano contraddistinte da un basso costo
computazionale, dalla poca memoria ausiliaria necessaria
(da un minimo di 300 bit = circa 38 bytes ad un massimo di 300*4=1200
  bytes) e soprattutto soddisfavano le condizioni (1) e (2).
E' vero che da un punto di vista squisitamente teorico solo
la (C) ha un costo costante, perche' la (A) e (B) estraggono
piu' numeri in caso di conflitto, pero' facendo un po' di
calcoli o di simulazioni si vede che in media devono venir
generati circa 80 numeri e che la probabilita' che se ne debbano
generare, per es. 150 per averne 70, e' piu' o meno quella
che io venga colpito in questo istante da una meteor...aaaarghhh... :-)
Apparentemente il richiedente voleva una funzione che
invocata 70 volte di fila generasse numeri distinti.
Questo e' fattibile, ed e' stato fatto usando per esempio le proprieta'
dei generatori di Zn (per n=307), anche se, naturalmente questa
soluzione non puo' soddisfare la (1) e la (2), perche' essendo
ogni numero determinato in modo univoco dal precedente non tutte le
sequenze sono possibili e anche facendo variare il generatore.
Siccome la funzione era richiesto non avesse "memoria", ogni volta
bisogna come minimo passarle l'ultimo numero generato, per generare il
prossimo (e quindi un minimo di memoria ausiliaria c'e' sempre..., per
il generatore utilizzato (a scelta tra 96) e per l'ultimo numero
generato).
E' facile allora vedere che se vogliamo soddisfare la (1) e la (2)
la nostra funzione avra bisogno di ancor piu' memoria ausiliaria.
Infatti consideriamo il momento nel quale il generatore sta
generando l'ultimo numero, il 70-esimo.
Se le condizioni di casualita' (1) e (2) devono essere verificate allora
ciascuno dei circa 230 numeri rimanenti deve poter essere estratto.
Quindi, per garantire che l'ultimo estratto non coincida con uno dei
numeri estratti in precedenza dobbiamo (in modo implicito o esplicito)
tenere traccia dei primi 69 numeri.
Per le condizioni (1) e (2) possiamo/dobbiamo assumere che i primi 69
numeri possano essere stati qualsiasi;
le possibili configurazioni dei primi 69 numeri sono circa uguali 
(siccome non ci interessa l'ordine), al
coefficiente binomiale (300 su 69) che con un po' di calcoli risulta
uguale a circa 2 alla 230, ovvero 230 bit di informazione.
Quindi e' IMPOSSIBILE generare il 70esimo numero usando meno
di 230 bit ausiliari (se uno vuole garantire le condizioni (1) e (2)).
La nostra soluzione (A) che usa 300 bit (ovvero 38 bytes) non e' quindi
molto distante dal minimo teorico.
Diverso e' il discorso se rinunciamo alla validita' di (1) e (2).
In tal caso possiamo "barattare" un perdita di casualita' con un
risparmio in termini di spazio ausiliario o un guadagno in termini
di velocita'.
Ma in tal caso il richiedente avrebbe dovuto dirci con piu' esattezza
quali erano i termini del problema, per poter ricevere risposte corrette
e "utili".
Ciao,
g.

 non usa "memoria ausiliaria" ?
Questa è una domanda che ti poni tu.
L'autore della richiesta ha semplicemente detto:
"Il mio problema è che devo generare 70 numeri casuali DISTINTI interi
nell'intervallo 0-300 (di interi) in C."
ed essendo il suo unico post (almeno tra quelli che vedo io) non capisco
perché ti devi inventare delle condizioni che l'autore non ha espresso.
La mia risposta soddisfa *totalmente* la richiesta. Avendo anche
precisato le limitazioni della soluzione che ho proposto, credo di aver
fatto il possibile per aiutare il richiedente, come lo hai fatto tu e
gli altri, ognuno a modo suo.
Se tutte le nostre risposte sono state inutili, pazienza... Ciò
significa che la domanda non precisa tutti i requisiti a cui attenersi.
Anche se l'autore aggiunge: "Dopo un giro in rete ho capito che esiste
una formula di statistica che può essere implementata in C e garantisce
che i numeri siano assolutamente DISTINTI." è evidente che non ci può
essere d'aiuto (per me in particolare è una frase assolutamente
incomprensibile).
Cristiano

 gli altri, ognuno a modo suo.
Non ho nulla contro la tua risposta (che di fatto e' quanto di piu'
vicino alla richiesta del Tipo si possa ottenere, ottemperando alle
sue richieste.)
Solo che io, forse per deformazione professionale, se uno mi chiede
di generare delle sequenze di numeri casuali, scarto a priori
un metodo che mi genera al massimo 96 sequenze diverse
(prova a pensare se fosse realmente usato a scopi statistici...)
Comunque il Tipo non ha voluto precisare in che ambito gli
servisse la funzione (su it.scienza.informatica ha detto per
un progetto universitario di algoritmi e strutture dati).
(La sua frase sulla "formula statistica" effettivamente e' priva di
senso...)
ciao,
g.

 perché ti devi inventare delle condizioni che l'autore non ha espresso.
No, i post sono due. Vedi anche quello a nome Luca Pistariello. (e su
l'altro ng ha postato come chobin).
Tommy


Comincio a convincermi che questo postulante misterioso stia
trolleggiando...
Cristiano

 (prova a pensare se fosse realmente usato a scopi statistici...)
Le sequenze diverse sono almeno il quadruplo di 96 perché vengono
utilizzati soltanto 70 numeri ogni 302 disponibili; potrebbero essere
abbastanza per molti scopi, se solo sapessimo quali... :-)
Se uno dice: "[...] generare 70 numeri casuali DISTINTI [...]" significa
che ha le idee confuse e quindi ho pensato d'interpretare a mia
discrezione tutta la richiesta pensando che il tutto servisse per scopi
'giocattolosi' (e mi sembra d'intuire che sia proprio così).
Spero che per aver tentato di aiutare qualcuno con debba dare ancora
altre giustificazioni per difendermi dal mio reato di tentato aiuto...
:-)
Cristiano


No. Ti ribadisco che non devi assolutamente difenderti. Hai dato una
risposta ragionevole. Ho solo spiegato perche' io avevo interpretato la
domanda in un altro modo.
Se questo ti puo' consolare, ti faccio una citazione dal "Dizionario del
Diavolo" di Ambrose Bierce:
AIUTARE: aumentare il numero degli ingrati.
ciao,
g.

 AIUTARE: aumentare il numero degli ingrati.
Ottima definizione! La condivido :-)
Cristiano