# random

***

**1. Generating Random Numbers**

```cpp
#include <random>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 6);

  for (int i = 0; i < 10; ++i) {
    std::cout << dist(gen) << ' ';
  }

  return 0;
}
```

**2. Shuffling a Vector**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());

  std::vector<int> vec = {1, 2, 3, 4, 5};
  std::shuffle(vec.begin(), vec.end(), gen);

  for (int i : vec) {
    std::cout << i << ' ';
  }

  return 0;
}
```

**3. Sampling a Population**

```cpp
#include <random>
#include <set>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());

  std::set<int> population = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  std::uniform_int_distribution<int> dist(1, 10);

  std::set<int> sample;
  for (int i = 0; i < 5; ++i) {
    sample.insert(dist(gen));
  }

  for (int i : sample) {
    std::cout << i << ' ';
  }

  return 0;
}
```

**4. Generating a Random String**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  std::string str(10, '\0');
  for (int i = 0; i < 10; ++i) {
    str[i] = dist(gen);
  }

  std::cout << str << '\n';

  return 0;
}
```

**5. Generating a Random Number in a Range**

```cpp
#include <random>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 10);

  int n = dist(gen);
  std::cout << n << '\n';

  return 0;
}
```

**6. Generating a Random Double**

```cpp
#include <random>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_real_distribution<double> dist(0.0, 1.0);

  double n = dist(gen);
  std::cout << n << '\n';

  return 0;
}
```

**7. Generating a Random Password**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  std::string password(10, '\0');
  for (int i = 0; i < 10; ++i) {
    password[i] = dist(gen);
  }

  std::cout << password << '\n';

  return 0;
}
```

**8. Generating a Random Number in a Weighted Distribution**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());

  std::vector<int> weights = {1, 2, 3, 4, 5};
  std::discrete_distribution<int> dist(weights.begin(), weights.end());

  int n = dist(gen);
  std::cout << n << '\n';

  return 0;
}
```

**9. Generating a Random Date**

```cpp
#include <random>
#include <chrono>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<std::chrono::time_point<std::chrono::system_clock>> dist(
      std::chrono::system_clock::from_time_t(0),
      std::chrono::system_clock::now());

  std::chrono::time_point<std::chrono::system_clock> t = dist(gen);
  std::cout << std::chrono::system_clock::to_time_t(t) << '\n';

  return 0;
}
```

**10. Generating a Random Vector**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 10);

  std::vector<int> vec(10);
  for (int i = 0; i < 10; ++i) {
    vec[i] = dist(gen);
  }

  for (int i : vec) {
    std::cout << i << ' ';
  }

  return 0;
}
```

**11. Generating a Random Matrix**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 10);

  std::vector<std::vector<int>> matrix(10, std::vector<int>(10));
  for (int i = 0; i < 10; ++i) {
    for (int j = 0; j < 10; ++j) {
      matrix[i][j] = dist(gen);
    }
  }

  for (int i = 0; i < 10; ++i) {
    for (int j = 0; j < 10; ++j) {
      std::cout << matrix[i][j] << ' ';
    }

    std::cout << '\n';
  }

  return 0;
}
```

**12. Generating a Random Permutation**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());

  std::vector<int> permutation(10);
  for (int i = 0; i < 10; ++i) {
    permutation[i] = i;
  }

  std::shuffle(permutation.begin(), permutation.end(), gen);

  for (int i : permutation) {
    std::cout << i << ' ';
  }

  return 0;
}
```

**13. Generating a Random Tree**

```cpp
#include <random>
#include <set>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 10);

  int max_nodes = 10;
  int num_nodes = dist(gen);

  std::set<std::pair<int, int>> tree;
  for (int i = 2; i <= num_nodes; ++i) {
    int parent = dist(gen) % i;
    tree.insert(std::make_pair(parent, i));
  }

  for (const auto& pair : tree) {
    std::cout << pair.first << " -> " << pair.second << '\n';
  }

  return 0;
}
```

**14. Generating a Random Graph**

```cpp
#include <random>
#include <set>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 10);

  int num_vertices = 10;
  int num_edges = dist(gen) / 2;

  std::set<std::pair<int, int>> graph;
  for (int i = 0; i < num_edges; ++i) {
    int v1 = dist(gen) % num_vertices;
    int v2 = dist(gen) % num_vertices;

    if (v1 == v2) {
      --i;
    } else {
      graph.insert(std::make_pair(v1, v2));
    }
  }

  for (const auto& pair : graph) {
    std::cout << pair.first << " -> " << pair.second << '\n';
  }

  return 0;
}
```

**15. Generating a Random Maze**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(0, 1);

  int rows = 10;
  int cols = 10;

  std::vector<std::vector<int>> maze(rows, std::vector<int>(cols, 0));

  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      maze[i][j] = dist(gen);
    }
  }

  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      std::cout << maze[i][j];
    }

    std::cout << '\n';
  }

  return 0;
}
```

**16. Generating a Random Sudoku Grid**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 9);

  int n = 9;

  std::vector<std::vector<int>> grid(n, std::vector<int>(n, 0));

  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      grid[i][j] = dist(gen);
    }
  }

  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      std::cout << grid[i][j] << ' ';
    }

    std::cout << '\n';
  }

  return 0;
}
```

**17. Generating a Random Crossword Puzzle**

```cpp
#include <random>
#include <set>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 10);

  int rows = 10;
  int cols = 10;

  std::set<std::pair<int, int>> crossword;
  for (int i = 0; i < dist(gen); ++i) {
    int r = dist(gen) % rows;
    int c = dist(gen) % cols;
    crossword.insert(std::make_pair(r, c));
  }

  std::vector<std::string> words(crossword.size());
  for (int i = 0; i < crossword.size(); ++i) {
    int length = dist(gen) % 5 + 1;
    std::string word(length, '\0');
    for (int j = 0; j < length; ++j) {
      word[j] = 'a' + dist(gen) % 26;
    }
    words[i] = word;
  }

  for (int i = 0; i < crossword.size(); ++i) {
    int r = std::get<0>(*crossword.begin());
    int c = std::get<1>(*crossword.begin());
    int length = words[i].length();

    for (int j = 0; j < length; ++j) {
      crossword[std::make_pair(r, c)] = words[i][j];
      ++c;
    }

    crossword.erase(crossword.begin());
  }

  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      if (crossword.count(std::make_pair(i, j))) {
        std::cout << crossword[std::make_pair(i, j)];
      } else {
        std::cout << '.';
      }
    }

    std::cout << '\n';
  }

  return 0;
}
```

**18. Generating a Random Poem**

```cpp
#include <random>
#include <set>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(0, 9);

  int num_words = 10;

  std::set<int> words;
  for (int i = 0; i < num_words; ++i) {
    words.insert(dist(gen));
  }

  std::vector<int> order(words.begin(), words.end());

  std::string poem;
  for (int i = 0; i < order.size(); ++i) {
    poem += std::to_string(order[i]) + ' ';
  }

  std::cout << poem << '\n';

  return 0;
}
```

**19. Generating a Random Name**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  int length = 10;

  std::string name(length, '\0');
  for (int i = 0; i < length; ++i) {
    name[i] = dist(gen);
  }

  std::cout << name << '\n';

  return 0;
}
```

**20. Generating a Random Company Name**

```cpp
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  int length = 10;

  std::string company_name(length, '\0');
  for (int i = 0; i < length; ++i) {
    company_name[i] = dist(gen);
  }

  std::cout << company_name << '\n';

  return 0;
}
```

**21. Generating a Random Email Address**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  int length = 10;

  std::string email_address;
  for (int i = 0; i < length; ++i) {
    email_address += dist(gen);
  }

  email_address += "@example.com";

  std::cout << email_address << '\n';

  return 0;
}
```

**22. Generating a Random Password**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  int length = 10;

  std::string password(length, '\0');
  for (int i = 0; i < length; ++i) {
    password[i] = dist(gen);
  }

  std::cout << password << '\n';

  return 0;
}
```

**23. Generating a Random Phone Number**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('0', '9');

  int length = 10;

  std::string phone_number(length, '\0');
  for (int i = 0; i < length; ++i) {
    phone_number[i] = dist(gen);
  }

  std::cout << phone_number << '\n';

  return 0;
}
```

**24. Generating a Random Address**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  int length = 10;

  std::string address(length, '\0');
  for (int i = 0; i < length; ++i) {
    address[i] = dist(gen);
  }

  std::cout << address << '\n';

  return 0;
}
```

**25. Generating a Random City**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('a', 'z');

  int length = 10;

  std::string city(length, '\0');
  for (int i = 0; i < length; ++i) {
    city[i] = dist(gen);
  }

  std::cout << city << '\n';

  return 0;
}
```

**26. Generating a Random State**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('A', 'Z');

  int length = 2;

  std::string state(length, '\0');
  for (int i = 0; i < length; ++i) {
    state[i] = dist(gen);
  }

  std::cout << state << '\n';

  return 0;
}
```

**27. Generating a Random Zip Code**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('0', '9');

  int length = 5;

  std::string zip_code(length, '\0');
  for (int i = 0; i < length; ++i) {
    zip_code[i] = dist(gen);
  }

  std::cout << zip_code << '\n';

  return 0;
}
```

**28. Generating a Random Country Code**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('A', 'Z');

  int length = 2;

  std::string country_code(length, '\0');
  for (int i = 0; i < length; ++i) {
    country_code[i] = dist(gen);
  }

  std::cout << country_code << '\n';

  return 0;
}
```

**29. Generating a Random Currency Code**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('A', 'Z');

  int length = 3;

  std::string currency_code(length, '\0');
  for (int i = 0; i < length; ++i) {
    currency_code[i] = dist(gen);
  }

  std::cout << currency_code << '\n';

  return 0;
}
```

**30. Generating a Random Language Code**

```cpp
#include <random>
#include <string>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist('A', 'Z');

  int length = 2;

  std::string language_code(length, '\0');
  for (int i = 0; i < length; ++i) {
    language_code[i] = dist(gen);
  }

  std::cout << language_code << '\n';

  return 0;
}
```

**31. Generating a Random Time**

```cpp
#include <random>
#include <iostream>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(0, 23);

  int hours = dist(gen);
  int minutes = dist(gen);
  int seconds = dist(gen);

  std::cout << hours << ':' << minutes << ':' << seconds << '\n';

  return 0;
}
```

**32. Generating a Random Date**

```cpp
#include <random>
#include <iostream>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<int> dist(1, 31);

  int day = dist(gen);
  int month = dist(gen);
  int year = dist(gen);

  std::cout << day << '/' << month << '/' << year << '\n';

  return 0;
}
```

**33. Generating a Random Age**

```cpp
#include <random>

```