Domanda Problema del compleanno

Stato
Discussione chiusa ad ulteriori risposte.
Ordina per data Ordina commenti per reazioni
L

Liolà

Utente Emerald
7 Luglio 2012
846
47
240
404
Ultima modifica:
Buon giorno ragazzi!
Voglio trovare 3 persone in una stanza che abbiano lo stesso compleanno(non contando l'anno però), e per fare ciò, stavo pensando a questo codice:
Codice: 
public class Birthdayx3{
public static void main(String args[]){
int count=0; // numero delle verifiche effettuate
boolean[] birthday=new boolean[365]; //array che rappresenta i 365 giorni che ci sono in un anno
while(true){
int i=(int) (Math.random()*365);
int j=(int) (Math.random()*365);//secondo indice che servirà per trovare la terza persona
if(birthday[i]==true && i==j && birthday[i]==birthday[j])  //se birthday é già true, vuol dire che due persone
break;                                                                         //con lo stesso compleanno sono state trovate
                                                                                   //Se però, l'elemento birthday[i] risulterà uguale
                                                                                   //all'elemento birthday[j] nello stesso giorno,
                                                                                   //una terza persona con lo stesso compleanno
                                                                                   //delle prime due, è stata trovata


birthday[i]=true;

count++;
}
System.out.println("After " + count+ " tries");
System.out.println("Three people with the same birthday were found");
Secondo voi é giusto come ragionamento? So che probabilmente questo non é il metodo più preciso e più elegante per risolvere questo tipo di problema, ma comunque mi basta sapere se sia giusto o meno.
 
Quante sono le persone nella stanza? Questa è un'informazione essenziale. 365 sono i giorni in un anno (o 366 se è bisestile come quest'anno) e non è possibile che una persona sia nata dopo il giorno 31 di un mese.

Hai un ciclo potenzialmente infinito e che farà un numero di giri non deterministico. L'assegnazione arbitraria di
Java: 
birthday[i]=true;
non mi sembra che rispecchi la tua descrizione. Assegni true ad un cella dell'array in modo casuale ad ogni iterazione.

Insomma, la logica non mi pare sia corretta e ci sono ampi margini di miglioramento. La soluzione è (in media, dalle prove che ho fatto) sempre un'ordine di grandezza maggiore (o due) di una banale implementazione che ho appena fatto.
 
  • Mi piace
Reazioni: Yosiri
Ultima modifica:
Scanetatore ha detto:
Quante sono le persone nella stanza? Questa è un'informazione essenziale. 365 sono i giorni in un anno (o 366 se è bisestile come quest'anno) e non è possibile che una persona sia nata dopo il giorno 31 di un mese.

Hai un ciclo potenzialmente infinito e che farà un numero di giri non deterministico. L'assegnazione arbitraria di
Java: 
birthday[i]=true;
non mi sembra che rispecchi la tua descrizione. Assegni true ad un cella dell'array in modo casuale ad ogni iterazione.

Insomma, la logica non mi pare sia corretta e ci sono ampi margini di miglioramento. La soluzione è (in media, dalle prove che ho fatto) sempre un'ordine di grandezza maggiore (o due) di una banale implementazione che ho appena fatto.
Clicca per espandere...
No no, é proprio vago l'esercizio(suppongo per rendere il tutto più semplice ai principianti). Salta l'anno di nascita, e non conta né il giorno, né il mese, ed inoltre non specifica il numero delle persone nella stanza. Per il fatto della casualità, é l'esercizio stesso che é basato sul random access in un array.
 
Più o meno é questo l'esercizio:
"
As an example, let’s look at a well-known problem called the birthday problem: Suppose
that there are N people in a room. What’s the chance that there are two people in the room
who have the same birthday? (That is, they were born on the same day in the same month,
but not necessarily in the same year.) Most people severely underestimate the probability. We
will actually look at a different version of the question: Suppose you choose people at random
and check their birthdays. How many people will you check before you find one who has the
same birthday as someone you’ve already checked? Of course, the answer in a particular case
depends on random factors, but we can simulate the experiment with a computer program and
run the program several times to get an idea of how many people need to be checked on average.
To simulate the experiment, we need to keep track of each birthday that we find. There are
365 different possible birthdays. (We’ll ignore leap years.) For each possible birthday, we need
to keep track of whether or not we have already found a person who has that birthday. The
answer to this question is a boolean value, true or false."
Nel mio caso specifico, invece di doverne trovare due, ne devo trovare 3.
 
Yosiri ha detto:
Secondo voi é giusto come ragionamento? So che probabilmente questo non é il metodo più preciso e più elegante per risolvere questo tipo di problema, ma comunque mi basta sapere se sia giusto o meno.
Clicca per espandere...
È sbagliata.
Anzi tutto tra le condizioni per uscire hai i==j, che fa ricadere l'esperimento in un caso simile a questo:
Yosiri ha detto:
Most people severely underestimate the probability.
We will actually look at a different version of the question: Suppose you choose people at random and check their birthdays. How many people will you check before you find one who has the same birthday as someone you’ve already checked?
Clicca per espandere...
Inoltre la condizione precedente non è sufficiente per farti uscire dal while, perché hai anche bbirthday(I)==true. Quindi non solo stai calcolando un evento più raro di quello richiesto, ma è ancora meno probabile di quel che l'intuito ci fa erroneamente pensare (descritto nel pezzo che ti ho quotato). La terza condizione è inutile, se si verificano le prime due allora la terza è sempre vera.

La soluzione più semplice è utilizzare un array di int invece che di bool: ad ogni ciclo del while chiedi ad una persona quando compie gli anni (estraendo il numero random) e incrementi il rispettivo valore nell'array. Quando incrementando quel valore raggiungi 3, hai trovato 3 persone che compiono gli anni lo stesso giorno in un insieme di "count" persone.
Stando a internet la mediana è 87, basati su questo per vedere se i risultati che ottieni ti sembrano ok. Tieni anche conto che non puoi ottenere valori superiori a 365*2+1=731 (se hai 731 persone per forza di cose ce ne sono almeno 3 che compiono gli anni lo stesso giorno).
 
  • Mi piace
Reazioni: Yosiri
Ultima modifica:
St3ve ha detto:
È sbagliata.
Anzi tutto tra le condizioni per uscire hai i==j, che fa ricadere l'esperimento in un caso simile a questo:

Inoltre la condizione precedente non è sufficiente per farti uscire dal while, perché hai anche bbirthday(I)==true. Quindi non solo stai calcolando un evento più raro di quello richiesto, ma è ancora meno probabile di quel che l'intuito ci fa erroneamente pensare (descritto nel pezzo che ti ho quotato). La terza condizione è inutile, se si verificano le prime due allora la terza è sempre vera.

La soluzione più semplice è utilizzare un array di int invece che di bool: ad ogni ciclo del while chiedi ad una persona quando compie gli anni (estraendo il numero random) e incrementi il rispettivo valore nell'array. Quando incrementando quel valore raggiungi 3, hai trovato 3 persone che compiono gli anni lo stesso giorno in un insieme di "count" persone.
Stando a internet la mediana è 87, basati su questo per vedere se i risultati che ottieni ti sembrano ok. Tieni anche conto che non puoi ottenere valori superiori a 365*2+1=731 (se hai 731 persone per forza di cose ce ne sono almeno 3 che compiono gli anni lo stesso giorno).
Clicca per espandere...
Ho capito la soluzione e ti ringrazio, ma non ho capito questa parte: "Anzi tutto tra le condizioni per uscire hai i==j, che fa ricadere l'esperimento in un caso simile a questo"
Comunque sì, anch'io ho pensato che sia superflua la terza, ma mi andava di metterla perché mi rendeva più sicuro XD
Per quanto riguarda le prime due ho pensato che dato che la prima verifica che ce ne siano almeno due, con la terza avrei verificato l'esistenza di una terza persona con lo stesso compleanno.
Non ho capito bene la cosa del (365*2)+1

Comunque penso che sia sufficente impostare la condizione a 2, poiché se mettiamo un controllo all'inizio, al ricominciare del ciclo se ribecca alla terza volta quel determinato compleanno, e rileva che già altre due volte sono capitate due persone con lo stesso compleanno, automaticamente può uscire dal ciclo.


Una curiosità: per riuscire a "sviluppare" la capacità di ragionare correttamente che bisogna studiare?
 
Yosiri ha detto:
Ho capito la soluzione e ti ringrazio, ma non ho capito questa parte: "Anzi tutto tra le condizioni per uscire hai i==j, che fa ricadere l'esperimento in un caso simile a questo"
Clicca per espandere...
Se io ti chiedo "qual'è la probabilità che, prendendo due persone, compiano gli anni nello stesso giorno?", questa probabilità è bassa. Se io ti chiedo "qual'è la probabilità che, in un gruppo di N persone, ce ne siano almeno 2 che compiano gli anni lo stesso giorno?", questa probabilità è molto alta (bastano 40 persone per arrivare al 90%).

Tra le condizioni per interrompere il ciclo hai i==j, con i e j estratti random. Questa condizione è equivalente a prendere due persone, chiedergli quando compiono gli anni ed essere contenti (ovvero: l'evento si verifica) quando ti dicono lo stesso giorno. È esattamente la prima domanda che ho scritto prima.

Non è intuitivo capire che la probabilità è molto alta perché non siamo abbastanza attenti a quello che chiede la domanda. Quando facciamo una stima "a occhio" e diciamo che la probabilità è bassa, stiamo in realtà pensando alla prima domanda.

Yosiri ha detto:
Non ho capito bene la cosa del (365*2)+1
Clicca per espandere...
Chiedi a 731 persone quando compiono gli anni, supponiamo che sei particolarmente sfigato: le prime 365 persone ti dicono 365 giorni diversi (nessuno compie gli anni lo stesso giorno), con altre 365 persone succede la stessa cosa. A questo punto abbiamo chiesto a 730 persone e, visto che siamo stati proprio molto sfigati, non abbiamo ancora 3 persone che compiono gli anni lo stesso giorno.
Abbiamo che in ogni giorno dell'anno ci sono 2 persone che compiono gli anni. Quando facciamo domanda alla 731esima persona, qualsiasi giorno dica, abbiamo trovato la terza persona che compie gli anni in un certo giorno dell'anno.
 
@St3ve ho capito la questione del 731, mentre la prima parte continuo a non capirla. Mi viene da pensare che una volta che verifico il birthday=true, ho verificato che ci siano effettivamente almeno 2 persone, mentre con la seconda condizione(i==j), verifico l'esistenza di una terza.
 
Ok, provo a spiegartela così:
Java: 
int i=(int) (Math.random()*365);  // compleanno della persona i
int j=(int) (Math.random()*365);  // compleanno della persona j

if (i == j) // se la persona i e la persona j compiono gli anni nello stesso giorno
    break;

La tua condizione non è proprio così, ma quello che ho scritto io è necessario (ma non sufficiente) per il verificarsi della tua condizione.

Con questa condizione, ad ogni giro del while stai prendendo due persone (i e j) e stai controllando se compiono gli anni nello stesso giorno. Nel problema del compleanno non ti viene chiesto di prendere due persone e vedere se compiono gli anni nello stesso giorno, questa è la domanda che erroneamente ci si pone quando si pensa a una stima.
 
Ultima modifica:
@St3ve
Però se verifico che quel determinato posto é già true(ovvero che 2 persone hanno compiuto gli anni quel giorno) e poi prendo un'altra variabile(o persona) e verifico che anch'essa ha fatto gli anni quel giorno, non ho trovato 3 persone?
Queste cose mi fanno uscire pazzo :ehm:
 
Yosiri ha detto:
@St3ve
Però se verifico che quel determinato posto é già true(ovvero che 2 persone hanno compiuto gli anni quel giorno) e poi prendo un'altra variabile(o persona) e verifico che anch'essa ha fatto gli anni quel giorno, non ho trovato 3 persone?
Clicca per espandere...
Spiegati meglio. Non capisco cosa non hai capito (o cosa non ti convince) di quello che ho scritto.
Parti dal codice che ho scritto io e vedi se le considerazioni che ho fatto ti tornano. Dopodiché paragonalo con il tuo per vedere che quello che stai calcolando è un evento ancora più raro di quello che ho mostrato.

Tu stai chiedendo a due persone (persona i e persona j) se compiono gli anni nello stesso giorno, già questo è sbagliato.
Nel problema del compleanno con 3 persone, devi chiedere ad una persona quando compie gli anni e devi verificare che tra tutte le persone a cui l'hai chiesto in precedenza ce ne siano due che compiono gli anni nello stesso giorno che ti ha detto il nuovo tizio.

Sei già in errore quando chiami due random a fila: devi prendere una persona e confrontarla con tutti i precedenti, non prendere due persone e vedere se c'era un altro tizio che compie gli anni nello stesso giorno di quei due.
(senza contare che quello che ti ho descritto non è proprio quello che stai facendo: dovresti mettere a true anche birthday(j) e modificare un po' l'if, ma vabbé... non è questo il punto.)
 
Se boolean=true quando ci ritorno una seconda volta, ho verificato che almeno due persone abbiano fatto gli anni quel giorno..bene
Con j faccio entrare un altro tizio in gioco, e se con quel determinato valore di i ho verificato che già due persone hanno compiuto gli anni quel giorno, e lo stesso valore é uguale ad un secondo valore j(che rappresenterà una terza persona), allora almeno 3 persone hanno compiuto gli anni quel giorno(secondo il mio ragionamento iniziale)
@St3ve
 
Ok, proviamo con un altra strada. Ti faccio un controesempio:
  • Primo giro del while: i=1, j=123;
  • Secondo giro del while: i=1, j=12;
  • Terzo giro del while: i=1; j=43;
È mai capitato che i==j ? No. Eppure abbiamo chiesto a 6 persone in totale e ce ne sono state 3 che ci hanno detto di aver compiuto gli anni nello stesso giorno.

Il problema è che stai prendendo due persone e gli stai chiedendo se compiono gli anni nello stesso giorno. Il fatto che ci sia anche il terzo (avvenuto in un'iterazione precedente) è secondario.

Se ancora non hai capito prova a farti una rilettura dei post precedenti, mi sembra di ripetere sempre lo stesso concetto. Non capisco cosa ti sfugge.
 
Nel mio ragionamento, ho interpretato la cosa in modo diverso.
Ho trovato due persone che hanno fatto il compleanno lo stesso giorno, quindi "marco" quella casella. Il mio problema però é marcare quella casella con una terza persona che troverò tramite j.
 
Yosiri ha detto:
Ho trovato due persone che hanno fatto il compleanno lo stesso giorno, quindi "marco" quella casella.
Clicca per espandere...
No. Non è quello che stai facendo e non è nemmeno una cosa fattibile.

Qualcuno ti dice che compie gli anni in un certo giorno, quindi marchi quel giorno sul calendario. Quando una seconda persona ti dice di compiere gli anni in un giorno, se quel giorno è già marcato tu sai che è la seconda persona.
Se vuoi fare la verifica con 3 persone, hai bisogno di 3 stati per ogni casella: non marcato, marcato e doppiamente marcato.

Adesso sei convinto? O non hai ancora capito?
 
Ultima modifica:
3 stati? Intendi the variabili random?
Come mai non é quello che sto facendo?Cioé se si verificasse birthday=true, non ho già verificato che due persone mi abbiano detto di fare gli anni nello stesso giorno? E con j non ho una terza persona che fa gli anni in quel giorno?

P.S
Una curiosità: per riuscire a "sviluppare" la capacità di ragionare correttamente che bisogna studiare?
Clicca per espandere...
 
Tre stati, per questo ti ho consigliato di utilizzare un array di int invece che un array di boolean. Quando l'int è 0 vuol dire che nessuno ha il compleanno in quel giorno, quando l'int è 1 vuol dire che 1 persona compie gli anni quel giorno e quando l'int è 2 vuol dire che due 2 persone hanno compiuto gli anni quel giorno.

Arrivare a 3 lo puoi fare, ma non è necessario: se la persona attuale compie gli anni in una casella che vale 2, allora è il terzo e puoi uscire dal ciclo anche senza incrementare il valore della casella.

Non è quello che stai facendo perché i boolean hanno solo 2 stati: true e false.

Se vuoi imparare a ragionare correttamente, conviene fare molta pratica. In questo caso specifico potevi pure usare la matematica per aiutarti, ma in generale devi sempre cercare di testare (magari stampando degli output aggiuntivi, tipo i valori di i e j) i tuoi programmi per capire se funzionano o non funzionano.
 
La soluzione da te proposta é più che ottimale, però non riesco a non capire il perché la mia sia sbagliata(e so che é sbagliata).
Cioé, non é come se oltre alla verifica per due persone, ne stessi aggiungendo una terza?
if(birthday==true(2 persone sono state verificate) && i==j (per quel determinato valore di i sappiamo che due persone fanno gli anni, ma se allo stempo i==j, vuol dire che anche una terza fa gli anni quel giorno)
Che formula di matematica dovrei utilizzare in questo caso?
 
Yosiri ha detto:
Nuovo La soluzione da te proposta é più che ottimale, però non riesco a non capire il perché la mia sia sbagliata(e so che lo é).
Cioé, non é come se oltre alla verifica per due persone, ne stessi aggiungendo una terza?
Clicca per espandere...
Proviamo a fare il contrario, spiegami tu e io ti dico cosa va bene e cosa non va bene.
Fammi capire se hai capito in cosa consiste il problema del compleanno con 2 persone e perché la gente pensa che la probabilità sia bassa quando invece è alta. Dopo prova a spiegarmi in cosa consiste il problema del compleanno con 3 persone.

Cerca di essere dettagliato, perché ho il sospetto che non hai ben chiaro il problema del compleanno con 2 persone. L'errore che stai facendo è il tipico errore che si fa comunemente quando si dice "la probabilità è bassa". In un post precedente te l'ho anche scritto, rileggilo e fammi capire se hai capito.

Yosiri ha detto:
Che formula di matematica dovrei utilizzare in questo caso?
Clicca per espandere...
La formula esatta per calcolare la mediana non è banale, ma si può ottenere una buona approssimazione con la distribuzione di Poisson. Se è roba che non hai mai visto, non perderci tempo. Anche solo capire che non potevi ottenere valori maggiori di 356*2+1 ti avrebbe aiutato a capire che stai sbagliando.
 
Ultima modifica:
@St3ve allora...umh...
Io parto dal fatto che non ho pensato minimamente alla probabilità.
Ho letto cosa mi chiedeva il problema, non l'ho saputo risolvere ed ho visto la soluzione, ovvero:
Codice: 
public class RandomAccess{
public static void main(String args[]){
boolean[] array=new boolean[365];
int count=0;
while(true){
int i=(int) (Math.random()*365);
count++;
if(array[i]==true)
break;
array[i]=true;

}
System.out.println("After "+ count + " tries, two person with the same birthday were found.");


}
}
Naturalmente ho studiato il ragionamento dell'autore per capire quali fossero i passaggi giusti per risolvere questo problema.
Così ho pensato che per trovare una terza persona avrei dovuto fare come ti ho mostrato poco fa.
Perché mi devo calcolare la mediana?
 
Se non hai capito perfettamente in cosa consiste il problema, allora ci sta che non riesci a capire dove sbagli. Se non hai pensato alla probabilità, allora ti sei perso la parte importante che ti evita di fare quell'errore.

La domanda che ci si pone è: "qual'è la probabilità che in una classe di 40 persone ci siano due persone che compiono gli anni nello stesso giorno?". Se facciamo la stessa considerazione che avevamo fatto prima, per ottenere una probabilità del 100% ci servono 356 persone: 365 persone compiono gli anni in giorni differenti (siamo sfortunati), la prossima persona per forza di cose deve compiere gli anni assieme a qualche altra persona (visto che non esiste il 356esimo giorno dell'anno).

Comunemente la risposta a quella domanda è: "è difficile che succeda un evento del genere, in un anno ci sono 356 giorni, per arrivare al 100% abbiamo bisogno di 356 persone e 40 persone sono veramente poche". Al di la delle nostre aspettative, la risposta corretta è: "la probabilità è 90%, sono molto sfortunato se nella mia classe di 40 persone non ci sono due persone che compiono gli anni nello stesso giorno".

Perché ci suona così strano che la probabilità sia addirittura del 90%?
Inconsciamente ci viene da pensare: "qual'è la probabilità che nella mia classe di 40 persone ci sia qualcuno che compie gli anni quando li compio io?". La probabilità in questo caso è molto bassa.

Dove sta l'inghippo? Proviamo a contare quante coppie di persone possiamo formare.
Nella domanda che ci siamo posti inconsciamente (chi compie gli anni assieme a me?) abbiamo solo 39 coppie: {(io, p2), (io, p3), (io, p4), ..., (io, p39)}. Nella domanda vera oltre ad avere le coppie formate da me + uno ad uno ogni altro compagno, abbiamo anche le coppie formate da p2 + ogni altro compagno (escluso me, perché la coppia (io, p2) è uguale a (p2, io)).
Il numero di coppie che posso formare con 40 persone sono ben 780, è questo fatto che rende la stima "a occhio" poco intuitiva.

Nel momento che tu scrivi:
Java: 
int i=(int) (Math.random()*365);  // compleanno della persona i
int j=(int) (Math.random()*365);  // compleanno della persona j

if (i == j)
Stai selezionando tu qual'è la coppia da confrontare. Non stai guardando tutte le possibili coppie (che sono moltissime), ma stai guardando la coppia (i, j) da te estratta.
Se fai un confronto scegliendo le due persone che entrano in gioco (la persona i e la persona j) allora la probabilità è bassa per davvero!

Pensaci un po' su, ci può stare che quando lo vedi per la prima volta sembra strano. Se ancora non capisci cerca di elaborare bene ed essere il più dettagliato possibile, perché fino ad ora sto ribadendo sempre lo stesso concetto. Se non riesco a capire dove ti blocchi, non c'è molto altro che posso scrivere.

Aggiungere un'altra persona è sbagliato perché sei tu che stai selezionando quella persona, non la stai buttando nel mucchio per formare un numero molto più elevato di coppe (o triple nel tuo caso). Ad ogni persona che aggiungi nel mucchio, il numero delle coppie (o triple) cresce enormemente (coefficiente binomiale).
 
Programmando sono abituato a pensare ad un rapporto serieDiComandi:risultato, non so se mi spiego. Probabilmente ragionandoci un parecchio sù sarei venuto anch'io alla soluzione dell' int[] array da te proposta, ma con un ragionamento del tipo: " se accede tre volte a quella cella dell'array ho trovato tre persone bla bla bla".
 
Ultima modifica:
Yosiri ha detto:
@St3ve allora...umh...
Io parto dal fatto che non ho pensato minimamente alla probabilità.
Ho letto cosa mi chiedeva il problema, non l'ho saputo risolvere ed ho visto la soluzione, ovvero:
Codice: 
public class RandomAccess{
public static void main(String args[]){
boolean[] array=new boolean[365];
int count=0;
while(true){
int i=(int) (Math.random()*365);
count++;
if(array[i]==true)
break;
array[i]=true;

}
System.out.println("After "+ count + " tries, two person with the same birthday were found.");


}
}
Naturalmente ho studiato il ragionamento dell'autore per capire quali fossero i passaggi giusti per risolvere questo problema.
Così ho pensato che per trovare una terza persona avrei dovuto fare come ti ho mostrato poco fa.
Perché mi devo calcolare la mediana?
Clicca per espandere...
Quell'algoritmo, come dice anche il println, ti trova 2 persone quindi sfrutta appunto il concetto che ti ha spiegato prima Steve degli stati delle caselle del calendario: genera un indice(che indica il compleanno di una persona), pone l'iesimo elemento a true, e continua...se capita un indice già capitato prima, guarda se l'iesimo elemento è settato a true, quindi hai trovato 2 persone ed esce.

Per farlo con 3 persone, come diceva Steve prima ti servono 3 stati.. Il tipo li ne utilizza 2(true e non true; attenzione ho detto NON true, quindi non per forza è false perciò può essere anche null dato che non inizializza l'array). Con questo ragionamento potrebbe bastare un array di boolean ma dato che a volte, tipo in c++, un valore NULL e uno false li considera uguali non è fattibile con un array di bool.L'unica scelta che rimane è un array di interi e utilizzare 2 stati o 3 se devi fare altre operazioni
1= trovata 1 persona
2= trovata 2 persona
Appena la terza genera un indice che ha già val 2, si esce dal ciclo(proprio per questo 3 stati sono inutili, nel bastano 2) dato che hai trovato 3 persone con lo stesso compleanno, oppure setti la casella con stato 3 se vuoi fare altre operazioni


Ti ho fatto un piccolo esempio in c++, con una piccola modifica dell'algoritmo che tu hai postato del tipo dal quale hai preso spunto, dato che volevi risolvere il problema modificando quel algoritmo

Utilizzo 2 stati
PHP: 
#include<iostream>
#include<time.h>
#include<stdlib.h>
#include<random>
#include<functional>
int main ()

{
int j[365];

    for(int i =0;i<365;i++){
       j[i]=NULL;

        }
   srand(time(NULL));
    std::random_device rd;
std::default_random_engine randomizer(rd()); std::uniform_int_distribution<int> range(1,365);
    auto dice =std::bind(range,  randomizer);
int d=0;
    int k;
    while(true)
    {
   
    d=dice();

      //  std::cout<<d<<std::endl;
   
  if(j[d]==1||j[d]==2)
   
  {
if(j[d] == 2){ k=d;break;}
        j[d]=2;

   
  }else {j[d]=1;}
 
}
   std::cout<<"3 founded on "<<k<<std::endl;;

    for(int h=0;h<365;h++) std::cout<<j[h]<<std::endl;
    EXIT_SUCCESS;
    return 0;
}

L'hai capito?
 
Stato
Discussione chiusa ad ulteriori risposte.
Top Bottom
Indietro