https://github.com/simobin/nothingbutcpp
c++
https://github.com/simobin/nothingbutcpp
alphabet cpp matrix random-generation time
Last synced: 12 months ago
JSON representation
c++
- Host: GitHub
- URL: https://github.com/simobin/nothingbutcpp
- Owner: siMobin
- Created: 2023-06-05T06:58:12.000Z (about 3 years ago)
- Default Branch: main
- Last Pushed: 2023-06-05T07:16:55.000Z (about 3 years ago)
- Last Synced: 2025-02-25T15:28:55.830Z (over 1 year ago)
- Topics: alphabet, cpp, matrix, random-generation, time
- Language: C++
- Homepage:
- Size: 2.93 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Random Alphabet Matrix Generator
This code is a C++ program that generates a random matrix of alphabets based on user input for the number of rows and columns. The generated matrix is then displayed on the console.
### Importing Required Libraries
```cpp
#include
#include
#include
#include
```
The code includes the necessary C++ libraries for input/output ``iostream``, string stream processing ``sstream``, random number generation ``cstdlib``, and time functions ``ctime``.
### Setting Up the Random Number Generator
```cpp
srand(time(NULL));
```
This line seeds the random number generator using the current time as the seed. It ensures that the random numbers generated later in the program are different in each run.
### Accepting User Input for Matrix Size
```cpp
int rows, cols;
std::cout << "Enter rows and columns (e.g., 10 or 10x10) or press enter: ";
std::string input;
std::getline(std::cin, input);
```
The program prompts the user to input the number of rows and columns for the matrix. The input is read as a string from the console.
### Handling Empty Input and Default Values
```cpp
if (input.empty()) {
rows = 10;
cols = 10;
} else {
std::stringstream ss(input);
char separator;
ss >> rows;
if (!ss) {
std::cout << "Invalid input.\n";
return 1;
}
if (ss >> separator >> cols && separator == 'x') {
// Both rows and cols are entered correctly
} else {
cols = rows;
}
}
```
If the user presses enter without providing any input, the program sets the number of rows and columns to 10 by default. Otherwise, it proceeds to process the user input.
If the extraction is successful, the code checks if the separator character is present and equals ``'x'``, indicating that both rows and columns are provided. If so, the variables ``rows`` and ``cols`` are set accordingly. Otherwise, the number of columns is set equal to the number of rows.
### Creating the Matrix
```cpp
char matrix[rows][cols];
```
A 2D character array called ``matrix`` is created with the dimensions specified by the user input.
### Filling the Matrix with Random Alphabets
```cpp
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
int randomNumber = rand() % 26;
matrix[i][j] = 'a' + randomNumber;
}
}
```
Nested loops iterate over each element of the matrix. A random number between 0 and 25 is generated using the ```rand()``` function, and the corresponding alphabet is assigned to the current matrix element.
### Printing the Matrix
```cpp
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (j > 0) {
std::cout << " | ";
}
std::cout << matrix[i][j];
}
std::cout << "\n";
for (int j = 0; j < cols * 4 - 3; j++) {
std::cout << "-";
}
std::cout << "\n";
}
```
Two nested loops iterate over each element of the matrix. The elements are printed on the console, separated by a vertical bar ``|``. After printing each row, a separator row consisting of hyphens ``-`` is printed to improve readability.
### Example Usage
Here's an example of how to use this program:
```shell
Enter rows and columns (e.g., 10 or 10x10) or press enter: 5x8
```
Output:
```shell
z | a | f | x | p | u | o | v
------------------------------
t | r | m | k | q | j | l | i
------------------------------
c | g | h | o | w | d | z | q
------------------------------
d | g | j | p | f | u | z | y
------------------------------
e | b | n | r | l | t | y | s
------------------------------
```
### Extending the Program
To take this program to an extreme level, you can consider adding the following features:
**User Input Validation:** Enhance the input validation to handle a wider range of scenarios, such as detecting and handling non-numeric or out-of-range inputs. Provide meaningful error messages to guide the user.
**Custom Alphabet Pool:** Allow the user to specify a custom pool of characters to generate the matrix from. For example, the user could input a string of characters, and the program would randomly select characters from that pool instead of using the default alphabet. This customization adds flexibility and allows the user to create matrices with specific character sets.
**Matrix Manipulation Operations:** Implement additional operations on the generated matrix, such as matrix transposition, matrix addition, matrix multiplication, matrix rotation, etc. These operations would enable users to perform various transformations on the matrix and perform mathematical computations.
**File I/O:** Add functionality to save the generated matrix to a file or load a matrix from a file. This feature would allow users to store and retrieve matrices for later use or share them with others.
**3D Movement and Visualization:** Extend the program to support 3D movement and visualization. Instead of generating a 2D matrix, create a 3D cube or grid structure. Allow the user to navigate within the 3D space, rotate the cube, and interact with the matrix elements in three dimensions. This would involve implementing 3D graphics libraries or frameworks and incorporating user input for controlling the movement and orientation.
**Matrix Operations Library:** Convert the program into a library that provides a set of functions for matrix manipulation, including both 2D and 3D operations. This library could be used by other developers to perform matrix-related operations in their projects. The library should be well-documented, with clear usage examples and comprehensive API documentation.
By implementing these additional features, the program can be expanded into a powerful tool for matrix manipulation and exploration, providing users with the ability to generate, customize, visualize, and perform operations on both 2D and 3D matrices.