1. Accueil
  2. Tous les snippets
  3. Snippets C / C++ / C++.NET
  4. Algorithme de calcul de probabilité du jeu risk

Algorithme de calcul de probabilité du jeu risk

0/5 (3 avis)

Snippet vu 13 072 fois - Téléchargée 19 fois

Commenter

Contenu du snippet

Tout le monde connaît le célèbre jeu de stratégie RISK, où le but est de conquérir le monde. Ce jeu bien que stratégique contient une part de chance lors des combats notamment. Ce programme calcule la probabilité de victoire de l'attaquant pour les différentes configuration possibles (un contre deux, trois contre deux). La méthode employée repose sur l'équiprobabilité des lancés de dés. La fonction "bataille()" prend en argument la configuration de la bataille x soldats contre y, ainsi que les lancés de dés de chaque camps. Cette fonction renvoie l'issue de la bataille. La fonction "main()" appelle la fonction bataille pour toutes les combinaisons de des possibles, et ainsi donne les probabilités.

Source / Exemple : 


#include <stdio.h>
#include <string.h>

typedef enum
{ UN_CONTRE_UN = 0,
  DEUX_CONTRE_UN = 1,
  TROIS_CONTRE_UN = 2,
  UN_CONTRE_DEUX = 3,
  DEUX_CONTRE_DEUX = 4,
  TROIS_CONTRE_DEUX = 5
} config;			/*les differentes configuration */

typedef enum
{ DEUX_ATTAQUANTS_MORTS = 0,
  UN_ATTAQUANT_MORT = 1,
  UN_CHACUN = 2,
  UN_DEFENSEUR_MORT = 3,
  VICTOIRE_ATTAQUANT = 4,
  VICTOIRE_DEFENSEUR = 5
} issue;			/*les differentes issues de la bataille */

typedef struct
{
  char d1;
  char d2;
  char d3;
} da;				/*les des de l'attaqquant : max 3 dès */

typedef struct
{
  char d1;
  char d2;
} dd;				/*les des du deffenseur max 2 des */

issue
bataille (config c, da a, dd d)
{
  switch (c)
    {
    case UN_CONTRE_UN:
      if (a.d1 > d.d1)
	return VICTOIRE_ATTAQUANT;
      else
	return VICTOIRE_DEFENSEUR;

    case DEUX_CONTRE_UN:
      if (a.d1 > d.d1 || a.d2 > d.d1)
	return VICTOIRE_ATTAQUANT;
      else
	return UN_ATTAQUANT_MORT;

    case TROIS_CONTRE_UN:
      if (a.d1 > d.d1 || a.d2 > d.d1 || a.d3 > d.d1)
	return VICTOIRE_ATTAQUANT;
      else
	return UN_ATTAQUANT_MORT;

    case UN_CONTRE_DEUX:
      if (d.d1 >= a.d1 || d.d2 >= a.d2)

	return VICTOIRE_DEFENSEUR;
      else
	return UN_DEFENSEUR_MORT;

    case TROIS_CONTRE_DEUX:
      a.d1 = (a.d1 > a.d2) ? a.d1 : a.d2;	//on selectionne les meilleurs dés attaquant
      a.d2 = (a.d2 > a.d3) ? a.d2 : a.d3;	//on selectionne les meilleurs dés attaquant
      goto DEUX_CONTRE_DEUXbis;

    case DEUX_CONTRE_DEUX:
    DEUX_CONTRE_DEUXbis:;
      if ((d.d1 >= a.d1 && d.d2 >= a.d2) || (d.d2 >= a.d1 && d.d1 >= a.d2))
	return DEUX_ATTAQUANTS_MORTS;
      if ((a.d1 > d.d1 && a.d2 > d.d2) || (a.d2 > d.d1 && a.d1 > d.d2))
	return VICTOIRE_ATTAQUANT;
      else
	return UN_CHACUN;
    }
}

int
main (int argc, char **argv)
{
  da a;
  dd d;
  int tmp[6];			//résultat temporaire
  float proba_victoire_attaquant[6];	//résultat définitif

  memset (tmp, 0x0, (sizeof (int) * 6));
  for (a.d1 = 1; a.d1 <= 6; a.d1++)
    for (d.d1 = 1; d.d1 <= 6; d.d1++)
      tmp[bataille (UN_CONTRE_UN, a, d)]++;
  proba_victoire_attaquant[UN_CONTRE_UN] =
    (float) tmp[VICTOIRE_ATTAQUANT] / (tmp[VICTOIRE_ATTAQUANT] +
				       tmp[VICTOIRE_DEFENSEUR]);

  memset (tmp, 0x0, (sizeof (int) * 6));
  for (a.d1 = 1; a.d1 <= 6; a.d1++)
    for (a.d2 = 1; a.d2 <= 6; a.d2++)
      for (d.d1 = 1; d.d1 <= 6; d.d1++)
	tmp[bataille (DEUX_CONTRE_UN, a, d)]++;
  proba_victoire_attaquant[DEUX_CONTRE_UN] =
    (float) (tmp[VICTOIRE_ATTAQUANT] +
	     tmp[UN_ATTAQUANT_MORT] *
	     proba_victoire_attaquant[UN_CONTRE_UN]) /
    (tmp[VICTOIRE_ATTAQUANT] + tmp[UN_ATTAQUANT_MORT]);

  memset (tmp, 0x0, (sizeof (int) * 6));
  for (a.d1 = 1; a.d1 <= 6; a.d1++)
    for (a.d2 = 1; a.d2 <= 6; a.d2++)
      for (a.d3 = 1; a.d3 <= 6; a.d3++)
	for (d.d1 = 1; d.d1 <= 6; d.d1++)
	  tmp[bataille (TROIS_CONTRE_UN, a, d)]++;
  proba_victoire_attaquant[TROIS_CONTRE_UN] =
    (float) (tmp[VICTOIRE_ATTAQUANT] +
	     tmp[UN_ATTAQUANT_MORT] *
	     proba_victoire_attaquant[DEUX_CONTRE_UN]) /
    (tmp[VICTOIRE_ATTAQUANT] + tmp[UN_ATTAQUANT_MORT]);

  memset (tmp, 0x0, (sizeof (int) * 6));
  for (a.d1 = 1; a.d1 <= 6; a.d1++)
    for (d.d1 = 1; d.d1 <= 6; d.d1++)
      for (d.d2 = 1; d.d2 <= 6; d.d2++)
	tmp[bataille (UN_CONTRE_DEUX, a, d)]++;
  proba_victoire_attaquant[UN_CONTRE_DEUX] =
    (float) tmp[UN_DEFENSEUR_MORT] / (tmp[UN_DEFENSEUR_MORT] +
				      tmp[VICTOIRE_DEFENSEUR]) *
    proba_victoire_attaquant[UN_CONTRE_UN];

  memset (tmp, 0x0, (sizeof (int) * 6));
  for (a.d1 = 1; a.d1 <= 6; a.d1++)
    for (a.d2 = 1; a.d2 <= 6; a.d2++)
      for (d.d1 = 1; d.d1 <= 6; d.d1++)
	for (d.d2 = 1; d.d2 <= 6; d.d2++)
	  tmp[bataille (DEUX_CONTRE_DEUX, a, d)]++;
  proba_victoire_attaquant[DEUX_CONTRE_DEUX] =
    (float) (tmp[VICTOIRE_ATTAQUANT] +
	     tmp[UN_CHACUN] * proba_victoire_attaquant[UN_CONTRE_UN]) /
    (tmp[VICTOIRE_ATTAQUANT] + tmp[UN_CHACUN] + tmp[DEUX_ATTAQUANTS_MORTS]);

  memset (tmp, 0x0, (sizeof (int) * 6));
  for (a.d1 = 1; a.d1 <= 6; a.d1++)
    for (a.d2 = 1; a.d2 <= 6; a.d2++)
      for (a.d3 = 1; a.d3 <= 6; a.d3++)
	for (d.d1 = 1; d.d1 <= 6; d.d1++)
	  for (d.d2 = 1; d.d2 <= 6; d.d2++)
	    tmp[bataille (TROIS_CONTRE_DEUX, a, d)]++;
  proba_victoire_attaquant[TROIS_CONTRE_DEUX] =
    (float) (tmp[VICTOIRE_ATTAQUANT] +
	     tmp[UN_CHACUN] * proba_victoire_attaquant[DEUX_CONTRE_UN] +
	     tmp[DEUX_ATTAQUANTS_MORTS] *
	     proba_victoire_attaquant[UN_CONTRE_DEUX]) /
    (tmp[VICTOIRE_ATTAQUANT] + tmp[UN_CHACUN] + tmp[DEUX_ATTAQUANTS_MORTS]);

  printf
    ("Probabilité de victoire du jeu RISK pour l'attaquant\n--------------------------------------------------------------------------------\n*Un attaquant contre un defenseur : %.1f%%\n*Deux attaquants contre un defenseur : %.1f%%\n*Trois attaquants contre un defenseur : %.1f%%\n*Un attaquant contre deux défenseurs : %.1f%%\n*Deux attaquants contre deux defenseurs : %.1f%%\n*Trois attaquants contre deux defenseurs : %.1f%%\n\n\n",
     proba_victoire_attaquant[UN_CONTRE_UN] * 100,
     proba_victoire_attaquant[DEUX_CONTRE_UN] * 100,
     proba_victoire_attaquant[TROIS_CONTRE_UN] * 100,
     proba_victoire_attaquant[UN_CONTRE_DEUX] * 100,
     proba_victoire_attaquant[DEUX_CONTRE_DEUX] * 100,
     proba_victoire_attaquant[TROIS_CONTRE_DEUX] * 100);
  return 0;

}

A voir également

Ajouter un commentaire Commentaires
Signaler
Messages postés
173
Date d'inscription
jeudi 20 décembre 2001
Statut
Membre
Dernière intervention
22 août 2008
Rigolo, fallait y penser :)
Juste pour pinailler, tes enum:
# typedef enum
# { UN_CONTRE_UN = 0,
# DEUX_CONTRE_UN = 1,
# TROIS_CONTRE_UN = 2,
# UN_CONTRE_DEUX = 3,
# DEUX_CONTRE_DEUX = 4,
# TROIS_CONTRE_DEUX = 5
# } config;
Pas besoin de donner les valeurs, le principe de l'enumeration c'est que les valeurs sont données automatiquement a partir de la premiere :
# typedef enum
# { UN_CONTRE_UN = a, // a un entier quelconque, ici 0
# DEUX_CONTRE_UN, // DEUX_CONTRE_UN a+1 1
# TROIS_CONTRE_UN, // TROIS_CONTRE_UN = a+2= 2
# UN_CONTRE_DEUX, // etc.
# DEUX_CONTRE_DEUX,
# TROIS_CONTRE_DEUX
# } config;
Signaler
Messages postés
1
Date d'inscription
jeudi 29 mars 2007
Statut
Membre
Dernière intervention
16 août 2007
Marrant et bien pensé, je vais de ce pas le tester avec une vraie partie.
Signaler
Messages postés
2
Date d'inscription
mercredi 8 août 2007
Statut
Membre
Dernière intervention
15 août 2007
tres encourageant merci .bon courage .
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (vinc1008881)