@bacelar: Je n'ai pas trouvé de tutoriel satisfaisant pour LINQ. En connais-tu un? Mon code est tout de même relativement simple. Peut-être que la fonction generer peut être remplacer par une simple fonction de LINQ Peut-être qu'on peut afficher un tableau complet dans une seule ligne. Quand à ma fonction intersec, je la trouve pratique car on pourrait indexer dans un tableau la valeur de count pour donner le gain associé à chaque tirage. Les autres statistiques devraient être également assez simples.
Le Tout est souvent plus grand que la somme de ses parties.
>Je n'ai pas trouvé de tutoriel satisfaisant pour LINQ. En connais-tu un?
Désolé, j'ai appris ça à partir de "What's New" quand c'est apparu, il y a, au moins 15 ans.
Mais cela doit être maintenant dans les cours "de base" du C#.
>Mon code est tout de même relativement simple.
Oui, tout à fais, mais pas forcément comme une personne connaissant "bien" .NET le ferait de manière "instinctive".
>Peut-être que la fonction generer peut être remplacer par une simple fonction de LINQ
En utilisant les méthodes Enumerable.Range et OrderBy générer un tirage se fait en une ligne et un ensemble de tirage, affichage compris, en 5.
Extrait du code que j'ai déjà posté qui fait tout cela :
for (int i = 0; i < nbr_tirages; i++)
{
var boules = Enumerable.Range(1,50).ToList();
var shuffled = boules.OrderBy(_ => hasard.Next()).ToList();
res.Add(string.Join(" - ", shuffled.GetRange(0,6)))
}
>Peut-être qu'on peut afficher un tableau complet dans une seule ligne. Oui :
string.Join(" - ", shuffled.GetRange(0,6))
>Quand à ma fonction intersec, je la trouve pratique car on pourrait indexer dans un tableau la valeur de count pour donner le gain associé à chaque tirage.
Oui, mais, comme l'a déjà indiqué le PO, il existe une méthode Intersect qui fait partiellement le job, donc risque de confusion, et il est plus "naturel" en .NET d'utiliser une méthode d’extension/lambda expression sur un Enumerable que de faire des double-boucle dessus.
Donc une lambda expression qui calcul un résultat pour chaque élément d'un Enumerable est plus "idiosyncratique" du C# avec l'utilisation de la méthode d'extension "Enumerable.Select".
>Les autres statistiques devraient être également assez simples.
Tout comme pour le "gain", il est plus simple/idiosyncratique de faire cela via expressions lambda.
C'est un peu la même démarche que dans le C++ moderne où l'on utilise bien plus volontiers les lambda et les algorithmes de la STL.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
J'ai mal choisi le nom de ma fonction intersec, j'aurais pu l'appeler score ou autre chose. Je ne connais pas l'efficacité de la fonction/méthode intersec. J'ose croire qu'elle n'est pas proportionnelle au produit des longueur des listes. Ma méthode est de l'ordre de la somme des longueurs. Et je retourne directement une valeur facilement utilisable pour toutes les statistiques. La valeur peut, par exemple, servir directement d'indice dans une table donnant les gains en fonctions des valeurs tirées.
Le Tout est souvent plus grand que la somme de ses parties.
Après avec LINQ, il y a la fonction SequenceEqual, qui permettrait ici de dire si 2 tirages sont égaux (avec prise en compte de l'ordre) (on pourrait les trier avant si besoin)
>J'ose croire qu'elle n'est pas proportionnelle au produit des longueur des listes.
L'infrastructure LINQ permet de spécialiser les algorithmes en fonction du type d'Enumerable.
Par exemple, si les 2 listes viennent plus ou moins directement d'enregistrement dans une base de données, il est assez courant que des fonctions d'extension comme Intersect soit directement des appels à des fonctions dans le moteur de base de données et non fait en "RAM coté client".
Je ne connais pas l'implémentation "générique" sur des List<int>, mais s'il s’avérerait en complexité N², il est tout à fait possible de spécialiser les types Enumerable avec une implémentation Intersect "de notre cru".
Mais comme votre "Intersect" n'a pas le même sens que celui de LINQ, il serait toujours préférable dans faire une simple lambda expression ou une fonction d'extension, pour ne pas tout mélanger.
Je ne dis pas que vos fonctions sont "fausses" mais que, généralement, on en ferait des fonctions d'extension ou des lambda, pour ne pas "polluer" les espaces de noms avec des méthodes "trop spécifiques" et plus facilement utilisable dans du code à évaluation "faignante" et/ou asynchrone.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
désolé bacelar j'étais un peu enrhumé depuis le début de semaine, voici mon code:
internal class Program
{
static Random rand = new Random(DateTime.Now.Millisecond); //déclaration d'une variable globale
static void Main(string[] args)
{
int nb_tirage;
do
{
Console.WriteLine("Entrer le nombre de combinaisons désirées:");
} while (!Int32.TryParse(Console.ReadLine(), out nb_tirage));
for (int a = 0; a < nb_tirage; a++) test();
Console.WriteLine("\nLa combinaison gagnante est:");
//test();
combinGagnante();
Console.WriteLine("le numero complementaire est:");
numCompletmentaire();//Appel à la procédure de tirage du numéro complémentaire
for (int i = 0; i < nb_tirage; i++)
{
foreach (int r in combinGagnante.intersect(test)) //intersection entre les listes de combinaison et la combinaison gagnante
Console.WriteLine(r);
}
Console.ReadLine();
}
private static void test()//Procédure permet de tirer les combinaisons demadées par l'utilisateur
{
List<int> res = new List<int>();
for (int i = 0; i < 6; i++)
{
int nbr;
do
{
nbr = rand.Next(1, 50);
} while (res.Contains(nbr)); // on tire un nombre tant qu'il n'est pas présent dans res
res.Add(nbr);
}
string res_string = String.Join(", ", res);
Console.WriteLine(res_string);
}
private static void combinGagnante()// combinaison gagnante
{
List<int> comb_gagnante = new List<int>();
for (int i = 0; i < 6; i++)
{
int nbr3;
do
{
nbr3 = rand.Next(1, 50);
} while (comb_gagnante.Contains(nbr3));
comb_gagnante.Add(nbr3);
}
string complementaire_string = string.Join(" ", comb_gagnante);
Console.WriteLine(complementaire_string);
}
private static void numCompletmentaire() // Cette procédure permet de faire le tirage du nombre complémentaire
{
List<int> complementaire = new List<int>();
for (int i = 0; i < 1; i++)
{
int nbr2;
do
{
nbr2 = rand.Next(1, 10);
} while (complementaire.Contains(nbr2));
complementaire.Add(nbr2);
}
string complementaire_string = string.Join(" ", complementaire);
Console.WriteLine(complementaire_string);
}
}
}
à la ligne 28 je veux faire une intersection entre le résultat des listes de combinaison et la liste de la combinaison gagnante.
mais il me marque en rouge combinGagnante, "avec comme message: est une méthode qui n'est pas valide dans le contexte donné"
Vous n'avez pas compris la différence entre variable et méthode (en espérant que vous n'avez pas encore abordé la programmation fonctionnelle, sinon, ça sera un carnage).
Ligne 28 :
foreach (int r in combinGagnante.intersect(test))
Ok, c'est quoi le type de "combinGagnante" ?
C'est quoi le type de "test" ?
C'est des méthodes, et on appelle une méthode avec l'opérateur "()".
Donc "(test)", ça veut dire quoi ?
Et "combinGagnante.intersect(...)", c'est appeler la méthode intersect sur l'objet qui est référencé par la variable "combinGagnante", mais qui n'est pas une variable. Donc, c'est nimportnawak.
C'est quoi la différence entre la méthode "test" et "combinGagnante" ? Rien, absolument rien, le nom d'une variable locale à la méthode, on s'en cogne.
Vous n'avez absolument pas suivi mon code :
- variable statique "rand", utilisé comme une globale bien sale, mais bon son usage dans votre code n'est pas des plus dégueulasse
- utilisation des boucles toutes pourries à la place de simplement utiliser la méthode d'extension "OrderBy"
- utilisation d'un type de retour "void" complètement débile, à la place de renvoi des données utiles en valeur de retour des méthodes.
- etc...
Vous ne savez toujours pas comment se servir d'une méthode, et c'est la base, révisez les, au moins un peu.
P.S.: la boucle ligne 88, sérieux.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
Non, "test" et "combinGagnante" sont des fonctions/procédures, "test()" et "combinGagnante()" sont des appels à ces fonctions/procédures.
Putain, ça fait 25 ans qu'il n'y a que le VBA pour avoir des "procédures" (différentes des fonctions).
Lors de l'évaluation de l'instruction/expression, les appels de fonction sont remplacés par la valeur de retour de la fonction.
Avec vos fonctions qui renvoient rien (cf. le void en type de retour), bin vos appels de fonctions ils servent à que dalle, sauf à l'effet de bord de faire "tourner" la pseudo variable globale "rand" et d'afficher des bidules dans la console qui ne servent à rien puisque vous ne travaillez que sur des variables locales sans jamais rien retourner.
Vous ne savez toujours pas comment se servir d'une méthode, et c'est la base, révisez les, au moins un peu.(BIS)
Si vous ne comprenez pas que votre code n'a aucun putain de sens, cf. la phrase précédente.
>Je veux faire l'intersection entre la liste gagnante
Bin, commencez par faire en sorte qu'elle "sorte" de la variable locale "comb_gagnante" pour vous en servir ailleurs.
>avec les autres listes
Idem, "res" doit sortir, et vous devez stocker ces listes "quelque part".
Vous vous noyez dans un vers d'eau avec un code bien trop compliqué pour ce qu'il est sensé faire.
>c'est pourquoi j'avais mis la fonction interssect
C'est "Intersect", pas "interssect" ni "intersect"
Et c'est une méthode d'extension de la classe/interface "Enumerable" alors que "combinGagnante" est une méthode, pas un "Enumerable".
Vous nous sortez une copie d'écran sans nous fournir le code associé, qui n'est en aucun cas celui que vous avez posté avant (car il n'a aucune chance de compiler), ça nous fait une belle jambe.
Si vous ne prenez pas la peine d'apprendre les bases, on va tourner en rond.
Si vous ne comprenez pas les bases, posez les questions sur ce forum, c'est fait pour.
Avec les bons outils, votre code doit faire entre 15 et 20 lignes, avec quasi aucune boucle.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
Si je peux le faire en C++ en moins de 60 lignes, ça doit pouvoir se faire en C# avec moins de lignes que ça. Ma fonction generer() pourrait être remplacée par des méthodes comme enumerable et shuffled. Je tiens tout de même à ma fonction score() que je trouve très pratique. - #include <iostream> #include <vector> #include <array> #include <random> #include <ctime> #include <algorithm>
void generer(Random &myRand, Vecteur &tab) { Tableau flag = {0}; for(int i = 0; i < tab.size(); i++) { int essai; do { essai = myRand() % 50; } while(flag[essai]); tab[i] = essai + 1; flag[essai] = 1; } }
int score(Vecteur gagnant, Vecteur tirage) { Tableau flags = {0}; for(int i = 0; i < 6; i++) flags[gagnant[i]-1] = 2; flags[gagnant[6]-1] = 1; int count = 0; for(int i = 0; i < 6; i++) { count += flags[tirage[i]-1]; } return count; }
int main(void) { Vecteur gagnant (7); Vecteur tirage (6); Vecteur stats (13, 0); Vecteur gains = {0, 0, 0, 0, 0, 0, 1000, 2000, 10000, 20000, 100000, 200000, 1000000}; unsigned int const seed = std::time(nullptr); Random myRand { seed }; generer(myRand, gagnant); std::for_each(gagnant.begin(), gagnant.end(), [](int &n){std::cout << n << " ";}); std::cout << std:: endl; std::cout << "Donnez le nombre de combinaisons "; int nbc; std::cin >> nbc; for(int c = 0; c < nbc; c++) { generer(myRand, tirage); int count = score(gagnant, tirage); stats[count]++; } for(int i=0; i<13; i++) { std::cout << i/2 << ((i%2) ? "+" : "") << " donne " << stats[i] << ", avec un gain de " << gains[i] << std::endl; } return 0; } - 38 48 1 11 49 9 10 Donnez le nombre de combinaisons 10000000 0 donne 3832268, avec un gain de 0 0+ donne 605652, avec un gain de 0 1 donne 3637429, avec un gain de 0 1+ donne 466918, avec un gain de 0 2 donne 1165199, avec un gain de 0 2+ donne 116173, avec un gain de 0 3 donne 155915, avec un gain de 1000 3+ donne 11355, avec un gain de 2000 4 donne 8517, avec un gain de 10000 4+ donne 410, avec un gain de 20000 5 donne 159, avec un gain de 100000 5+ donne 4, avec un gain de 200000 6 donne 1, avec un gain de 1000000
Le Tout est souvent plus grand que la somme de ses parties.
class Program
{
static void Main(string[] args)
{
int nb_tirage;
do
{
Console.WriteLine("entrer le nombre de combinaisons desirées");
} while (!Int32.TryParse(Console.ReadLine(), out nb_tirage));
Random hasard = new Random();
var tirages = GenererTirages(nb_tirage, hasard);
var tirage_loto = GenererTirages(1, hasard)[0];
var res = new List<int>();
tirages.ForEach(t =>
{
int intersection = t.GetRange(0, 6).Intersect(tirage_loto.GetRange(0, 6)).Count();
int gain = 0;
switch (intersection)
{
case int n when (n >=3) :
gain = (int)Math.Pow(10, n);
if ((n < 6) && (t.Intersect(tirage_loto.GetRange(6, 1)).Count()>0))
gain *= 2;
break;
}
res.Add(gain);
}
);
Console.WriteLine(String.Format("tirage loto : {0}",String.Join(", ", tirage_loto)));
for (int i = 0; i < res.Count; i++)
Console.WriteLine(String.Format("{0} : {1} : gain = {2}", i+1, String.Join(", ", tirages[i]), res[i]));
}
private static List<List<int>> GenererTirages(int nb_tirage, Random hasard)
{
List<List<int>> res = new List<List<int>>();
var boules = Enumerable.Range(1, 50).ToList();
for (int i = 0; i < nb_tirage; i++)
{
var shuffled = boules.OrderBy(_ => hasard.Next()).ToList();
res.Add(shuffled.GetRange(0, 7));
}
return res;
}
}
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
euh, du coup comme tes fonctions renvoient des entiers, en tout cas tes variables MesNombres et MesNombres2 (pas sûr que ce soit le bon type de sortie ..), les entiers n'étant pas dérivés d'Enumerable, il n'a pas accès cette fonction Intersect (d'ailleurs, en tant qu'entier est-ce qu'il en a besoin).
Pour le bénéfice (?) de mgf, j'ai "essayé" de réécrire ma fonction score à la sauce de C# avec un dictionnaire: - Dictionary<int, int> dico = new Dictionary<int, int>(); for(int i = 0; i < 6; i++) } dico.Add(gagnanrt[i], 2); } dico.Add(gagnant[6], 1); int count = 0; for(int i = 0; i < 6; i++) { dico.TryGetValue(tirage[i], out int val); count += val; } return count;
Le Tout est souvent plus grand que la somme de ses parties.
Évitez les variables statiques (ligne 1 à 12) qui ne sont ici que des variables globales déguisées.
Ligne 23 - 25, c'est pas cohérent, vous appelez "entrerNombre" pour récupérer un nombre et vous le passez à "GenererCombinaisons" en argument, mais "GenererCombinaisons" n'en fait rien.
Soit c'est de la responsabilité de "GenererCombinaisons" de demander ce nombre, donc pas d'argument, soit ce n'est pas de son ressort et il prend celui donné en paramètre. Conseil général : respecter les principes SOLID, et en particulier le SRP : passez cette information en paramètre (et arrêtez de coller des entrées/sortie console partout, SVP, because magic numbers un peu partout dans le code).
Dans la méthode "GenererCombinaisons", c'est où que le résultat est rempli ?
"NumeroComplementaire" peut donc tirer un nombre qui a déjà été tirer dans la combinaison "gagnante", c'est "original".
Pour la méthode "verification", le paramètre "a" est un non-sens.
D'une, vous utilisez une variable qui n'est pas utilisé lors de la génération, cf. le problème entre "entrerNombre" et "GenererCombinaisons", et, en plus, cette donnée peut être déduite des autres variables passées en paramètre (cf. la taille des tableaux, qui devrait être des listes, à mon avis) : moins de paramètre, moins de bugs.
La méthode "verification" est beaucoup trop longue et compliquée pour ce qu'elle fait. Les lignes 21 à 31 font la même chose, avec le calcul du gain, sans vos foutues sorties/consoles, mais ça rajoute 2 à 3 lignes dans un code correctement structuré, sans copier-coller à la con.
Si, au lieu d'avoir toute une tripoté de "nbr_xyyy", vous aviez un simple tableau, ça donnerais quoi comme code ?
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
@mgf: je comprend que tu es débutant ... mais tu n'es pas assez fainéant. Les tableaux et les listes, ça n'existe pas en C#? Et le slicing: tableau[debut..>fin] ? Va falloir que j'apprenne le C# pour t'aider.
Le Tout est souvent plus grand que la somme de ses parties.
profite de l'erreur pour voir ce que valent tes valeurs i, j , tabcombinaisons et combinaisonsGagnante (ainsi que les tailes de ces 2 tableaux, vu que l'erreur indique un dépassement d'indice dans ce dernier tableau)
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.