Les systèmes réducteurs

Tiens en zyeutant à droite à gauche sur le net, je crois que j'ai trouvé peut être une piste d'amélioration du système de calcul. En fait on doit pouvoir faire beaucoup plus rapide en prenant le problème à l'envers : plutôt que de rechercher les combinaisons qui permettent de résoudre le problème comme ça brutalement ne serait-il pas mieux de chercher parmis les n combinaisons possibles celles qui ont moins de 3 numéros en commun ; du coup on fait un seul passage sur l'ensemble des combinaisons et on vérifie à la fin que l'on a ce que l'on a bien ce que l'on voulait.
Euh tu m'as suivi ?

Bon je vais essayer de recoder ça et je te transmet le bout de code.

A+

Despeludo

Ok effectivement c'est beaucoup plus rapide.
J'ai obtenu un système réduit pour un sélection de 6 à 49 numéros en moins de dix minutes.
Par contre je n'ai mis la vérification  pour gagner du temps. Libre à toi de le faire.
Alors comme promis je remets le code ici.
Bon courage pour les prochains tirages.

===========================================================

program Reducteur;

{$APPTYPE CONSOLE}

uses
  SysUtils;

{
  Objectif : programme de calcul de systèmes réducteurs
  Le programme calcule le nombre de combinaisons nécessaires pour
  être sûr d'obtenir n numéros parmis m tirés sur une sélection de p numéros
}

type
  TCombinaison = record
    Necessaire : Boolean;
    Tirage : array[0..5] of byte;
  end;

function Combinaison(AValeurMax : Integer; ASelection : Integer) : Integer;
var
  i : Integer;
  p : Integer;
  r : Int64;
begin
  r := 1;
  p := AValeurMax;
  for i := 0 to Pred(ASelection) do begin
    r := p * r;
    Dec(p);
  end;
  p := ASelection;
  for i := 0 to Pred(ASelection) do begin
    r := r div p;
    Dec(p);
  end;
  Result := r;
end;

var
  i : integer;
  j,k,l : Integer;
  nb_numeros_tires : Integer;
  nb_numeros_selectionnes : Integer;
  nb_numeros_objectif : Integer;
  nb_numeros_max : Integer;
  combinaisons : array of TCombinaison;
  nb_combinaisons : Integer;
  nb_numero_communs : Integer;
  nb_combinaisons_selectionnee : Integer;
begin
  nb_numeros_tires := 6;     // on part de cette base pour le loto
  nb_numeros_max := 49;
  nb_numeros_objectif := 3;
  for nb_numeros_selectionnes := nb_numeros_tires to nb_numeros_max do begin
    // calcul du nombre de combinaisons possibles
    nb_combinaisons := Combinaison(nb_numeros_selectionnes, nb_numeros_tires);
    SetLength(combinaisons, nb_combinaisons);
    System.Writeln(Format('Selection : %d '#7' Combinaisons : %d', [nb_numeros_selectionnes, nb_combinaisons]));

    // remplissage du tableau
    combinaisons[0].Tirage[0] := 1;
    combinaisons[0].Tirage[1] := 2;
    combinaisons[0].Tirage[2] := 3;
    combinaisons[0].Tirage[3] := 4;
    combinaisons[0].Tirage[4] := 5;
    combinaisons[0].Tirage[5] := 6;
    Combinaisons[0].Necessaire := True;   // Par défaut on garde tout
    if High(Combinaisons) > 0 then begin
      for i := 1 to High(Combinaisons) do begin
        for j := 0 to High(Combinaisons[i].Tirage) do begin
          Combinaisons[i].Tirage[j] := Combinaisons[i-1].Tirage[j];
        end;
        j := High(Combinaisons[i].Tirage);
        Inc(Combinaisons[i].Tirage[j]);
        while Combinaisons[i].Tirage[j] > (nb_numeros_selectionnes + j - High(Combinaisons[i].Tirage)) do begin
          Inc(Combinaisons[i].Tirage[j-1]);
          Dec(j);
        end;
        for j := 1 to High(Combinaisons[i].Tirage) do begin
          if Combinaisons[i].Tirage[j] > (nb_numeros_selectionnes + j - High(Combinaisons[i].Tirage)) then begin
            Combinaisons[i].Tirage[j] := Combinaisons[i].Tirage[j-1] + 1;
          end;
        end;
        Combinaisons[i].Necessaire := True;
      end;
    end;

    // Recherche des combinaisons nécessaires
    nb_combinaisons_selectionnee := 0;
    for i := 0 to Pred(nb_combinaisons) do begin
      if Combinaisons[i].Necessaire then begin
        Inc(nb_combinaisons_selectionnee);
        for j := i + 1 to Pred(nb_combinaisons) do begin
          nb_numero_communs := 0;
          for k := 0 to High(Combinaisons[i].Tirage) do begin
            for l := 0 to High(Combinaisons[j].Tirage) do begin
              if Combinaisons[i].Tirage[k] = Combinaisons[j].Tirage[l] then begin
                Inc(nb_numero_communs);
                if nb_numero_communs = nb_numeros_objectif then break;
              end;
            end;
            if nb_numero_communs = nb_numeros_objectif then break;
          end;
          if nb_numero_communs = nb_numeros_objectif then begin
            Combinaisons[j].Necessaire := False;
          end;
        end;
      end;
    end;

    // Affichage
    Writeln(Format('%d combinaisons necessaires', [nb_combinaisons_selectionnee]));
    for i := 0 to Pred(nb_combinaisons) do begin
      if Combinaisons[i].Necessaire then begin
        for j := 0 to High(Combinaisons[i].Tirage) do begin
          write(Format('%.2d ', [Combinaisons[i].Tirage[j]]));
        end;
        writeln('');
      end;
    end;

  end;
  system.Readln;

end.

Je ne pense qu'il soit utile de tester toutes les sélections car qd on joue on sélectionne une série de numéros et ensuite on choisit un type de grille.
Par ailleurs, on doit pouvoir choisir son jeu..(loto, keno, pmu + ceux à l"étranger
et il y en a bcp..)
ce qui revient à dire que la poblématique est la suivante :

Combien (et comment) faut-il prendre au minimum de p-parties (les grilles)  de {1,...,m} (la sélection) pour que toute t-partie  de {1,...,m}  (trace du tirage dans la sélection) ait au moins r éléments communs (combinaison gagnante) avec au moins l'une d'entre elles?

Car en fait, ce qui compte c'est de jouer le minimum de combinaisons permettant d'assurer à X % (pour l'instant à 100 %, mais après c'est à étudier)
c'est-à-dire être certain d'avoir la condition de garantie que l'on a choisit au départ et au moins UNE FOIS.
Ex : tu prend 15 numéros, jouer des grilles de 6 et tu veux une garantie de 5/7 et c'est-à-dire avoir au moins une grille de 5 bons numéros sur 6 si 7 bons numéros sortent dans les 15.
Quelles sont les combinaisons minimum à jouer(bien sûr afin de dépenser le moins possible)
afin d'assurer le résultat escompté ?
et c'est pas sûr qu'il n'y ait qu'une solution..

Enfin, ça commence à chauffer et çà devient très intéressant..
Evidemment, reste le problème du choix de la sélection, mais ça c'est un autre débat...

Je propose que tu déposes ton programme sur le forum en créant une interface + une ListBox1 + Tbutton1 + placer 3 edits et remplacer les writeln par ListBox1.items.add(Format(....));
pour le 2e writeln, il suffit de faire une concaténation..

Ce qui permettra d'avoir un ensemble plus convivial et d'élargir le débat à tout le forum.

@+
 
cantador

Bonjour à tous !
Voilà, je suis tout nouveau et je n'y connais rien de rien en math. Mais, je suis amateur de Kéno. Je viens de m'inscrire sur le site car j'ai remarqué que vous en parliez (mais vous êtes tous de gros connaisseurs). Quant à moi, je suis le joueur lambda de tous les jours. J'ai une question, en espérant que l'on puisse m'apporter une aide.
Voilà, j'ai 19 n° fétiches. Je désire jouer des grilles de 6 n° (potentiel de gains pour 6 bons n° 1000¤, pour 5n° 30¤ et 4n° 2¤....mais je ne vous apprends rien). J'aimerais savoir si un système réducteur existe pour jouer 19n° et être certain d'obtenir les 6 bons numéros, si 6/7/8 ou 9n° ... sortent dans ma selection de 19n°. J'espère que mes explications sont assez claires pour avoir une réponse de votre part. (Moi, je me comprends, mais je ne suis pas sûr d'être bien clair, veuillez m'en excuser SVP, merci). J'attends avec impatience vos réponses.
Cordialement à tous ! et encore merci d'avance !
Hallyd

Pardon, je pense que 6 bons n° sur 19, c'est beaucoup trop (après réflexion). Par contre est-ce que vous pouvez me dire si cela est possible avec 9 numéros. Donc un système efficace de 6/6 bon numéros sur 9 joués. Bien sûr, si 6n° sont corrects dans ma sélection. Merci et à bientôt. Hallyd

bonsoir,

Si ta sélection est de 19 numéros, il est inutile de tenter de gagner une grille de 6/6, le nombre de combinaisons a joué étant trop important.

en revanche tu peux jouer des grilles de 10 avec une petite chance de gagner
(si tu as 9 bons numéros/19) une grille de 6/10 ou 7/10.
les autres gains sont hors de portée..
je sais c'est dur, mais c'est la dure réalité.

cantador

Bonsoir,
Merci mille fois Cantador, et dis moi. 6/9 d'après toi c'est faisable ?
merci

Oui, des grilles de 6/6(1000¤), 6/7, 6/8, 6/9 sont possibles.
En fait toute la difficulté est d'avoir une sélection riche la plus courte possible.
il faut beaucoup d'observation(ou faire un programme qui le fait automatiquement) et aussi de la chance.

cantador

Superbe Cantador, merci !
Mais maintenant, comment je fais. Est-ce que tu peux me mettre la
solution.......mais pas comme vous faites avec tel ou tel formule, car
je n'y comprends absolument rien, vous êtes tous trop 'balaises'.
Est-ce que tu m'alligner les nombres, que j'y comprenne quelque chose.
Peux-tu me faire ca ? ou est-ce trop demandé, car trop long !
Merci, j'attends ta réponse. Cordialement

hou là, il n'existe pas de solutions miracles...
mais à force d'observations, on finit par écrire un programme qui note certaines choses..et de temps en temps ça marche..mais si on fait la somme des gains et des pertes, ca reste faiblard...
C'est surtout un passe-temps comme un autre..
Mais n'espère pas t'enrichir..sauf un coup de bol de gagner un gros lot.
et ensuite tu vas à la pêche ou à la chasse !
cantador