algoritmo tombola in c. chi mi da una mano?Grazie

[robs05]

ragazzi ho letto i post e vi ringrazio....però vorrei procedere a passi.

prima di tutto adesso sto cercando di realizzare un algoritmo per la creazione delle cartelle.....come posso riempire la casella che nella cartella della tombola nn contiene nessun numero?

[yorkeiser]

Se lavori con strutture ad interi ci puoi mettere uno 0, altrimenti qualsiasi numero non compreso tra 1 e 90

[robs05]

quindi

typedef struct cartella
{
int righe[3];
int colonne[9];
}

[robs05]

scusa typedef è satto un lapsus

[yorkeiser]

E' un'idea, puoi progettarlo come meglio credi, anche a stringhe al posto dei numeri se lo preferisci. Il typedef lo puoi usare senza problemi

main()
{

typedef int bool;

typedef struct
{
    int numero;
    bool uscito;
} def_cartella;

def_cartella cartella [3][5]; //array di struct (da dove esce il 9 ??)

cartella[0][0].numero=12;
cartella[0][0].uscito=0; //false
cartella[1][0].numero=15;
printf("%d",cartella[0][0]);
printf("%d",cartella[1][0]);

oppure te lo fai coi puntatori, è lo stesso con la differenza che ti allochi la memoria dinamicamente, nel caso volessi avere un numero imprecisato di giocatori o ne vuoi aggiungere a runtime

def_cartella* cartella;
cartella=(def_cartella*)malloc(3*5*sizeof(def_cartella));
cartella->numero=12;
(cartella+1)->numero=15;
printf("%d",cartella->numero);
printf("%d",(cartella+1)->numero);

Questa è solo un'idea, lo puoi fare in tanti modi

[robs05]

sto cercando prima di creare una cartella.
solo ceh la funzione rand nn va bene...questo è un abozzo adeso dovrei are in modo ceh per ogni riga ci sia un numero diverso per decina e che nn compare due volte lo stesso numero..
giusto?

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

void main()
{

srand(time(NULL));

int i,j;    
    struct cartella
    {
    int c1[3];
    int c2[3];
    int c3[3];
    int c4[3];
    int c5[3];
    };
struct cartella uno;


for(i=0;i<5;i++)
    uno.c1[i]=1+rand()%90;
        
    for(j=0;j<3;j++)   
       {
       for(i=0;i<5;i++)
          {
          printf(" %d",uno.c1[i]);    
          }
        printf("\n");
        }  

system("pause");
return 0; 

}

[cionci]

Il modo più semplice è usare la stessa funzione di estrazione che ti ho postato nella pagina prima (magari modificandola estraendo le strutture dati static ed infilandole in una struct per poterle utilizzare in estrazioni diverse azzerando la struttura dati)...

Fai le estrazioni usando la funzione che ti ho postato prima e ti tieni il conto dei numeri estratti per ogni decina (basta un vettore di 10 elementi per 3 righe), se il numero estratto all'i-esima estrazione appartiene ad una decina con già 3 elementi estratti non ne tieni di conto, lo scarti ed esegui nuovamente l'i-esima estrazione.

Attento che la tombola ha una concezione particolare di "decina", da 1-9 sono della prima decina, ma da 80 a 90 sono della nona, mentre per le restanti vanno da x0 a x9. Credo che tu debba tenere conto anche di questo.

Per memorizzare le cartelle di bastano 3 vettori da 5 elementi. Saprai in quale vettore dovrai andare ad inserire l'elemento estratto sfruttando il contatore delle decine ed il contatore degli elementi in ogni vettore.

Ricapitolando, ti serve una struttura di questo tipo:

int cartella[3][5];

int contatori_riga[3];
int flag_decine[3][10];

Estraggo un numero da 1 a 90 senza ripetizione (vedere l'algoritmo precedente).

int riga = 0;
La riga dove andrò ad inserire l'elemento sarà data da:

- per ogni contatore_riga == 5 incremento di 1 "riga"
- per ogni riga a partire del valore corrente di "riga" che ha già la decina estratta presente, incrementi "riga" di 1
- se "riga" è = 3 significa che tale decina è presente in ogni riga e scarti l'estratto, altrimenti vai ad inserire l'estratto nella riga "riga" e nella casella "contatore_riga", incrementi "contatore_riga", metti un 1 nella posizione corrispondente di "flag_decine".

E' più semplice a farsi che a dirsi.

[robs05]

int estratto = estrai_da_0_a_N(89 - estrazioni);


nn riesco a capire questo

[cionci]

La puoi sostituire con una qualsiasi funzione che genera valori random da 0 a N...ad esempio: rand()%(90-estrazioni)
Oppure con una qualsiasi trattata qui: http://www.hwupgrade.it/forum/showthread.php?t=1196677

[cionci]

Per farti capire cosa volevo dire nella prima parte del post per "estrazione della struttura dati static":

struct estrazione
{
   int estratti[90];
   int numero_estrazioni;
};


int estrai_numero(struct estrazione *e)
{	
	int i = 0;
	int estratto = estrai_da_0_a_N(89 - e->numero_estrazioni);

	for(i = 0; i <= estratto; ++i)
		estratto += e->estratti[i];

	e->estratti[estratto]++; 
	e->numero_estrazioni++;
	estratto++; //lo riporto da 1 a 90
  
        return estratto;
}

La struttura deve essere azzerata per iniziare una nuova serie di estrazioni.
Quindi la dovrai azzerare per ogni cartella e per l'estrazione dei numeri durante il gioco.
Ovviamente la funzione dovrai chiamarla in questo modo:

struct estrazione e;
....
....
estratto = estrai_numero(&e);

[corzand]

Originariamente inviato da Ziosilvio

Il gioco è un po' più complicato di quanto sembra.

Le cartelle della tombola hanno nove colonne e tre righe, e su ogni riga devono esserci esattamente cinque numeri, mentre su ogni colonna deve esserci almeno un numero (questa condizione non c'è nella traccia dell'esercizio). Per cui, devi considerare anche l'opzione in cui una casella non contiene nessun numero.
(In realtà, la tombola tradizionale ha 48 cartelle prestabilite; potresti usare quelle.)

Inoltre, questo è un caso in cui ti serve che la probabilità di estrazione dei numeri sia uniformemente distribuita, per cui un brutale "1+(rand()%90)" non va bene.
La cosa più semplice, credo sia mettere i numeri da 1 a 90 in una lista, e poi rimuoverli man mano che vengono estratti. Per estrarre un numero,
- ti metti all'inizio della lista,
- scorri in avanti di un numero di posizioni scelto a caso, e
- estrai quel numero dalla lista.
Se fai così, ti servono un contatore del numero di elementi nella lista, e una funzione che, dato N, ti genera un valore equidistribuito tra 0 ed N-1. Fai un salto nella sottosezione "tutorial" e cerca quello sulle sequenze pseudorandom.

Chiedi troppo: qui non si fanno i compiti altrui.

Sto preparando proprio ora un progetto di un'applicazione che simuli appunto il gioco della tombola..
Il problema maggiore è sicuramente quello di generare le cartelle, in quanto l'algoritmo è più complesso di quel che si pensa..

Avevo pensato ad una cosa del genere:
- Ciclo for di 90 iterazioni
- Una lista da cui ogni iterazione vado a pescare un numero.
- Una lista con 6 cartelle vuote (Matrici 3x9 di interi).
- Tento di aggiungere quel numero ad una cartella estratta casualmente tra le 6. *
- Se non riesco ad aggiungere provo su un'altra cartella.
- Alla fine di ogni iterazione controllo se e quali cartelle sono state completate, e le rimuovo dalla Lista.

* Il problema è nel metodo di aggiunta del numero cartella..

	public boolean addNumber(int num)
	{
		int columnIndex = (num == 90 ? 8 : num/10);
		int rowIndex;
		for (rowIndex= 0; rowIndex< 3 && tabNums[rowIndex][columnIndex]!=0; rowIndex++);
		if (rowIndex == 3)
			return false;
		else
		{
			while(rowIndex <= 2)
			{
				int contRow=0;
				for(int i=0; i<9;i++)
				{
					if( tabNums[rowIndex][i]!=0)
						contRow++;
				}
				if(contRow  == 5)
					rowIndex ++;
				else if(tabNums[rowIndex][columnIndex] == 0)
				{
					tabNums[rowIndex][columnIndex]=num;
					return true;
				}
				else
				{
					rowIndex++;
				}
			}
			return false;
		}
	}

ovviamente come ben capirete l'algoritmo è in java..
Ebbene, ciò che non riesco a controllare è come imporre che per ogni colonna vi sia almeno un numero..
Spero possiate aiutarmi, ciao!