Initialisation aléatoire d'un tableau 2D- c++
Résolu
Bonjour,
Je souhaiterai créer un tableau de char à 2 dimensions qui s'initialise aléatoirement.
la 1ère colonne et la derniere ligne de ce tableau est prédéfini.
exemple :
4 | c | b | c | a
3 | b | a | a | b
2 | a | b | c | a
1 | a | b | b | a
... A . B . C . D
Pouve-vous me donner des pistes pour y arriver.
Merci d'avance
PS: ne tenez pas compte des point dans le tableau
Je souhaiterai créer un tableau de char à 2 dimensions qui s'initialise aléatoirement.
la 1ère colonne et la derniere ligne de ce tableau est prédéfini.
exemple :
4 | c | b | c | a
3 | b | a | a | b
2 | a | b | c | a
1 | a | b | b | a
... A . B . C . D
Pouve-vous me donner des pistes pour y arriver.
Merci d'avance
PS: ne tenez pas compte des point dans le tableau
A voir également:
- Initialisation aléatoire d'un tableau 2D- c++
- Tableau word - Guide
- Trier un tableau excel - Guide
- Tableau ascii - Guide
- Imprimer un tableau excel - Guide
- Tableau croisé dynamique - Guide
3 réponses
En fait il y a deux points sur lesquels tu dois réfléchir
- comment générer une valeur aléatoire
- comment stocker ton tableau
Il y a plusieurs façons de faire, tout dépend si tu stockes l'information
- dans un tableau 2d (vecteur de vecteur (classe std::vector), dont les cases vides seront initialisées avec une valeur par défaut) . Pour cette solution chaque case est identifiée par une paire d'entiers positifs (std::size_t)
- ou matrice creuse (map de map (classe std::map), seule les cases remplies sont stockées en mémoire). Pour accéder à une case tu peux utiliser une paire générique de clé (par exemple un entier relatif et un char).
Dans notre cas on va par exemple utiliser des vecteurs de vecteurs de char.
Ci dessous une façon de faire :
qui donne à l'exécution :
Les templates permettent par la même occasion de passer très facilement d'une matrice de char à une matrice de float ou d'int, il suffit de corriger le main (cf type en gras) et les bornes du random (ici 'a' et 'z'), et la valeur initiale (ici 'x')
Bonne chance
- comment générer une valeur aléatoire
- comment stocker ton tableau
Il y a plusieurs façons de faire, tout dépend si tu stockes l'information
- dans un tableau 2d (vecteur de vecteur (classe std::vector), dont les cases vides seront initialisées avec une valeur par défaut) . Pour cette solution chaque case est identifiée par une paire d'entiers positifs (std::size_t)
- ou matrice creuse (map de map (classe std::map), seule les cases remplies sont stockées en mémoire). Pour accéder à une case tu peux utiliser une paire générique de clé (par exemple un entier relatif et un char).
Dans notre cas on va par exemple utiliser des vecteurs de vecteurs de char.
Ci dessous une façon de faire :
#include <vector>
#include <iostream>
#include <cstdlib>
template <typename T>
class tableau2d{
protected:
std::size_t size1;
std::size_t size2;
std::vector<std::vector<T> > data;
public:
tableau2d(
const std::size_t & size10 = 0,
const std::size_t & size20 = 0,
const T & default_value = T()
):
size1(size10),
size2(size20),
data(size10,std::vector<T>(size20,default_value))
{}
inline const std::size_t & nb_row() const{
return size1;
}
inline const std::size_t & nb_col() const{
return size2;
}
inline T & get(const std::size_t & col,const std::size_t & row){
if(col >= nb_row()) throw;
if(row >= nb_col()) throw;
return data[col][row];
}
inline const T & get(const std::size_t & col,const std::size_t & row) const{
if(col >= nb_row()) throw;
if(row >= nb_col()) throw;
return data[col][row];
}
inline void set(const std::size_t & col,const std::size_t & row,const T & val){
if(col >= nb_row()) throw;
if(row >= nb_col()) throw;
data[col][row] = val;
}
};
template <typename T>
inline std::ostream & operator << (std::ostream & out,const tableau2d<T> & x){
const std::size_t &
nb_row = x.nb_row(),
nb_col = x.nb_col();
for(std::size_t i=0;i<nb_row;++i){
for(std::size_t j=0;j<nb_col;++j){
out << x.get(i,j) << '\t';
}
out << std::endl;
}
return out;
}
template <typename T>
T rand(
const T & min = std::numeric_limits<T>::min(),
const T & max = std::numeric_limits<T>::max()
){
if(min > max) throw;
return min + ((max - min + 1) * (rand() / (RAND_MAX + 1.0)));
}
template <typename T>
void random_init(
tableau2d<T> & x,
const T & min = std::numeric_limits<T>::min(),
const T & max = std::numeric_limits<T>::max()
){
if(min > max) throw;
const std::size_t &
nb_row = x.nb_row(),
nb_col = x.nb_col();
for(std::size_t i=0;i<nb_row;++i){
for(std::size_t j=0;j<nb_col;++j){
x.set(i,j,rand<T>(min,max));
}
}
}
int main(){
tableau2d<char> tab(5,7,'x');
std::cout << tab << std::endl;
random_init(tab,'a','z');
std::cout << tab << std::endl;
// getchar(); // sous windows decommente cette instruction
return 0;
}
qui donne à l'exécution :
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x v k u u x f i t h o m q j n y x q s d p a g d u e k d c z f n v p h q
Les templates permettent par la même occasion de passer très facilement d'une matrice de char à une matrice de float ou d'int, il suffit de corriger le main (cf type en gras) et les bornes du random (ici 'a' et 'z'), et la valeur initiale (ici 'x')
Bonne chance
