[C] Problema con i numeri casuali che non devono essere ripescati.

[raffaeledicapri]

Ciao a tutti, sto lavorando ad un programma che mi estragga 21 numeri casuali che però non si devono ripetere per un gioco di carte, fino ad ora sono riuscito a scrivere questo:

#include <stdlib.h>
#include <time.h>
#include <stdio.h>
int a[21],b,e,f,g,h,i,l,c,cont;
main()
{
      
      c=1;
      srand((unsigned)time(NULL));
      a[0]=rand() % 70+1; 
      for(b=1;b<21;b=b+1)
      {
      a[b]=rand() % 70+1;
      while(c!=0)
      {
      c=0;
      for(cont=b;cont>-1 || c!=0;cont=cont-1)
      {
       if(a[cont]==a[cont-1])
       {
       a[cont]=rand() % 70+1;
       c=1;
       }
      }
      }
      }

tralasciando le variabili iniziali che mi servono per un procedimento che devo fare dopo.. con questo codice i numeri spuntano diversi soltanto che solo 2 rimangono uguali.. è un problema del srand o è il codice che non funge? grazie a tutti

[minomic]

Ciao,
la funzione rand, come suggerisce il nome, genera numeri casuali (in realtà pseudo-casuali), quindi tu, giustamente, non hai il controllo sui numeri generati.
Quello che puoi fare per evitare numeri ripetuti è continuare a "estrarre" (cioè generare) un nuovo numero fino a quando non ne trovi uno che vada bene.

Quindi l'algoritmo può essere il seguente:
1. generi un numero
2. scorri l'array dove memorizzi i numeri casuali
3. se il numero non è presente allora lo inserisci e torni al passo (1)
4. se il numero è già presente ne generi un altro e torni al passo (2)

[raffaeledicapri]

E come dovrei fare? :/ puoi fare un esempio rapido? è 2 ore che ci sto sopra e sto fondendo lol

[minomic]

Scritto al volo, quindi con possibili errori.

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


#define MAX 100


/* funzione che ritorna 1 se "num" e' presente in "array"
 * e 0 se invece non e' presente */
int controlla_presenza(int *array, int size, int num)
{
    int i;
    for(i=0; i<size; ++i)
    {
        if(array[i] == num)
            return 1;
    }
    return 0;
}


/* funzione che genera un array di numeri casuali e non ripetuti */
int * genera_casuali(int size)
{
    int *array = (int *) malloc(size * sizeof(int));
    int i, generato, riempito = 0;


    for(i=0; i<size; ++i)
    {
        array[i] = 0;       /* inizializzazione a zero */
    }


    for(i=0; i<size; ++i)
    {
        do
        {
            generato = rand() % MAX + 1;
        } while(controlla_presenza(array, size, generato) == 1);
        array[riempito++] = generato;
    }


    return array;
}




void stampa_array(int *array, int size)
{
    int i;
    for(i=0; i<size; ++i)
        printf("%d\n", array[i]);
}


int main()
{
    srand(time(NULL));
    int size;


    printf("Inserire dimensione: ");
    scanf("%d", &size);


    int *casuali = genera_casuali(size);
    stampa_array(casuali, size);


    return 0;
}

[raffaeledicapri]

mmm bene ahah grazie mille per la risposta purtroppo non sono ancora a questi livelli di C quindi mi dovrò arrangiare :/ vediamo se riesco a convertirlo ad un "c base" che posso capire ahah grazie mille

[minomic]

Forse ti sembra strano perché l'ho fatto con l'allocazione dinamica. Però se tu sai già che il numero di elementi è 21 puoi farlo anche con l'allocazione statica, cioè dichiarando l'array come avevi fatto.
Tu prova e poi ci fai sapere.

PS. Mi sono accorto che la variabile "riempito" non serviva a nulla... l'avevo detto che l'avevo scritto al volo!

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


#define MAX 100


/* funzione che ritorna 1 se "num" e' presente in "array"
 * e 0 se invece non e' presente */
int controlla_presenza(int *array, int size, int num)
{
    int i;
    for(i=0; i<size; ++i)
    {
        if(array[i] == num)
            return 1;
    }
    return 0;
}


/* funzione che genera un array di numeri casuali e non ripetuti */
int * genera_casuali(int size)
{
    int *array = (int *) malloc(size * sizeof(int));
    int i, generato;


    for(i=0; i<size; ++i)
    {
        array[i] = 0;       /* inizializzazione a zero */
    }


    for(i=0; i<size; ++i)
    {
        do
        {
            generato = rand() % MAX + 1;
        } while(controlla_presenza(array, size, generato) == 1);
        array[i] = generato;
    }


    return array;
}


/* funzione che stampa un array di interi */
void stampa_array(int *array, int size)
{
    int i;
    for(i=0; i<size; ++i)
        printf("%d\n", array[i]);
}


/* main */
int main()
{
    srand(time(NULL));
    int size;


    printf("Inserire dimensione: ");
    scanf("%d", &size);


    int *casuali = genera_casuali(size);
    stampa_array(casuali, size);


    return 0;
}

[Scara95]

mmm bene ahah grazie mille per la risposta purtroppo non sono ancora a questi livelli di C quindi mi dovrò arrangiare :/ vediamo se riesco a convertirlo ad un "c base" che posso capire ahah grazie mille

Guarda che questa domanda è stata afforontata svariate altre volte. Ed esiste un algoritmo più efficiente. Basta che fai una ricerca nel forum. In sostanza prendi un array di N elementi che contiene tutte le possibili scelte, generi un indice casuale i fra 0 e N-1 scambi gli elementi i e N-1 e diminuisci N di uno quindi ritorni l'elemento che originariamente si trovava in i.
Eccoti un esempio di una possibile implementazione in C che usa delle variabili globali per semplicità. Il main è un esempio e l'output te ne fa vedere il funzionamento

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

#define N 5

int nums[N];
int n;

void init_gen() {
    int i;
    for(i = 0; i < N; ++i) {
        nums[i] = i+1;
    }
    n = N;
}

void reset_gen() {
    n = N;
}

int gen() {
    //nel caso tutti i numeri siano stati generati segnala un uso innappropriato
    if(n < 1) {
        return -1;
    }
    int i = rand() % n;
    --n;
    int tmp = nums[i];
    nums[i] = nums[n];
    nums[n] = tmp;
    return tmp;
}


int main(void) {
    srand(time(NULL));
    init_gen();
    int i, j;
    for(i = 0; i < 6; ++i) {
        for(j = 0; j < 6; ++j) {
            printf("%d ", gen());
        }
        printf("\n");
        reset_gen();
    }
    return 0;
}

Output di esempio

1 4 5 2 3 -1 
4 2 5 1 3 -1 
3 2 1 5 4 -1 
4 5 1 3 2 -1 
1 2 4 5 3 -1 
5 4 3 2 1 -1

Per risolvere il tuo problema ti basta sostanzialmente cambiare N, ma il codice è facilmente addattabile a casi più complessi in cui gli elementi generati/mescolati non sono semplici numeri.

[raffaeledicapri]

Ho riassunto ciò che avete scritto in un linguaggio "base" che posso capire (sono ancora un nabbo, ma mi piace molto il linguaggio e lo studierò approfonditamente) e adesso.. FUNZIONA se siete curiosi vi lascio il codice qui riportato:
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
int a[21],b,e,f,g,h,i,l,c,cont;
main()
{

for(i=0;i<21;i=i+1)
{
c=rand() % 70+1;
b=0;
while(b!=21)
{
if(a[b]!=c)
{
b=b+1;
}
if(a[b]==c)
{
c=rand() % 70+1;
b=0;
}
}
a[i]=c;
}