Boucle pour vérifier le numéro en double

Question

J'ai besoin de conseils (pas la réponse).

Mon affectation actuelle nécessite que je vérifie (int first, int second ... int quinte), pour les nombres dupliqués en utilisant int pick.

utilisateur doit entrer les numéros 2 (un numéro est une gamme de 1 à 100 et le second nombre est égal à 1-6), puis i randomiser la sortie en utilisant les informations qu'ils fournissent

Exemple Num1 = 49 Num2 = 3 sortie: 4, 40, 30.

je besoin d'un moyen de vérifier si "pick" (le nombre aléatoire généré), ne dédouble pas contre int première, int seconde et ainsi de suite.

Je peux utiliser un tas d'instructions if pour valider la sélection par rapport à la première, à la seconde, etc. Je ne voudrais pas faire cela car c'est beaucoup de code. Je me demandais s'il y avait un moyen que je pourrais utiliser une boucle pour le faire?

Tout conseil serait apprécié, ce sont les devoirs, mais je ne cherche pas la réponse juste un indice ou un conseil.

Je peux poster un code que j'ai si nécessaire.

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



int validate(int low, int high) { 
    int flag = 0, number = 0; 
    do 
    { 
     scanf(" %d", &number); 
     if (number <= low || number > high) 
     { 
      printf("INVALID! Must enter a value between %d and %d: ", low, high); 
     } 
     else { 
      flag = 1; 
     } 
    } while(flag == 0); 
    return number; 
} 

int getRand(int max) { 
    int number, i; 
    number = rand() % max + 1; 
    return number; 
} 
int validatePick(int pick, int first, int second, int third, int fourth, int fifth) { 
    int valid; 

    do { 
     if (pick 

} 
void prnt(int qty, int first, int second, int third, int fourth, int fifth, int sixth); 
int sort2(int *n1, int *n2); 


main() { 
    int num1, num2, count = 0; 
    int pick, first = second = third = fourth = fifth = 0; 

    printf("LOTTERY GENERATOR\n"); 
    printf("Enter the maximum value between 1 and 100: "); 
    num1 = validate(1,100); 
    printf("Enter quantity of numbers to pick, between 1 and 6: "); 
    num2 = validate(1, 6); 

    srand(time(NULL)); 
    printf("Picks: %c", ' '); 
    while (count < num2) { 
     getRand(num1); 

     count++; 
    } 
} 

Answer 1

Vous pouvez créer une table de hachage de base pour stocker vos numéros et vérifier les doublons assez facilement.

typedef struct HashElement 
{ 
    int data; 
    HashElement* next; 
} HashElement; 

typedef struct HashTable 
{ 
    int size; 
    HashElement** table; 
} HashTable; 

HashTable* allocateHashTable(int size) 
{ 
    HashElement** table = malloc(sizeof(HashElement*) * size); 

    for (int count = 0; count < size; count++) 
    { 
     table[count] = NULL; 
    } 

    HashTable* hashTable = malloc(sizeof(HashTable)); 

    hashTable->size = size; 
    hashTable->table = table; 

    return hashTable; 
} 

HashElement* allocateHashElement(int value) 
{ 
    HashElement* element = malloc(sizeof(HashElement)); 

    element->data = value; 
    element->next = NULL; 

    return element; 
} 

void freeHashTable(HashTable* hashTable) 
{ 
    //to do 
} 

void freeHashElement(HashElement* element) 
{ 
    //to do 
} 

void insertValue(HashTable* hashTable, int value) 
{ 
    //to do 
} 

int hash(int value, int size) 
{ 
    return value % size; 
} 

int elementExists(HashTable* hashTable, int value) 
{ 
    int index = hash(value, hashTable->size); 

    HashElement* current = hashTable->table[index]; 

    while (current != NULL) 
    { 
     if (current->data == value) 
      return 1; 

     current = current->next; 
    } 

    return 0; 
} 

Edit 1:

Vous pouvez ajouter vos 5 numéros ou quoi à la table de hachage, et changer votre fonction à ceci:

int validatePick(int pick, HashTable* hashTable) { 
    return (elementExists(hashTable, pick) : 0 ? 1); 
} 

Bien que, une table de hachage peut être exagérer si vous avez seulement 5 éléments. Il semble qu'un simple tableau suffise, mais vous avez mentionné que les tableaux sont interdits.

Edit 2:

Alors:

1. Les tableaux sont interdits.
2. Les structures de données sont trop complexes.
3. Vous voulez réduire le code.

Donc, si vous ne voulez pas juste un tas de gros blocs if ...

int validatePick(int pick, int one, int two, int three, int four, int five) { 
    return ((pick == one) : 0 ? 
     ((pick == two) : 0 ? 
     ((pick == three) : 0 ? 
     ((pick == four) : 0 ? 
     ((pick == five) : 0 ? 1))))); 
}