Блог

Например: если я получаю несколько цифр, и все эти числа генерируются случайным образом (1-9), всего до 7 цифр, и я хочу, чтобы все они были целым целым числом, как мне это сделать?

Вот что я пробовал:

 static void generate_key(std::map<std::string, int>amp; key, std::string c_user)
{
    unsigned int hold[7]{}; // will hold all the random integers seperate to add onto final
    int *final = new int; // will store a complete 7 digit integer here later on

    for (int i = 0; i < 7; i  )
    {
        unsigned int num = rand() % 9;
        hold[i] = num;
    }

    *final = hold[0]   hold[1]   hold[2]   hold[3]; // I know this sums everything but how do I get it to just add all the numbers into a single integer?!
    key.emplace(c_user, final);

    std::cout << "Key created: " << *final << 'n';

    delete final;
}
 

Храните все целые числа отдельно друг от друга:

 unsigned int hold[7]{};
 

Создание случайных цифр:

 for (int i = 0; i < 7; i  )
        {
            unsigned int num = rand() % 9;
            hold[i] = num;
        }
 

Сохраняйте и добавляйте все целые числа в *final целое число

 int *final = new int;
 

Я хочу сгенерировать 7-значный ключ, и каждая отдельная цифра рандомизирована. Затем я хочу сложить их все, чтобы получить целое целое число, которое помещается в карту, где строка уже создана, и этот ключ будет представлять строку. Вы понимаете, что я здесь говорю? Извините, если мое объяснение ужасно, я просто слишком потерян здесь..

Вот полный код, если это полезно:

 #include <iostream>
#include <string>
#include <map>
#include <vector>
#include <stdlib.h>

class Account
{
private:
    std::string username;
    std::string password;
public:
    Account(std::string username, std::string password)
    {
        this->username = username;
        this->password = password;
    }
    ~Account() {};

    std::string get_username()const { return username; }
    std::string get_password()const { return password; }
};

static void create_account(std::string user, std::string pass, std::vector<Account> amp;acc)
{
    Account *account = new Account(user, pass);

    acc.push_back(*account);

    delete account;
}

static void generate_key(std::map<std::string, int>amp; key, std::string c_user)
{
    unsigned int hold[7]{};
    int *final = new int;

    for (int i = 0; i < 7; i  )
    {
        unsigned int num = rand() % 9;
        hold[i] = num;
    }

    *final = hold[0]   hold[1]   hold[2]   hold[3];

    key.emplace(c_user, final);

    std::cout << "Key created: " << *final << 'n';

    delete final;
}

std::vector<Account> accounts;
std::map<std::string, int> keys;

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

    create_account("random", "triathlon", accounts);
    generate_key(keys, accounts[0].get_username());

    return 0;
}

static void create_account(std::string, std::string, std::vector<Account> amp;acc);
static void generate_key(std::map<std::string, int>amp;, std::string);
 

Если вы хотите сгенерировать 7-значное число, в котором все цифры уникальны, то вы можете сохранить действительные цифры в a vector , а затем shuffle в этом векторе и взять первые 7 элементов в качестве цифры, чтобы составить число. Это можно было бы сделать следующим образом:

 std::vector<char> digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
std::random_device rd;
std::mt19937 g(rd());
std::suffle(digits.being(), digits.end(), g);
std::string number{digits.begin(), digits.begin()   7}
 

и теперь number это 7-значная строка, где каждая цифра появляется только один раз. Если вы не хотите иметь начальный ноль, вам нужно будет проверить, является ли первый элемент нулем, и если да, снова перемешайте или просто возьмите элементы с 1 по 7.

Если вы просто хотите сгенерировать 7-значное число, но вам все равно, есть ли повторяющиеся цифры, то вы можете сделать это с помощью a std::string и простого цикла for, например:

 std::random_device rd;
std::mt19937 g(rd());
std::uniform_int_distribution<> dist(0, 9);
std::string number;
for (int i = 0; i < 7;   i)
{
    number.push_back('0'   dist(g))
}
 

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

Я забыл, как называется этот алгоритм.

В вашем случае вам нужно выполнить только семь итераций, начиная с девяти цифр. Код ниже:

 #include <vector>
#include <array>
#include <algorithm>
#include <iostream>

int remove_rnd_item( std::vector<int>amp; digits ) {
    int n = rand() % digits.size(); // should use a better RNG...
    int rnd_digit = digits[n];
    //swap with the last digit and pop...
    std::swap(digits[n], digits.back());
    digits.pop_back();
    return rnd_digit;
}

int random_seven_digit_number_with_unique_digits() {
    std::vector<int> digits = { 0,1,2,3,4,5,6,7,8,9 };
    std::array<int, 7> rnd_digits;
    std::generate(rnd_digits.begin(), rnd_digits.end(),
        [amp;digits]() {
            return remove_rnd_item(digits);
        }
    );
    // convert the digits vector to a single int, if that is what you want
    int tens_place = 1;
    int val = 0;
    for (auto digit : rnd_digits) {
        val  = tens_place * digit;
        tens_place *= 10;
    }
    return val;
}

int main() {
    for (int i = 0; i < 10;   i) {
        std::cout << random_seven_digit_number_with_unique_digits() << "n";
    }
}
 

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

Чтобы получить случайное 7-значное число, вам нужно только:

 #include <random>
#include <iostream>

int main()
{
    std::random_device rd;  //Will be used to obtain a seed for the random number engine
    std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
    std::uniform_int_distribution<> distrib(0, 9'999'999);

    std::cout << distrib(gen) << std::endl;
}
 

Если вы хотите избежать начальных нулей, используйте distrib(1'000'000, 9'999'999);

Уииии! Привет!.Я тоже новичок !. и да. Я думаю, вы можете сделать это так !.

 int boop(){
    int ding=1000000;
    int a[7]={1,4,6,3,4,2,4};
    int re=0;
    for(int i=0;i<7;i  ){
        re =a[i]*ding;
        ding/=10;
    }
    return re;
}
 

или просто создайте свою собственную функцию для создания случайного числа в диапазоне от 0 до 1. и умножьте его на 9999999. (вроде как рекомендуется).

 #include <iostream>
#include <math.h>
float boop(int seed){
    return abs(sin( cos(seed*3972)*38472));
}
int main(){
    float f=boop(34)*9999999;
    std::cout<<(int)f;
    return 0;
}