Генерирование уникальных случайных чисел заданной суммы

@names1995 · Регистрация: 13.11.2012

Author24 — интернет-сервис помощи студентам

Здорова ребят, есть такой код, которые генерирует уникальные числа, необходимо что сгенерированные числа, т.е их сумма была равна переменной numbers, закицлился на этот моменте.

C++

#include "pch.h"
#include <iostream>
#include <Windows.h>
#include <ctime>
using namespace std;
 
int main()
{     
    SetConsoleOutputCP(1251);
    SetConsoleCP(1251);
    srand(time(NULL));
    int *numbers = new int;
    cout << "Введите число от 15 до 240: ";
    cin >> *numbers;
    if (*numbers > 14 && *numbers < 240) { 
        const int size = 5;
        int *arr = new int[size]; 
        bool chek_arr;
        int sum = 0;
        for (int i = 0; i <size;) { 
            chek_arr = false;
            int num_rand =  1 + rand() % 50; 
            for (int j = 0; j < i; j++) {
                if (arr[j] == num_rand) { 
                    chek_arr = true;
                    break;
 
                      }
            }   
            if (!chek_arr) {  
                sum += num_rand;  
                if ( sum == *numbers )
                arr[i] = num_rand;
                i++;
                }
            
                        
                        
        }
        for (int i = 0; i < size; i++) {
            cout << " " << arr[i] << endl;
        } 
 
        delete numbers;
        delete[] arr;
        
    } 
    else {
        cout << "Вы вышли за диапазон\n";
    }
}

@zss · 07.04.2019, 18:38

Это что-то слишком мудрено.
Генерите просто size-1 чисел,
а в arr[size-1] запишите разность между number и суммой всех остальных.

Не по теме:

зачем под number память выделяете динамически?

@Clever411 · 07.04.2019, 18:39

Я возможно что-то не понял... Но вроде бы так вот работает:

C++

#include <iostream>
#include <random>
 
 
using namespace std;
 
 
 
 
 
// main
int main( int argc, char *argv[] )
{
    srand(time(0));
 
    int number;
    cin >> number;
 
    int const first = rand()%number;
    int const second = number - first;
 
    cout << first << ", " << second << endl;
    cout << first+second << endl;
 
 
 
    return 0;
}
 
 
 
 
 
// end

@XLAT · 07.04.2019, 18:53

Сообщение от Clever411

Я возможно что-то не понял.

вы правильно поняли zss )

Но если, по коду автора проинженерить задачу, то вот:
Генерируются массив из 5 случайных уникальных чисел от 1 до 50.
Этот массив будет считаться true-настоящим, если сумма элементов этого массива будет равна переменной *numbers.

@names1995 · 07.04.2019, 20:05 **[ТС]**

попробуем щас

Добавлено через 11 минут
можете код дать? у меня что-то не получается ) не совсем понял

@Clever411 · 07.04.2019, 21:05

XLAT, Окей, понял, нужно несколько чисел, сумма которых...
names1995, Сейчас попробую написать код

Добавлено через 5 минут
Окей... Можно вот так. Только распределение будет не очень равномерным.

C++

#include <iostream>
#include <random>
 
 
using namespace std;
 
 
 
 
 
// main
int main( int argc, char *argv[] )
{
    static constexpr int const N = 5;
 
 
 
    // prepare
    int number;
    cin >> number;
    int arr[N] = { 0 };
 
 
 
    // calc
    for(int i = 0; i < N-1; ++i)
    {
        arr[i] = rand()%number;
        number -= arr[i];
    }
    arr[N-1] = number;
 
 
 
    // output
    int summ = 0;
    for(int i = 0; i < N; ++i)
    {
        cout << arr[i] << " ";
        summ += arr[i];
    }
    cout << endl;
    cout << "summ: " << summ << endl;
 
 
 
 
    return 0;
}
 
 
 
 
 
// end

@names1995 · 07.04.2019, 21:08 **[ТС]**

да, получается неравномерное распределение, теряется уникальность

@Clever411 · 07.04.2019, 21:13

А вот здесь всё равномерно, только сложность O(number):

C++

#include <iostream>
#include <random>
 
 
using namespace std;
 
 
 
 
 
// main
int main( int argc, char *argv[] )
{
    static constexpr int const N = 5;
 
 
 
    // prepare
    int number;
    cin >> number;
    int arr[N] = { 0 };
 
 
 
    // calc
    for(int i = 0; i < number; ++i)
        ++arr[rand()%N];
 
 
 
    // output
    int summ = 0;
    for(int i = 0; i < N; ++i)
    {
        cout << arr[i] << " ";
        summ += arr[i];
    }
    cout << endl;
    cout << "summ: " << summ << endl;
 
 
 
 
    return 0;
}
 
 
 
 
 
// end

@names1995 · 07.04.2019, 21:18 **[ТС]**

спасибо, но в данном решение опять таки не наблюдается уникальность, все пять чисел должны быть уникальны, и вопрос как понять эту строчку, думаю достаточно туда добавить проверку на уникальность в эту часть кода

C++

1 2	for(int i = 0; i < number; ++i) ++arr[rand()%N];

@Clever411 · 07.04.2019, 21:21

Ах... Уникальность!!! А я и забыл! А "rand()%N" надо понимать как случайное число принадлежащее интервалу [0; N), ++i - я думаю объяснять не надо

@names1995 · 07.04.2019, 21:25 **[ТС]**

да, строчку догнал, но уникальность

@Clever411 · 07.04.2019, 21:28

Этот вариант лучше, т.к. сложность его - O(N). А уникальность... надо подумать

C++

#include <iostream>
#include <random>
 
 
using namespace std;
 
 
 
 
 
// main
int main( int argc, char *argv[] )
{
    static constexpr int const N = 5;
 
 
 
    // prepare
    int number;
    cin >> number;
    int arr[N] = { 0 };
    float arrf[N] = { 0.0f };
 
 
 
    // calc
    float summf = 0.0f;
    for(int i = 0; i < N; ++i)
    {
        arrf[i] = float(rand())/RAND_MAX;
        summf += arrf[i];
    }
 
    int summ = 0;
    for(int i = 0; i < N-1; ++i)
    {
        arr[i] = arrf[i] / summf * number;
        summ += arr[i];
    }
    arr[N-1] = number - summ;
    summ += arr[N-1];
 
 
 
    // уникальность
    // ...
 
 
 
    // output
    for(int i = 0; i < N; ++i)
    {
        cout << arr[i] << ' ';
    }
    cout << endl;
    cout << "summ: " << summ << endl;
 
 
 
 
    return 0;
}
 
 
 
 
 
// end

@names1995 · 07.04.2019, 21:41 **[ТС]**

в моем коде уникальность была, но сумма не была равна заданной сумме

@XLAT · 10.04.2019, 10:41

names1995,

C++

///ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
/// Генерирование уникальных случайных чисел заданной суммы                    |
///ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
#include <iostream>
#include <conio.h>
#include <time.h>
 
#define FOR(v)     for(size_t i = 0; i < v; ++i)
#define SHOW(v)    std::cout << #v << " = "<< v << "\n"
#define SH(v)      std::cout << v
 
///----------------------------------------------------------------------------|
///  Шаблон динамического массива.
///----------------------------------------------------------------------------:
template<class T>
class cDynamicArray 
{
public:
    cDynamicArray() : p(NULL), size(0){}
    cDynamicArray(size_t s): size(s)
    {   p = new T[size];
    }
   ~cDynamicArray()
    {   if (p) delete[] p;
    }
 
    //-------------------------------------------------------------------------|
    size_t size; // Размер массива.
    T*     p;    // Адрес массива с первым элементом.
 
    //-------------------------------------------------------------------------|
    cDynamicArray& operator=(cDynamicArray & _m)
    {   for (size_t i = 0; i < size; ++i)
        {   p[i] = _m.p[i];
        }
        return *this;
    }
    T& operator[](size_t v)  
    {   return p[v];
    }
    // Изменяем размер массива.
    void cDynamicArray<T>::resize(size_t _i)
    {   if (p) delete[] p;
        size = _i;
        p = new T[size];
    }
};
 
///----------------------------------------------------------------------------|
/// cRand_uniq
/// Генератор уникальных целых чисел из заданного диапазона.
///----------------------------------------------------------------------------:
class cRand_uniq
{
public:
    struct sDiapazon
    {   int min, maxx;
    };
 
    cRand_uniq(sDiapazon _dp) : nmax (_dp.maxx),
                                field(_dp.maxx+1 - _dp.min)
    {   dp = _dp;//number.resize(dp.maxx+1 - dp.min);
        FOR(field.size)
        {   field[i] = i + dp.min;
        }
    }
 
    void gen(cDynamicArray<int>& a )
    {   FOR(a.size)
        {   a[i] = work();
        }
    }
 
    void test()
    {   cDynamicArray<int> m(10);
        gen(m);
 
        FOR(10)
        {   SHOW(m[i]);
        }
        std::cout << "\n";
    }
 
private:
    //---------------------------------------------------------------------data:
    sDiapazon          dp;
    cDynamicArray<int> field;
    int                nmax;
    
    int work()
    {   if(nmax == dp.min)
        {   std::cout << "Error: Диапазон исчерпан!\n";
            return -1;
        }
 
        int n           = rrand(dp.maxx, dp.min);
        int res         = field[n-dp.min];       //SHOW(res);
        field[n-dp.min] = field[nmax-- -dp.min]; //SHOW(number[n-MIN]);
 
        return res;
    }
 
    int rrand(int range_max, int range_min)
    {   return rand() % (range_max - range_min + 1) + range_min;
    }
    static bool one;
 
};
 
//-----------------------------------------------------------------------------|
// Тестируем класс cRand_uniq.
//-----------------------------------------------------------------------------:
void test_cRand_uniq()
{   cRand_uniq::sDiapazon dp = {3, 10};
    cRand_uniq Task(dp);
    Task.test();
    getchar  ();
}
 
///----------------------------------------------------------------------------|
/// Структура для входных параметров.
///----------------------------------------------------------------------------:
struct sUserdata
{   int                   summa;   ///     Сумма, как входной параметр.
    size_t                amrand;  ///<<<--Кол-во уник.чисел для суммы.
    cRand_uniq::sDiapazon diapazon;///     Диапазон уникальных значений рандома.
}user_default = { 240, 7, 31, 60 };
 
///----------------------------------------------------------------------------|
/// Генерация случайных чисел с заданной суммой.
///----------------------------------------------------------------------------:
class cmyTask
{
public:
    cDynamicArray<int> numbrand; /// Здесь будут самм эти числа.
    sUserdata* user;             /// Указатель на входные данные.
    
    cmyTask(sUserdata* _user) : user(_user),
                                numbrand(_user->amrand)
    {   if(count == 0)
            srand(static_cast<unsigned int>(time(NULL)));
 
        count++;
        
        ///--------------------------------------------------------------------|
        /// Инициализируем генератор случайных чисел для
        /// диапазона от user->diapazon.min до user->diapazon.maxx :
        ///--------------------------------------------------------------------:
        cRand_uniq Rand_uniq(user->diapazon);
 
        ///--------------------------------------------------------------------|
        /// Заполняем массив numbrand[] уникальными случайными числами:
        ///--------------------------------------------------------------------:
        Rand_uniq.gen(numbrand);
 
        ///--------------------------------------------------------------------|
        /// Остальная наша задача в этой работе:
        ///--------------------------------------------------------------------:
        work();
    }
 
private:
    /// Проверяем сумму сгенерированных чисел с заданным числом summa:
    void work()
    {   int s = 0;
        FOR(user->amrand)
            s += numbrand[i];
        if(user->summa == s) show_numbrand();
    }
 
    /// Вывод на экран массива numbrand[]:
    void show_numbrand()
    {   SH("Успешная попытка: "); 
        SHOW(count);
 
        FOR(user->amrand)
            std::cout << "arr[" << i << "] = " << numbrand[i] << "\n";
        std::cout << "\n";
    }
 
    static int count; // Счетчик итераций.
};
int cmyTask::count = 0;
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------|
int main()
{   setlocale(0, "");
 
    //test_cRand_uniq();
 
    ///------------------------------------------------------------------------|
    /// Входные данные.
    ///------------------------------------------------------------------------:
    sUserdata user = 
    {   240,    ///     Сумма, как входной параметр.
        5  ,    ///<<<--Кол-во уник.чисел для суммы.
        30 ,    ///     Минимальное  значение рандома.
        70      ///     Максимальное значение рандома.
    };
 
    while(true)
    { //cmyTask Task(&user_default);
        cmyTask Task(&user);
    }
 
    return 0;
 
}

задача решается без лайфхака от zss:

Сообщение от zss

а в arr[size-1] запишите разность между number и суммой всех остальных.

@names1995 · 18.04.2019, 18:28 **[ТС]**

Ругается на это
Ошибка C4596 resize: недопустимое полное имя в объявлении члена Susya v2 c:\users\drm\source\repos\susya v2\susya v2\susya v2.cpp 49

@XLAT · 18.04.2019, 21:28

Сообщение от names1995

Ругается на это

вот это:

C++

41
42

    // Изменяем размер массива.
    void cDynamicArray<T>::resize(size_t _i)

очевидно, что нужно так:

C++

41
42

    // Изменяем размер массива.
    void resize(size_t _i)

vs2010 на это по барабану, компилит на ура.

реализацию я в последний момент закинул в класс, чтобы не распылять по файлам такую мелкую структуру.

Добавлено через 3 минут
пофиксил, как показал выше и проверил теперь на TDM-GCC4.9.2, все работает.

@names1995 · 18.04.2019, 21:32 **[ТС]**

XLAT, все заработало, просто пока не совсем сильно разобрался в ооп, теперь у меня стоит другой вопрос, вот у нас щас генерируется числа несколько раз, и эти массивы, т.е новая генерация может совпадать с первой, надо сделать так что бы, новый массив который генерериутеся не совподал, т.е они тоже должны быть уникальны, и сгенерировать надо максимально возможную комбинацию чисел.
надеюсь внятно объяснил

@XLAT · 18.04.2019, 22:25

Сообщение от names1995

сгенерировать надо максимально возможную комбинацию чисел.

максимально возможное количество уникальных массивов уникальных случайных чисел согласно заданному критерию?
количество уникальных массивов можно вычислить аналитически.
Возможно имеющийся ресурс железа(конкретно это память) не позволит получить сразу весь такой список.

Сообщение от names1995

просто пока не совсем сильно разобрался в ооп

ooп это просто!
данные и методы которые работают с этим данными инкапсулируются в одной структуре(классе)
+ важная часть такой структуры это начальная инициализации подходящим из имеющихся конструктором при создании объекта этой структуры.

@names1995 · 18.04.2019, 22:33 **[ТС]**

XLAT, l

Сообщение от XLAT

максимально возможное количество уникальных массивов уникальных случайных чисел согласно заданному критерию?

да, именно.
Также у тебя в коде бесконечное количество выходит этих массивов. переделываю цикл на 10 итераций, допустим, но почему это не заработало)

@XLAT · 18.04.2019, 22:58

Сообщение от names1995

переделываю цикл на 10 итераций, допустим, но почему это не заработало)

потому что все 10 ваших итераций были провалены, т.е. не удовлетворили Критерий Суммы!
посмотрите номера итераций которые удовлетворяют критерию.
на первой секунде то что можно поймать в консоле 94733 номер итерации самый верхний.

но щас сделаю для 10 успешных.
вот:

C++

///ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
/// Генерирование уникальных случайных чисел заданной суммы                    |
///ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
#include <iostream>
#include <conio.h>
#include <time.h>
 
#define FOR(v)     for(size_t i = 0; i < v; ++i)
#define SHOW(v)    std::cout << #v << " = "<< v << "\n"
#define SH(v)      std::cout << v
 
///----------------------------------------------------------------------------|
///  Шаблон динамического массива.
///----------------------------------------------------------------------------:
template<class T>
class cDynamicArray 
{
public:
    cDynamicArray() : p(NULL), size(0){}
    cDynamicArray(size_t s): size(s)
    {   p = new T[size];
    }
   ~cDynamicArray()
    {   if (p) delete[] p;
    }
 
    //-------------------------------------------------------------------------|
    size_t size; // Размер массива.
    T*     p;    // Адрес массива с первым элементом.
 
    //-------------------------------------------------------------------------|
    cDynamicArray& operator=(cDynamicArray & _m)
    {   for (size_t i = 0; i < size; ++i)
        {   p[i] = _m.p[i];
        }
        return *this;
    }
    T& operator[](size_t v)  
    {   return p[v];
    }
    // Изменяем размер массива.
    void resize(size_t _i)
    {   if (p) delete[] p;
        size = _i;
        p = new T[size];
    }
};
 
///----------------------------------------------------------------------------|
/// cRand_uniq
/// Генератор уникальных целых чисел из заданного диапазона.
///----------------------------------------------------------------------------:
class cRand_uniq
{
public:
    struct sDiapazon
    {   int min, maxx;
    };
 
    cRand_uniq(sDiapazon _dp) : nmax (_dp.maxx),
                                field(_dp.maxx+1 - _dp.min)
    {   dp = _dp;//number.resize(dp.maxx+1 - dp.min);
        FOR(field.size)
        {   field[i] = i + dp.min;
        }
    }
 
    void gen(cDynamicArray<int>& a )
    {   FOR(a.size)
        {   a[i] = work();
        }
    }
 
    void test()
    {   cDynamicArray<int> m(10);
        gen(m);
 
        FOR(10)
        {   SHOW(m[i]);
        }
        std::cout << "\n";
    }
 
private:
    //---------------------------------------------------------------------data:
    sDiapazon          dp;
    cDynamicArray<int> field;
    int                nmax;
    
    int work()
    {   if(nmax == dp.min)
        {   std::cout << "Error: Диапазон исчерпан!\n";
            return -1;
        }
 
        int n           = rrand(dp.maxx, dp.min);
        int res         = field[n-dp.min];       //SHOW(res);
        field[n-dp.min] = field[nmax-- -dp.min]; //SHOW(number[n-MIN]);
 
        return res;
    }
 
    int rrand(int range_max, int range_min)
    {   return rand() % (range_max - range_min + 1) + range_min;
    }
    static bool one;
 
};
 
//-----------------------------------------------------------------------------|
// Тестируем класс cRand_uniq.
//-----------------------------------------------------------------------------:
void test_cRand_uniq()
{   cRand_uniq::sDiapazon dp = {3, 10};
    cRand_uniq Task(dp);
    Task.test();
    getchar  ();
}
 
///----------------------------------------------------------------------------|
/// Структура для входных параметров.
///----------------------------------------------------------------------------:
struct sUserdata
{   int                   summa;   ///     Сумма, как входной параметр.
    size_t                amrand;  ///<<<--Кол-во уник.чисел для суммы.
    cRand_uniq::sDiapazon diapazon;///     Диапазон уникальных значений рандома.
}user_default = { 240, 7, 31, 60 };
 
///----------------------------------------------------------------------------|
/// Генерация случайных чисел с заданной суммой.
///----------------------------------------------------------------------------:
class cmyTask
{
public:
    cDynamicArray<int> numbrand; /// Здесь будут самм эти числа.
    sUserdata* user;             /// Указатель на входные данные.
    
    cmyTask(sUserdata* _user) : user(_user),
                                numbrand(_user->amrand)
    {   if(count == 0)
            srand(static_cast<unsigned int>(time(NULL)));
 
        count++;
        
        ///--------------------------------------------------------------------|
        /// Инициализируем генератор случайных чисел для
        /// диапазона от user->diapazon.min до user->diapazon.maxx :
        ///--------------------------------------------------------------------:
        cRand_uniq Rand_uniq(user->diapazon);
 
        ///--------------------------------------------------------------------|
        /// Заполняем массив numbrand[] уникальными случайными числами:
        ///--------------------------------------------------------------------:
        Rand_uniq.gen(numbrand);
 
        ///--------------------------------------------------------------------|
        /// Остальная наша задача в этой работе:
        ///--------------------------------------------------------------------:
        work();
    }
 
    bool success;
    
private:
    /// Проверяем сумму сгенерированных чисел с заданным числом summa:
    void work()
    {   success = false;
        int s = 0;
        FOR(user->amrand)
            s += numbrand[i];
        if(user->summa == s)
        {   show_numbrand();
            success = true;
        }
    }
 
    /// Вывод на экран массива numbrand[]:
    void show_numbrand()
    {   SH("Успешная попытка: "); 
        SHOW(count);
        show_numbrand_string();
        FOR(user->amrand)
            std::cout << "arr[" << i << "] = " << numbrand[i] << "\n";
        std::cout << "\n";
    }
    
    void show_numbrand_string()
    {   std::cout << "В виде строки:   ";
        FOR(user->amrand)
            std::cout << char(numbrand[i]);
        std::cout << "\n";
    }
 
    static int count; // Счетчик итераций.
};
int cmyTask::count = 0;
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------|
int main()
{   setlocale(0, "");
 
    //test_cRand_uniq();
 
    ///------------------------------------------------------------------------|
    /// Входные данные.
    ///------------------------------------------------------------------------:
    sUserdata user = 
    {   240,    ///     Сумма, как входной параметр.
        5  ,    ///<<<--Кол-во уник.чисел для суммы.
        30 ,    ///     Минимальное  значение рандома.
        70      ///     Максимальное значение рандома.
    };
 
    int i = 0;
    while(i < 10)
    { //cmyTask Task(&user_default);
        cmyTask Task(&user);
        if(Task.success) i++;
    }
 
    return 0;
}

самая первая успешная попытка - 17

Добавлено через 7 минут
попробуйте вот тут дефолтные входные данные:

C++

    int i = 0;
    while(i < 10)
    {   cmyTask Task(&user_default); /// user_default = { 240, 7, 31, 60 };
        //cmyTask Task(&user);
        if(Task.success) i++;
    }

первая успешная итерация на полумилионник.

Генерирование уникальных случайных чисел заданной суммы

Решение

Решение

Решение

@zss Модератор 13507 / 10757 / 6412 Регистрация: 18.12.2011 Сообщений: 28,715
	07.04.2019, 18:38	2
	Это что-то слишком мудрено. Генерите просто size-1 чисел, а в arr[size-1] запишите разность между number и суммой всех остальных. Не по теме: зачем под number память выделяете динамически? 1

@XLAT Just Do It! 3841 / 2286 / 636 Регистрация: 23.09.2014 Сообщений: 7,073 Записей в блоге: 3
	07.04.2019, 18:53	4
	Сообщение от Clever411 Я возможно что-то не понял. вы правильно поняли zss ) Но если, по коду автора проинженерить задачу, то вот: Генерируются массив из 5 случайных уникальных чисел от 1 до 50. Этот массив будет считаться true-настоящим, если сумма элементов этого массива будет равна переменной *numbers. 1

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	07.04.2019, 20:05 [ТС]	5
	попробуем щас Добавлено через 11 минут можете код дать? у меня что-то не получается ) не совсем понял 0

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	07.04.2019, 21:08 [ТС]	7
	да, получается неравномерное распределение, теряется уникальность 0

@Clever411 9 / 8 / 3 Регистрация: 09.05.2018 Сообщений: 23
	07.04.2019, 21:21	10
	Ах... Уникальность!!! А я и забыл! А "rand()%N" надо понимать как случайное число принадлежащее интервалу [0; N), ++i - я думаю объяснять не надо 1

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	07.04.2019, 21:25 [ТС]	11
	да, строчку догнал, но уникальность 0

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	07.04.2019, 21:41 [ТС]	13
	в моем коде уникальность была, но сумма не была равна заданной сумме 0

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	18.04.2019, 18:28 [ТС]	15
	Ругается на это Ошибка C4596 resize: недопустимое полное имя в объявлении члена Susya v2 c:\users\drm\source\repos\susya v2\susya v2\susya v2.cpp 49 1

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	18.04.2019, 21:32 [ТС]	17
	XLAT, все заработало, просто пока не совсем сильно разобрался в ооп, теперь у меня стоит другой вопрос, вот у нас щас генерируется числа несколько раз, и эти массивы, т.е новая генерация может совпадать с первой, надо сделать так что бы, новый массив который генерериутеся не совподал, т.е они тоже должны быть уникальны, и сгенерировать надо максимально возможную комбинацию чисел. надеюсь внятно объяснил 0

@XLAT Just Do It! 3841 / 2286 / 636 Регистрация: 23.09.2014 Сообщений: 7,073 Записей в блоге: 3
	18.04.2019, 22:25	18
	Сообщение от names1995 сгенерировать надо максимально возможную комбинацию чисел. максимально возможное количество уникальных массивов уникальных случайных чисел согласно заданному критерию? количество уникальных массивов можно вычислить аналитически. Возможно имеющийся ресурс железа(конкретно это память) не позволит получить сразу весь такой список. Сообщение от names1995 просто пока не совсем сильно разобрался в ооп ooп это просто! данные и методы которые работают с этим данными инкапсулируются в одной структуре(классе) + важная часть такой структуры это начальная инициализации подходящим из имеющихся конструктором при создании объекта этой структуры. 0

@names1995 12 / 13 / 6 Регистрация: 13.11.2012 Сообщений: 295
	18.04.2019, 22:33 [ТС]	19
	XLAT, l Сообщение от XLAT максимально возможное количество уникальных массивов уникальных случайных чисел согласно заданному критерию? да, именно. Также у тебя в коде бесконечное количество выходит этих массивов. переделываю цикл на 10 итераций, допустим, но почему это не заработало) 0