Est-il possible de random_shuffle un tableau de int éléments?

J'ai lu sur ce : http://www.cplusplus.com/reference/algorithm/random_shuffle/
et je me demandais si il est possible de random_shuffle un tableau de int éléments. C'est mon code

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int a[10]={1,2,3,4,5,6,7,8,9,10};

    cout << a << endl << endl;

    random_shuffle(a[0],a[9]);

    cout<<a;
}

J'ai eu cette erreur:

error C2893: Failed to specialize function template
    'iterator_traits<_Iter>::difference_type *std::_Dist_type(_Iter)'.

Mes question sont:

Est-il possible de mélanger un int tableau à l'aide de random_shuffle. Si oui, je voudrais savoir comment le faire.
Est random_shuffle uniquement applicable aux modèles?
Ce que fait mon erreur signifie?

OriginalL'auteur Computernerd | 2013-02-06

algorithm c++shuffle

43

Vous avez besoin pour passer des pointeurs à a[0] et a[10], pas les éléments eux-mêmes:
```
random_shuffle(&a[0], &a[10]); //end must be 10, not 9
```
En C++11, vous pouvez utiliser std::begin et std::end:
```
random_shuffle(std::begin(a), std::end(a));
```
je sais que cela semble stupide, mais comment savez-vous son pointeurs?? quelle partie de la page le dire??
Les pointeurs sont en accès aléatoire itérateurs, et il prend deux itérateurs.
un autre qn: Cette méthode de mélange de tous les nombre quand il est appelé une fois, il n'existe aucune méthode qui échange 2 nombre qu'une seule fois quand on l'appelle??
@Computernerd, std::swap?
Si vous avez besoin de changer un peu les chiffres pour obtenir une autre permutation aléatoire, vous pouvez appeler next_permutation. Il est souvent swaps de seulement deux éléments, mais peut échanger plus, ou pas du tout (auquel cas il revient false).

OriginalL'auteur dasblinkenlight
3

random_shuffle prend des itérateurs, plutôt que des éléments. Essayez:
```
std::random_shuffle(a, a + 10);
```
ou
```
std::random_shuffle(std::begin(a), std::end(a));
```
std::random_shuffle peut être utilisé sur n'importe quelle paire de random access itérateurs, et mélange les éléments dans l'intervalle dénoté par ces itérateurs.

L'erreur se produit car ints ne sont pas des itérateurs, et ainsi de std::random_shuffle est incapable d'utiliser la donnée ints comme des itérateurs.

OriginalL'auteur Mankarse
3

Essayez de remplacer
```
random_shuffle(a[0],a[9]);
```
avec
```
random_shuffle(&a[0], &a[10]);
```
À partir de: http://www.java2s.com/Code/Cpp/STL-Basics/Userandomshufflealgorithmswitharray.htm

OriginalL'auteur Theo20185

Travaillé pour moi de cette façon:

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int a[10]={0,1,2,3,4,5,6,7,8,9};

    for (unsigned i = 0; i < 10; i++)
    {
        cout << a[i];
    }
    cout << endl;

    random_shuffle(&a[0],&a[10]);

    for (unsigned i = 0; i < 10; i++)
    {
        cout << a[i];
    }
    cout << endl;
}

Pour quelque raison que ce sont toujours le mélange de la matrice dans le même ordre. Ou est-ce que la lecture aléatoire est sur?
srand(time(0)) ?

OriginalL'auteur Renato Aloi

0

Simplement de changer l'arr d'un pointeur ne résout pas la solution. Cela permet de rendre le tableau de swap pour un type de permutation. Cela signifie que si vous exécutez à nouveau le programme, votre tableau sera mélangée dans l'exact la même manière comme il le faisait dans l'exécution précédente.

Pour résoudre ce - la fonction d'offre d'un troisième paramètre qui agit comme une graine. Donc la bonne mise en œuvre de la fonction est la suivante.

1) Ont une fonction ou d'un lamda qui génère un nombre aléatoire. Ce sera votre semence.
```
int myrandom (int i) { return std::rand()%i;}
```
Assurez-vous que la semence de l'intérieur du générateur de nombres aléatoires.
```
std::srand ( unsigned ( std::time(0) ) );
```
2) Insérer cette fonction en tant que troisième arguement dans le random_shuffle appel de fonction.
```
std::random_shuffle ( myvector.begin(), myvector.end(), myrandom);
```
Sera toujours aléatoire mélangées ensemble.
Assurez-vous d'inclure les éléments suivants:
```
#include <algorithm>    //std::random_shuffle
#include <vector>       //std::vector
#include <ctime>        //std::time
#include <cstdlib>      //std::rand, std::srand
```
OriginalL'auteur Grant Wilson

Vous devez vous connecter pour publier un commentaire.