Как проверить, чтобы убедиться, что нет повторов при генерации 6 случайных чисел?

Question

Я могу получить случайные числа в массив, но я не могу понять, как проверить, чтобы они не повторялись.Я печатаю код, но в массиве нет чисел (ничего не печатается).

//puts random numbers into an array
i = 0, j = 0;
srand(time(NULL));
for (i = 0; i < arrSize; i++)
{
  randArr[i] = randNums(1,50);
}

i = 0;
for(i = 0; i < arrSize; i++)
{
  printf("%d ", randArr[i]);
}

printf("\n\n");

//checks to make sure there are no duplicates
i = 0, j = 0, k = 0, temp = 0;
for (i = 0; i < arrSize; i++)
{
  for (j = 1; j <= arrSize;)
  {
    if (randArr[j] == randArr[i])
    {
      for (k = j; k <= arrSize; k++)
      {
        temp = randNums(1,50);
        randArr[k + 1] = temp;
      }
      arrSize--;
    }
    else
      j++;
  }
}

//generates random numbers between the inputed max and min
int randNums(int min, int max)
{
  int result = 0, low = 0, high = 0;
  if (min < max)
  {
    low = min;
    high = max + 1;
  }
  else
  {
    low = max + 1;
    high = min;
  }
  result = (rand() % (high - low)) + low;
  return (result);
}

Answer 1

Как и этот ответ , вы можете сделать выборку отклонения , но равномерное распределение фиксированного числа выборок идеально подходит для очень простого хэш-набора. (Хотя асимптотическое время выполнения может быть несущественным для n=6.)

#include <stdlib.h> /* (s)rand */
#include <stdio.h>  /* printf */
#include <time.h>   /* clock */
#include <assert.h> /* assert */

/* Double-pointers are confusing. */
struct Reference { int *ref; };

/* Simple fixed hash set. */
static struct Reference bins[256];
static int nums[6];
static const size_t no_bins = sizeof bins / sizeof *bins,
    no_nums = sizeof nums / sizeof *nums;
static size_t count_num;

/* Uniformly distributed numbers are great for hashing, but possibly clump
 together under linear probing. */
static size_t hash(const int n) { return ((size_t)n * 21) % no_bins; }

/* Linear probing. */
static struct Reference *probe(const int n) {
    size_t bin_index;
    struct Reference *bin;
    assert(sizeof bins > sizeof nums);
    for(bin_index = hash(n); bin = bins + bin_index,
        bin->ref && *bin->ref != n; bin_index = (bin_index + 1) % no_bins);
    return bin;
}

/* Return whether it's a new value. */
static int put_in_set(const int n) {
    struct Reference *bin = probe(n);
    int *num;
    assert(count_num < no_nums);
    if(bin->ref) return 0; /* Already in hash. */
    num = nums + count_num++;
    *num = n;
    bin->ref = num;
    return 1;
}

/* http://c-faq.com/lib/randrange.html */
static int rand_range(const unsigned n) {
    unsigned int x = (RAND_MAX + 1u) / n;
    unsigned int y = x * n;
    unsigned int r;
    assert(n > 0);
    do {
        r = rand();
    } while(r >= y);
    return r / x;
}

/* Generates random numbers between the inputed max and min without
 repetition; [min, max] inclusive. */
static int unique_uniform(const int min, const int max) {
    int n;
    assert(min <= max && (size_t)(max - min) >= count_num);
    do { n = rand_range(max - min + 1) + min; } while(!put_in_set(n));
    return n;
}

int main(void) {
    int n = 6;
    srand((int)clock()), rand(); /* My computer always picks the same first? */
    while(n--) { printf("%d\n", unique_uniform(1, 50)); }
    return EXIT_SUCCESS;
}

Однако, если числа плотно упакованы (например, unique_uniform(1, 6),), они отклонят много чисел. Другое решение состоит в том, чтобы принять распределенные числа Пуассона в качестве промежуточной суммы (повторение T(n+1)=T(n)+\mu_{n+1},), где ожидаемое значение - это диапазон чисел, разделенных на общие выборки, а затем принять случайную перестановку .

Answer 2

Осторожно!Есть много разных решений этой проблемы, и все они имеют один или другой недостаток.Если бы я быстро реализовал это, я бы пошел на что-то вроде этого (без излишней магии C):

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

#define SIZE (30)
#define RAND_MIN (1)
#define RAND_MAX (50)

static int randNums(int min, int max) {
  // ...
}

int main(void) {
  (void) srand(time(NULL));
  int arr[SIZE];
  int used = 0;
  while (used < SIZE) {
    int  num    = randNums(RAND_MIN, RAND_MAX);
    bool exists = false;
    for (int i = 0; i < used; ++i) {
      if (arr[i] == num)
        exists = true;
    }
    if (exists == false)
      arr[used++] = num;
  }
  for (int i = 0; i < SIZE; ++i)
    (void) printf("%d\n", arr[i]);
  return EXIT_SUCCESS;
}

Надеюсь, это немного поможет:)