Initialisation aléatoire d'un tableau 2D- c++

Résolu/Fermé
tatouprog - 19 déc. 2007 à 16:26
mamiemando Messages postés 31753 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 28 novembre 2022 - 20 déc. 2007 à 14:51
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
A voir également:

3 réponses

mamiemando Messages postés 31753 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 28 novembre 2022 7 480
19 déc. 2007 à 21:46
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 :
#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
1
merci beaucoup, ça va beaucoup m'aider.
j'ai juste rajouté "#include <limits>" en entête car mon compilateur ne reconnaissait pas le" numeric_limits"
0
mamiemando Messages postés 31753 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 28 novembre 2022 7 480
20 déc. 2007 à 14:51
Ah ok :-) Ravie d'avoir pu t'aider, bonne continuation !
0