Discussion :

[ternel]

C'est dommage, parce que les bons arguments sont source.begin, source.end, target.begin, functor, ce qui, dans ton cas, correspond à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::transform(std::begin(jeuDeCarte), std::end(jeuDeCarte), std::begin(jeuDeCarte), [](Carte c) { c.first %= 13; c.second %= 4; return c; });

Regarde scrupuleusement la documentation de std::transform

[stendhal666]

Oups, en effet, j'ai fait une erreur de copie...
mea culpa

il y a deux possibilités pour utiliser transform:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
std::transform(std::begin(input), std::end(input), std::begin(output), function); // output est la séquence résultat de fonction(élément de l'input) appliquée au éléments de input
std::transform(std::begin(input1), std::end(input1), std::begin(input2), std::begin(output), function); // output est le résultat de fonction(élément input1, élément input2) appliquée aux élements de input1 et 2

[toto81]

On est d'accord que std::transform n'a d'effet qu'une fois que std::iota a fonctionné? Car avant de me pencher sur tranform et bien le bucher, j'voudrais réussir à faire fonctionner iota ^^

J'ai relu plusieurs fois tes indications et regardé mon code et pourtant je n'arrive pas a faire que std::iota incrémente mes pairs. Mon tableau est toujours à {{0,0},{0,0},{0,0}...{0,0}}... Quel galère !! x)

[stendhal666]

C'est étonnant. Je te laisse faire de l'auto-contrôle avec la solution que j'ai testée (qui donc fonctionne):

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
constexpr unsigned NB_COLORS = 4;
constexpr unsigned NB_CARDS_BY_COLOR = 13;
 
using Card = std::pair<unsigned, unsigned>;
using Deck = std::array<Card, NB_CARDS>;
 
auto& operator++(Card& c) {
    ++c.first;
    ++c.second;
    return c;
}
 
auto generate_deck() {
    Deck d;
    std::iota(std::begin(d), std::end(d), Card());
    std::transform(std::begin(d), std::end(d), std::begin(d), [](auto&& c) { 
        c.first  %= NB_CARDS_BY_COLOR; 
        c.second %= NB_COLORS;
        return c; 
    });
    return d;
}

Tu nous diras ce qui ne va pas.

J'en profite pour te signaler un compilateur en-ligne qui peut-être très pratique pour tester des petits bouts de code: http://melpon.org/wandbox/

[ternel]

Quand un résultat est erroné, il y a trois possibilités:

• soit le calcul est mal fait: ca serait ton utilisation de transform, ou la lambda.
• soit les données sont mal choisies: plutot du coté de iota et ++
• soit le résultat est mal observé: regarde donc ta boucle d'affichage

Qu'affiches-tu précisément?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for (int x = 0; x < jeuDeCarte.size(); x++){
	std::cout << jeuDeCarte[0].first << jeuDeCarte[0].second << std::endl;
}

Tout particulièrement, pour x = 5?
C'est dommage de ne pas avoir utilisé la boucle "range based": for (auto const& carte : jeuDeCarte)

[toto81]

Pfff bien vu Leternel!! C'est ma boucle d'affichage qui était erroné...

Je cherche l'erreur dans les calculs compliqués alors qu'elle est toute bête !!! Grrr mon code et ton code fonctionne Stend sauf que toi tu penses à utiliser les constantes alors que moi j'y pense pas... ^^

Leternel, je ne connaissais pas ta boucle, encore une chose d'apprise!

[stendhal666]

Leternel, malgré ses millions d'années, a des yeux de lynx!

[ternel]

J'ai assez écrit d'aneries pour avoir pris pour habitude de vérifier d'abord mes meessages de débugs
Jusqu'à l'année dernière, je m'arretai à deux raisons: le calcul ou les données.
Puis j'ai fais cette erreur.

Et je ne suis pas vieux... il faut juste que je fasse changer mon pseudo (qui signifie "le ter Nel")

[stendhal666]

(qui signifie "le ter Nel")

Et que signifie le ter Nel?

@toto81: d'ailleurs cela confirme l'utilité des algorithmes tout fait de la bibliothèque standard; si tu avais utilisé for_each:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

std::for_each(std::begin(deck), std::end(deck), [](Card c) { std::cout << '(' << c.first << ',' << c.second << ") "; });

ce ne serait pas arrivé

[ternel]

Le mot "ter" désigne dans un français archaïque et légèrement déformé, le troisième d'un ensemble ou d'un groupe, en l'occurence des cinq Nels qui son (ou plus exactement étaient) les gardiens d'un ordre secret dans un jeu de rôle (inventé par un ami).

Par ailleurs, je suis contre ce for_each, puisqu'on a for(:).
Autant j'aime beaucoup les algorithmes, autant je désapprouve for_each en C++11(et +). Il est plus lourd syntaxiquement, et n'apporte pas d'avantage sinificatif en performance (pour ce que j'en ai vu)

[stendhal666]

Le mot "ter" désigne dans un français archaïque et légèrement déformé, le troisième d'un ensemble ou d'un groupe, en l'occurence des cinq Nels qui son (ou plus exactement étaient) les gardiens d'un ordre secret dans un jeu de rôle (inventé par un ami).

Tout s'explique. J'ai l'impression que votre maître de jeu connaissant bien son affaire...

Par ailleurs, je suis contre ce for_each, puisqu'on a for(.
Autant j'aime beaucoup les algorithmes, autant je désapprouve for_each en C++11(et +). Il est plus lourd syntaxiquement, et n'apporte pas d'avantage sinificatif en performance (pour ce que j'en ai vu)

for_each est plus flexible puisqu'on peut fixer le point de départ et le point d'arrivée, y compris par composition d'algorithme:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
std::for_each( std::find(std::begin(vec), std::end(vec), x),
                     std::find(std::begin(vec), std::end(vec), x+y),
                     faire_qqc );

L'autre bon point c'est qu'avec un alias de namespace on pourra faire basculer son code vers les versions parallèles des algorithmes disponibles dans le TS

[jo_link_noir]

Plus flexible, car il y a un manque du côté de la stl: un conteneur sur 2 itérateurs:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
template<class It>
struct Range {
  using iterator = It;
 
  iterator first;
  iterator last; 
 
  iterator begin() const { return first; }
  iterator end() const { return last; }
};
 
template<class Cont, class T, class U>
auto find_range(Cont & cont, T const & x, U const & y) -> Range<decltype(begin(cont))> {
  auto first = std::find(begin(cont), end(cont), x);
  return Range<decltype(first)>{first, std::find(first, end(cont), y)};
}
 
for (auto && x : find_range(vec, x, x+y))) {
  faire_qqc;
}

Il y a quand même un énorme avantage d'utiliser for_each plutôt qu'une boucle: la stratégie utilisée pour le parcours (séquentielle, parallèle) comme dans parallelism TS.

[toto81]

J'ai avancé encore un peu! Création du deck avec tri des carte dans le bon ordre, fonction de mélange et fontion pour couper en deux fonctionnel:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <iostream>
#include <utility>
#include <array>
#include <numeric>
#include <algorithm>
#include <random>
 
const auto nbCarte = 52;
const auto nbCarteParSigne = 13;
const auto nbCouleur = 4;
using Carte = std::pair<unsigned, unsigned>;
using Deck = std::array<Carte, nbCarte>;
 
Carte& operator++(Carte& p) //Ajoute un operateur ++ pour la fonction std::iota qui est appelé dans la fonction "creationDeck"
{
	++p.first;
	++p.second;
	return p;
}
 
auto creationDeck() //Creation d'un array de 52 emplacements qui contient chacun une paire de deux unsigned int
{
	Deck tab;
	std::iota(std::begin(tab), std::end(tab), Carte());
	std::transform(std::begin(tab), std::end(tab), std::begin(tab), [](Carte c)
	{
		c.first %= nbCarteParSigne;
		c.second %= nbCouleur;
		return c;
	});
	std::sort(std::begin(tab), std::end(tab));
	return tab;
}
 
void melangerCarte(Deck &tab) //Fonction de mélange aleatoire
{
	std::random_device random;
 
	std::shuffle(std::begin(tab), std::end(tab), random);
}
 
void couperCarte(Deck &tab) //Fonction qui coupe les carte en deux
{
	std::rotate(tab.begin(), tab.begin() + 27, tab.end());
}
 
int main()
{
	auto jeuDeCarte = creationDeck(); //Crétion du jeu de carte dans un array en appelant la fonction "creationDeck"
 
	melangerCarte(jeuDeCarte); //Melange les cartes aléatoirement en appelant la fonction "melangerCarte"
 
	couperCarte(jeuDeCarte);//Coupe le jeu de carte au milieu en appelant la fonction "couperCarte"
 
	for (const auto& carte : jeuDeCarte) //Affiche le résultat
 
		std::cout << carte.first << ',' << carte.second << ' ';
 
	return 0;
}

Voilà il me manque que la dernière étape, convertir mon tableau en string.. Un petit indice pour m'aider? ^^ J'ai test plein de truc sans aucun résultat concluant...

[stendhal666]

Eh bien, tu as des cartes représentées par une paire de nombre:
- un qui va de 0 à 12
- l'autre de 0 à 3
qu'est-ce qui a une taille qu'on peut définir à 13, à 4, à n'importe-quel nombre d'ailleurs et qui pourrait contenir le nom des cartes ou des couleurs?

[toto81]

Un vector de type string à plusieurs dimensions? ^^'

[stendhal666]

ou deux vectors de string plus simplement?

[toto81]

Oue et j'aime quand c'est simple! ^^

Du coup je dois utiliser une fonction spéciale? J'ai essayé de faire une sorte de copie dans un tableau mais j'ai eu a chaque fois des problèmes de type incompatible etc..

J'ai vu des gens parler de ostream ou je sais plus, une sorte de copie mais entre les truc obsolète ou autre, j'ai dis je vais pas encore afficher un vieux code de louis 14.. x)

[stendhal666]

Il y a beaucoup plus simple: tu crées 2 tableaux de string avec respectivement les noms des cartes et des couleurs, et tu te sers des valeurs dans les cartes comme index pour trouver le nom correspondant dans les tableaux. Les tableaux peuvent être dans la fonction ou dans l'espace global

[toto81]

Salut!

Mais je suis pas sûr de moi car ca affiche bien le nom nom d'une carte mais je vois pas trop comment affiché une carte précise, par exemple, si tu me demande
d'afficher le 7 de carreau, je ne saurais pas qu'elle est son numéro dans le tableau, surtout si le tableau de base est mélangé et coupé ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <iostream>
#include <utility>
#include <array>
#include <numeric>
#include <algorithm>
#include <random>
#include <string>
 
const auto nbCarte = 52;
const auto nbCarteParSigne = 13;
const auto nbCouleur = 4;
using Carte = std::pair<unsigned, unsigned>;
using Deck = std::array<Carte, nbCarte>;
 
Carte& operator++(Carte& p) //Ajoute un operateur ++ pour la fonction std::iota qui est appelé dans la fonction "creationDeck"
{
	++p.first;
	++p.second;
	return p;
}
 
auto creationDeck() //Creation d'un array de 52 emplacements qui contient chacun une paire de deux unsigned int
{
	Deck tab;
	std::iota(std::begin(tab), std::end(tab), Carte());
	std::transform(std::begin(tab), std::end(tab), std::begin(tab), [](Carte c)
	{
		c.first %= nbCarteParSigne;
		c.second %= nbCouleur;
		return c;
	});
	std::sort(std::begin(tab), std::end(tab));
	return tab;
}
 
void melangerCarte(Deck &tab) //Fonction de mélange aleatoire
{
	std::random_device random;
 
	std::shuffle(std::begin(tab), std::end(tab), random);
}
 
void couperCarte(Deck &tab) //Fonction qui coupe les carte en deux
{
	std::rotate(tab.begin(), tab.begin() + 27, tab.end());
}
 
void afficherCarte(Deck &tab, int n) //Fonction qui affiche le nom d'une carte
{
	std::array<std::string, nbCarteParSigne> numero = { "As","Deux","Trois","Quatre","Cinq","Six","Sept","Huit","Neuf","Dix","Valet","Dame","Roi" };
	std::array<std::string, nbCouleur> couleur = { "coeur","carreau","pique","trefle" };
 
	std::cout << numero[tab[n].first] << " de " << couleur[tab[n].second] << std::endl;
}
 
int main()
{
	auto jeuDeCarte = creationDeck(); //Crétion du jeu de carte dans un array en appelant la fonction "creationDeck"
 
	melangerCarte(jeuDeCarte); //Melange les cartes aléatoirement en appelant la fonction "melangerCarte"
 
	couperCarte(jeuDeCarte); //Coupe le jeu de carte au milieu en appelant la fonction "couperCarte"
 
	afficherCarte(jeuDeCarte, 0); //Permet d'affiché le nom de la carte demandé en deuxieme argument contenu dans un array en premier argument 
 
	return 0;
}

[stendhal666]

C'est presque ça!

Trois points:

1. La signature de ta fonction devrait prendre une carte pas un Deck et le numéro de la carte dedans: void afficher_carte(Carte c);. D'ailleurs l'exercice ne demandait pas d'afficher la carte mais de renvoyer une string contenant sa description.
2. L'as devrait être placé en dernier dans ton vecteur des noms. Comme ça l'ordre des noms dans le array<string> est identique à l'ordre en valeur des cartes. Cela simplifiera la comparaison de deux cartes. La carte la plus faible est 2, elle est représentée par 0 dans le premier membre d'une Carte, d'où: numeros[0] == "deux";. De même la carte la plus puissante est l'as, d'où: numeros[NB_CARDS_BY_COLOR-1] == "as";. Pour les couleurs c'est purement conventionnel donc tu peux choisir l'ordre que tu veux.
3. Ta fonction va créer les deux tableaux à chaque fois que tu l'appelles, ce n'est pas optimal Tu as deux solutions: ou bien définir les tableaux dans l'espace global, c'est-à-dire en dehors de la fonction. Ou bien tu les déclares static: ils ne seront créés qu'une fois, au premier appel de la fonction: void afficher_carte(Carte c) { static std::array<std::string, 4> couleurs = { ... }; ... }

Bon, on continue!

Jeu de poker, étape 2:
facile-moyen
- Une main est composée de 5 cartes. Avec l'algorithme std::copy_n, copier les n premières cartes d'un paquet dans une main. Ecrire une fonction pour trier la main en fonction du rang (numéro) des cartes en utilisant std::sort.
- En utilisant (facultatif) l'algorithme std::all_of, vérifier si la main contient une suite (5 cartes qui se suivent) ou une couleur (5 cartes de couleur identique).
moyen-difficile:
- mettons qu'on choisisse de définir une main comme un vecteur de Cartes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

using Hand = std::vector<Card>;

Ecrire une fonction qui divise la main en un vecteur de mains où les cartes sont identiques:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector<Hand> split_by_rank(const std::Hand& hand); // dans chaque Hand du vector de résultat, toutes les cartes ont le même numéro

difficile:
écrire split_by_rank en utilisant l'algorithme std::accumulate.
facile-moyen:
- écrire une fonction qui trie le std::vector<Hand> par ordre décroissant de taille (les groupes de cartes contenant le plus de cartes d'abord).
difficile:
- écrire une fonction qui, en utilisant, les fonctions définies préalablement, permette d'attribuer un score à chaque main.