Fonction rand

invitee1464df2 · 21/09/2011, 08h30

Bonjour,
Je fais un tirage loto, mon but c'est lorsque je presse le switch ca me donne un nombre entre 1-45 !
mon je dois tirer 6 chiffres pour 1 tirage!

Mais des fois il y a 2 fois le même numero qui sort!!¨

Je n arrive pas à faire une fonction RAND() !

QUi peut m aider??

Code:

int i,j,k, tab1[6],tab2[6];
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}

/*** FONCTION RAND ***/
void RAND()
{


}

void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)
   {
      k=0;
      do
      {
         if(input(SW0) == 0)
         {
           do
           {
               output_high(LED0);
           }
           while(!input(SW0));
              
           tab1[k] = rand()% 45 + 1;
     
          do
          {
            for(j=0;j<6;j++)
            {
               if(tab1[i] == tab2[j+1])
               {
                  tab1[i] = rand()%45 + 1;
                  i=0;
               }
            }
            i++;           
          }
          while(i<6);            printf("%d\n ",tab1[k]);
            k++;
         }  
         else
            output_low(LED0);   
      }while(k<6);
      printf("\n");   
   }
}

invite29971eb1 · 21/09/2011, 09h04

Du fait de l'aléatoire, rien n'empêche que la même valeur sorte 2,3 fois voire à chaque fois.

Il faut simplement tester si la valeur est déjà dans le tableau et recommencer au cas ou.

**Jack** · 21/09/2011, 09h10

De plus, pour éviter que la même séquence ne se répète, il faut initialiser le générateur de séquence (pseudo) aléatoire. Sur un PC, on fait ça à partir de l'heure courante. Sur un micro contrôleur, on peut prendre la valeur d'un compteur interne.

A+

PS: je l'ai fait pour cette fois, mais à l'avenir pense à mettre des balises code afin de rendre ton code plus lisible

invitee1464df2 · 21/09/2011, 09h27

Je testes sur 2 tableaux

if(input(SW0) == 0)
{
do
{
output_high(LED0);
}
while(!input(SW0));

tab1[i] = rand()% 45 + 1;
tab2[j] = tab1[i];

k=0;
do
{
j=0;
do
{
if(tab1[0] == tab2[j+1])
tab1[0] = rand()%45 + 1;

if(tab1[1] == tab2[j+1])
tab1[1] = rand()%45 + 1;

if(tab1[2] == tab2[j+1])
tab1[2] = rand()%45 + 1;

if(tab1[3] == tab2[j+1])
tab1[3] = rand()%45 + 1;

if(tab1[4] == tab2[j+1])
tab1[4] = rand()%45 + 1;

if(tab1[5] == tab2[j+1])
tab1[5] = rand()%45 + 1;
j++;
}while( j< 5 );
k++;

} while(tab1[0] == tab2[k] && tab1[1] == tab2[k] && tab1[2] == tab2[k] && tab1[3] == tab2[k] && tab1[4] == tab2[k] && tab1[5] == tab2[k]);

printf("%d\n ",tab1[k]);

A voir en vidéo sur Futura · Aujourd'hui

invitee1464df2 · 21/09/2011, 09h36

J'ai un problème dans // *******TEST DES NOMBRES***************//
qui peut m'aider?
Je pens que c'est juste mais il doit y avoir une erreur dans le DO WHILE
} while(tab1[0] == tab2[k] && tab1[1] == tab2[k] && tab1[2] == tab2[k] && tab1[3] == tab2[k] && tab1[4] == tab2[k] && tab1[5] == tab2[k]);

Code:

 while(TRUE)
   {
      i=0;
      do
      {
         if(input(SW0) == 0)
         {
           do
           {
               output_high(LED0);
           }
           while(!input(SW0));
              
           tab1[i] = rand()% 45 + 1;
           tab2[j] =  tab1[i];
           
           
           // *******TEST DES NOMBRES***************//
           k=0;
         do
         {
                j=0;
                do
                {
                   if(tab1[0] == tab2[j+1])
                              tab1[0] = rand()%45 + 1;
                      
                   if(tab1[1] == tab2[j+1])                  
                              tab1[1] = rand()%45 + 1;
                      
                   if(tab1[2] == tab2[j+1])         
                              tab1[2] = rand()%45 + 1;
                      
                   if(tab1[3] == tab2[j+1])                   
                              tab1[3] = rand()%45 + 1;
                      
                   if(tab1[4] == tab2[j+1])                   
                              tab1[4] = rand()%45 + 1;
                      
                   if(tab1[5] == tab2[j+1])                  
                              tab1[5] = rand()%45 + 1;
                     j++;
                }while( j< 5 );
                k++;
                
                 
         } while(tab1[0] == tab2[k] && tab1[1] == tab2[k] && tab1[2] == tab2[k] && tab1[3] == tab2[k] && tab1[4] == tab2[k] && tab1[5] == tab2[k]);
            
         // **********************//
         
            printf("%d\n ",tab1[i]);
            i++;
         }  
         else
            output_low(LED0);   
      }while(i<6);
      printf("\n");   
   }

**Jack** · 21/09/2011, 09h59

Code:

           tab2[j] =  tab1[i];

j n'est pas initialisé !

A+

**Jack** · 21/09/2011, 10h06

Code:

         } while(tab1[0] == tab2[k] && tab1[1] == tab2[k] && tab1[2] == tab2[k] && tab1[3] == tab2[k] && tab1[4] == tab2[k] && tab1[5] == tab2[k];)

Vu que l'opérateur == est plus prioritaire que &&, je mettrais des parenthèses:

Code:

         } while((tab1[0] == tab2[k]) && (tab1[1] == tab2[k]) && etc.

A+

Edit: ça doit marcher sans parenthèses, vu la priorité justement. Mais je préfère mettre des parenthèses supplémentaires afin de ne pas avoir à me poser de question.

invite765732342432 · 21/09/2011, 10h11

Envoyé par Jack

Edit: ça doit marcher sans parenthèses, vu la priorité justement. Mais je préfère mettre des parenthèses supplémentaires afin de ne pas avoir à me poser de question.

Juste un avis en passant: mettre des parenthèses quand la priorité est "évidente" (comme les ==) empêche de voir clairement les parenthèses utiles.
Quitte à séparer en blocs, je préfère dans ce cas passer à la ligne à chaque &&.
Mais bon, c'est juste une vision personnelle.

invitee1464df2 · 21/09/2011, 10h16

Je comprend pas pourquoi cela ne fonctionne pas !
J'ai beaucoup de peine en prog

Code:

//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Include Files                           //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#include "math.h"
#include "stdio.h"
#include "stdlib.h"
#include "kit_v4_header.h"
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                            Definitions                            //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Variable Globale                        //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
int i,j,k, tab1[6],tab2[6];
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}

/*** FONCTION RAND TEST ***/
void RAND_TEST()
{
   tab1[i] = rand()% 45 + 1;
   tab2[j] =  tab1[i];
   // *******TEST DES NOMBRES***************//
         k=0;
         do
         {
                j=0;
                do
                {
                   if(tab2[j+1] == tab1[0])
                              tab1[0] = rand()%45 + 1;
                      
                   if(tab2[j+1] == tab1[1])                  
                              tab1[1] = rand()%45 + 1;
                      
                   if(tab2[j+1] == tab1[2])         
                              tab1[2] = rand()%45 + 1;
                      
                   if(tab2[j+1] == tab1[3])                   
                              tab1[3] = rand()%45 + 1;
                      
                   if(tab2[j+1] == tab1[4])                   
                              tab1[4] = rand()%45 + 1;
                      
                   if(tab2[j+1] == tab1[5])                  
                              tab1[5] = rand()%45 + 1;
                     j++;
                }while(j< 5);
                k++;
                
                 
         } while((tab1[0] == tab2[k]) && (tab1[1] == tab2[k]) && (tab1[2] == tab2[k]) && (tab1[3] == tab2[k]) && (tab1[4] == tab2[k]) && (tab1[5] == tab2[k]));
     
         


}

void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)
   {
      i=0;
      j=0;
      do
      {
         if(input(SW0) == 0)
         {
           do
           {
               output_high(LED0);
           }
           while(!input(SW0));  
           
           RAND_TEST();   
           printf("%d\n ",tab1[i]);
           i++;
         }  
         else
            output_low(LED0);   
      }while(i<6);
      printf("\n");   
     
   }
}

invite765732342432 · 21/09/2011, 10h30

RanaINTER, ta fonction me semble beaucoup plus complexe que nécessaire.
Je pense que la réécrire entièrement serait plus simple, surtout si tu commences par la base:
Décris nous, en français, comment tu t'y prendrais pour tirer ces 6 nombres et faire en sorte que tu n'as pas 2 fois le même.

Une fois correct en français, ça sera beaucoup plus simple à coder.

[EDIT]Le début:
- je tire un nombre au hasard, il est forcément bon, je le mets dans la première case du tableau
- je tire un deuxième nombre au hasard...

invitee1464df2 · 21/09/2011, 10h40

-Je presse sur le switch.
-cela tire un nombre au hasard
-puis je l'affiche

-Je presse sur le switch.
-cela tire un 2e nombre
-je test si il est deja sortie
-S'il n'est pas déjà sortie je l'affiche
-S'il est déjà sortie je retire un nouveau nombre
-je le retest tant qu'il n'est pas de même nombre identique
-après je l'affiche

-Je presse sur le switch.
-cela tire un 3e nombre
-je test si il est deja sortie
-S'il n'est pas déjà sortie je l'affiche
-S'il est déjà sortie je retire un nouveau nombre
-je le retest tant qu'il n'est pas de même nombre identique
-après je l'affiche

-Je presse sur le switch.
-cela tire un 4e nombre
-je test si il est deja sortie
-S'il n'est pas déjà sortie je l'affiche
-S'il est déjà sortie je retire un nouveau nombre
-je le retest tant qu'il n'est pas de même nombre identique
-après je l'affiche

-Je presse sur le switch.
-cela tire un 5e nombre
-je test si il est deja sortie
-S'il n'est pas déjà sortie je l'affiche
-S'il est déjà sortie je retire un nouveau nombre
-je le retest tant qu'il n'est pas de même nombre identique
-après je l'affiche

-Je presse sur le switch.
-cela tire un 6e nombre
-je test si il est deja sortie
-S'il n'est pas déjà sortie je l'affiche
-S'il est déjà sortie je retire un nouveau nombre
-je le retest tant qu'il n'est pas de même nombre identique
-après je l'affiche

quand le tirage a rejoint 6 nombres le tirage est terminé.

invite765732342432 · 21/09/2011, 10h47

Ca a l'air presque bon, reste à détailler un peu cette partie:

Envoyé par RanaINTER

-je test si il est deja sortie
-S'il n'est pas déjà sortie je l'affiche
-S'il est déjà sortie je retire un nouveau nombre
-je le retest tant qu'il n'est pas de même nombre identique

Quelques remarques:
- afficher, tu le feras quoiqu'il arrive à la fin, il n'est pas forcément nécessaire de chercher à cette étape s'il faut l'afficher ou non.
- peux-tu détailler, en français toujours, le "je le reteste" ?
- tu vois apparaître ici une fonction "tester s'il est déjà sorti", ce serait une bonne idée, dans le code, d'en faire une fonction séparée renvoyant vrai ou faux, non ?

Est-ce que ça t'aide un peu à y voir clair ?

**DAUDET78** · 21/09/2011, 10h49

Et je n'utiliserai pas la fonction Rand() qui est un générateur pseudo-aléatoire.

Moi, je ferai tourner un timer entre 0 et 44 qui pédale à la fréquence maximum (disons 1 Mhz). Lors de l'appui sur le bouton, je viens lire sa valeur à la volée. Ca, c'est de l'aléatoire ! Car ça dépend du nombre de microsecondes "modulo 44" entre deux appuis

inviteaca451ba · 21/09/2011, 10h59

Ca, c'est de l'aléatoire !

Effectivement, mais il aura tout loisir d'améliorer sa fonction rand() une fois qu'il aura la logique du programme correcte!

invitee1464df2 · 22/09/2011, 07h26

Voici ce que j'ai fais !
Il y a encore des petites erreurs

Code:

int i,j,k, tab1[6],tab2[6];
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}

/*** FONCTION RAND TEST ***/
void RAND_TEST()
{ 
   // *******TEST DES NOMBRES***************//
   
                  if(tab2[1] == tab1[0])
                     tab1[i] = rand()% 45 + 1;
                    
                  if(tab2[2] == tab1[0] ||tab2[2] == tab1[1] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab2[3] == tab1[0] ||tab2[3] == tab1[1] || tab2[3] == tab1[2] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab2[4] == tab1[0] ||tab2[4] == tab1[1] || tab2[4] == tab1[2] || tab2[4] == tab1[3] )
                     tab1[i] = rand()% 45 + 1;
                   
                  if(tab2[5] == tab1[0] ||tab2[5] == tab1[1] || tab2[5] == tab1[2] || tab2[5] == tab1[3] || tab2[5] == tab1[4] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab2[6] == tab1[0] ||tab2[6] == tab1[1] || tab2[6] == tab1[2] || tab2[6] == tab1[3] || tab2[6] == tab1[4] || tab2[6] == tab1[5] )
                     tab1[i] = rand()% 45 + 1;
}

void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)
   {
      i=0;
      j=0;
      do
      {
         if(input(SW0) == 0)
         {
           do
           {
               output_high(LED0);
           }
           while(!input(SW0));  
          
          tab1[i] = rand()% 45 + 1;
         
     
          // RAND_TEST();
           printf("%d\n ",tab1[i]);
           i++;
         }  
         else
            output_low(LED0);   
      }while(i<6);
      printf("\n");   
     
   }
}

invitee1464df2 · 22/09/2011, 07h30

Je pense que j'ai réussis

Maintenant je teste un peu pour vérifier si c'est vraiment juste

Code:

///////////////////////////////////////////////////////////////////////
//                           Include Files                           //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#include "math.h"
#include "stdio.h"
#include "stdlib.h"
#include "kit_v4_header.h"
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                            Definitions                            //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Variable Globale                        //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
int i,tab1[6];
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}

/*** FONCTION RAND TEST ***/
void RAND_TEST()
{ 
   // *******TEST DES NOMBRES***************//
   
                  if(tab1[1] == tab1[0])
                     tab1[i] = rand()% 45 + 1;
                    
                  if(tab1[2] == tab1[0] ||tab1[2] == tab1[1] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab1[3] == tab1[0] ||tab1[3] == tab1[1] || tab1[3] == tab1[2] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab1[4] == tab1[0] ||tab1[4] == tab1[1] || tab1[4] == tab1[2] || tab1[4] == tab1[3] )
                     tab1[i] = rand()% 45 + 1;
                   
                  if(tab1[5] == tab1[0] ||tab1[5] == tab1[1] || tab1[5] == tab1[2] || tab1[5] == tab1[3] || tab1[5] == tab1[4] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab1[6] == tab1[0] ||tab1[6] == tab1[1] || tab1[6] == tab1[2] || tab1[6] == tab1[3] || tab1[6] == tab1[4] || tab1[6] == tab1[5])
                     tab1[i] = rand()% 45 + 1;
}

void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)
   {
      i=0;
      do
      {
         if(input(SW0) == 0)
         {
           do
           {
               output_high(LED0);
           }
           while(!input(SW0));  
          
          tab1[i] = rand()% 45 + 1;
         
     
          RAND_TEST();
           printf("%d\n ",tab1[i]);
           i++;
         }  
         else
            output_low(LED0);   
      }while(i<6);
      printf("\n");   
     
   }
}

invitee1464df2 · 22/09/2011, 07h35

Maintenant je penses que j'ai presque terminé !
Mais j'ai tester plusieurs tirages !!
Après plusieurs tirages, il est 2 même nombres sont sorties !!

20 4 42 20 43 31

Code:

///////////////////////////////////////////////////////////////////////
//                           Include Files                           //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#include "math.h"
#include "stdio.h"
#include "stdlib.h"
#include "kit_v4_header.h"
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                            Definitions                            //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Variable Globale                        //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
int i,tab1[6];
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}

/*** FONCTION RAND TEST ***/
void RAND_TEST()
{ 
   // *******TEST DES NOMBRES***************//
   
                  if(tab1[1] == tab1[0])
                     tab1[i] = rand()% 45 + 1;
                    
                  if(tab1[2] == tab1[0] ||tab1[2] == tab1[1] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab1[3] == tab1[0] ||tab1[3] == tab1[1] || tab1[3] == tab1[2] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab1[4] == tab1[0] ||tab1[4] == tab1[1] || tab1[4] == tab1[2] || tab1[4] == tab1[3] )
                     tab1[i] = rand()% 45 + 1;
                   
                  if(tab1[5] == tab1[0] ||tab1[5] == tab1[1] || tab1[5] == tab1[2] || tab1[5] == tab1[3] || tab1[5] == tab1[4] )
                     tab1[i] = rand()% 45 + 1;
                     
                  if(tab1[6] == tab1[0] ||tab1[6] == tab1[1] || tab1[6] == tab1[2] || tab1[6] == tab1[3] || tab1[6] == tab1[4] || tab1[6] == tab1[5])
                     tab1[i] = rand()% 45 + 1;
}

void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)
   {
      i=0;
      do
      {
         if(input(SW0) == 0)
         {
           do
           {
               output_high(LED0);
           }
           while(!input(SW0));  
          
          tab1[i] = rand()% 45 + 1;
         
     
          RAND_TEST();
           printf("%d\n ",tab1[i]);
           i++;
         }  
         else
            output_low(LED0);   
      }while(i<6);
      printf("\n");   
     
   }
}

invitee1464df2 · 22/09/2011, 07h51

Environ sur 20-30 tirage, il y a un tirage qui apparait 2X même nombre!

invite765732342432 · 22/09/2011, 08h20

Envoyé par RanaINTER

Environ sur 20-30 tirage, il y a un tirage qui apparait 2X même nombre!

Normal, dans ton explication en français, tu dis "je le retest tant qu'il n'est pas de même nombre identique".
Mais dans ton code, il n'y a pas de "tant que" lors du test. Tu fais seulement une série de if.

La fonction rand_test n'est pas bonne, il faut la retravailler.
Cette fonction ne devrait servir qu'à une chose: savoir si le nouveau nombre tiré est déjà présent dans ton tableau (inutile de retester les autres: s'ils étaient bons lors du tirage, il le sont toujours)

Bon courage

invitee1464df2 · 22/09/2011, 08h23

Pour l'instanzt 0 ERREUR

Code:

NOUVEAUX TIRAGES							
1	tirage:	8	17	19	1	40	32
2	tirage:	5	15	29	17	1	6
3	tirage:	28	34	5	23	14	36
4	tirage:	34	24	10	3	1	28
5	tirage:	12	29	21	44	11	41
6	tirage:	43	34	7	39	4	35
7	tirage:	39	31	29	2	30	12
8	tirage:	5	1	9	42	18	27
9	tirage:	20	17	15	7	11	18
10	tirage:	32	5	19	7	10	24
11	tirage:	5	27	25	4	32	41
12	tirage:	8	3	39	1	41	38
13	tirage:	30	38	41	17	34	8
14	tirage:	26	2	28	21	30	34
15	tirage:	31	14	38	22	42	1
16	tirage:	24	4	8	41	44	9
17	tirage:	25	23	28	4	44	7
18	tirage:	35	6	34	45	11	40
19	tirage:	18	45	17	38	6	31
20	tirage:	41	43	34	27	2	21
21	tirage:	9	14	34	44	35	28
22	tirage:	9	1	13	17	41	14
23	tirage:	43	21	25	15	44	5
24	tirage:	44	39	34	36	15	41
25	tirage:	7	8	40	14	27	16
26	tirage:	5	38	21	12	32	10
27	tirage:	24	18	5	10	8	22
28	tirage:	15	40	9	23	10	13
29	tirage:	38	4	25	34	7	12
30	tirage:	13	18	39	42	29	25
31	tirage:	18	8	31	33	1	41
32	tirage:	9	7	45	34	18	12
33	tirage:	22	43	2	31	29	8
34	tirage:	37	39	16	2	19	33
35	tirage:	1	37	40	2	19	24
36	tirage:	33	12	32	14	23	39
37	tirage:	9	6	4	37	12	43
38	tirage:	45	9	24	44	31	20

invitefaaca50b · 22/09/2011, 08h35

on peut aussi declarer les numeros sous forme de tableau, on lance 1000 tirages de numero rand, on classe les numeros dans le tableau en incrementant chaque case du tableau quand un nombre correspond a la case, et ensuite on tire les 6 numeros ayant le plus gros increment. Ensuite, on efface le contenu du tableau, comme ca plus de soucis de doublon.
Il faut s'assurer que le rand est vraiment aleatoire... sinon on aura une propension a tomber sur les meme numeros regulierement.
On peut aussi utiliser sur une entree analog du µC un generateur de bruit blanc et faire des acquisitions regulieres en ne prenant que les bits de poids faible.

inviteaca451ba · 22/09/2011, 08h48

C'est assez alambiqué comme façon de faire.
Ton algo n'est pas bon, car si tu regardes bien, tu t'aperçois que tabl[0] ne peux pas être un nombre présent dans le précédent tirage. Ton tirage est donc biaisé. Tu peux corrigé facilement l'algo tel qu'il est.

Sinon la solution plus propre consiste, lorsque tu tires par exemple le 4éme numéro, de vérifier qu'il n'est pas égal à l'un des trois premiers ...

invitee1464df2 · 22/09/2011, 08h49

Est-ce mieux?

Code:

void RAND_TEST()
{  // *******TEST DES NOMBRES***************// 
   while(tab1[1] == tab1[0])
      tab1[1] = rand()% 45 + 1;
                    
   while(tab1[2] == tab1[0] ||tab1[2] == tab1[1])
      tab1[2] = rand()% 45 + 1;
                     
   while(tab1[3] == tab1[0] ||tab1[3] == tab1[1] || tab1[3] == tab1[2])
      tab1[3] = rand()% 45 + 1;
                     
   while(tab1[4] == tab1[0] ||tab1[4] == tab1[1] || tab1[4] == tab1[2] || tab1[4] == tab1[3])
      tab1[4] = rand()% 45 + 1;
                   
   while(tab1[5] == tab1[0] ||tab1[5] == tab1[1] || tab1[5] == tab1[2] || tab1[5] == tab1[3] || tab1[5] == tab1[4])
      tab1[5] = rand()% 45 + 1;
                     
   while(tab1[6] == tab1[0] ||tab1[6] == tab1[1] || tab1[6] == tab1[2] || tab1[6] == tab1[3] || tab1[6] == tab1[4] || tab1[6] == tab1[5])
      tab1[6] = rand()% 45 + 1;
}

inviteaca451ba · 22/09/2011, 09h00

mmhh
Est-ce que tu vois que quand tu rentres dans RAND_TEST avec i==0, les tabl[1] à tabl[6] sont ceux du tirage précédent?

invite765732342432 · 22/09/2011, 09h06

Envoyé par RanaINTER

Est-ce mieux?

Euh... ça peut marcher comme ça...
Mais c'est très, très, très laid

inviteaca451ba · 22/09/2011, 09h09

ça marche "à l'oeil' mais c'est pas un tirage aléatoire!

invitee1464df2 · 22/09/2011, 09h15

A la fin du programme j initialise le tableau à 0 .

Code:

//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}
/*** FONCTION RAND TEST ***/
void RAND_TEST()
{ 
   tab1[i] = rand()% 45 + 1;
   // *******TEST DES NOMBRES***************//
   while(tab1[1] == tab1[0])
      tab1[1] = rand()% 45 + 1;
                    
   while(tab1[2] == tab1[0] ||tab1[2] == tab1[1])
      tab1[2] = rand()% 45 + 1;
                     
   while(tab1[3] == tab1[0] ||tab1[3] == tab1[1] || tab1[3] == tab1[2])
      tab1[3] = rand()% 45 + 1;
                     
   while(tab1[4] == tab1[0] ||tab1[4] == tab1[1] || tab1[4] == tab1[2] || tab1[4] == tab1[3])
      tab1[4] = rand()% 45 + 1;
                   
   while(tab1[5] == tab1[0] ||tab1[5] == tab1[1] || tab1[5] == tab1[2] || tab1[5] == tab1[3] || tab1[5] == tab1[4])
      tab1[5] = rand()% 45 + 1;
                     
   while(tab1[6] == tab1[0] ||tab1[6] == tab1[1] || tab1[6] == tab1[2] || tab1[6] == tab1[3] || tab1[6] == tab1[4] || tab1[6] == tab1[5])
      tab1[6] = rand()% 45 + 1;
}
void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)
   {
      i=0;
      do
      {
         if(input(SW0) == 0)
         {
              do
              {
                  output_high(LED0);
              }
              while(!input(SW0)); 
       
              RAND_TEST();
              printf("%d ",tab1[i]);
              i++;
         }  
         else
              output_low(LED0);   
      }while(i<6);
      printf("\n");  
      
      for(i=0;i<6;i++)
          tab1[i] = 0;
   }
}

invitee1464df2 · 22/09/2011, 09h19

Dans la fonction j ai enlevé
while(tab1[6] == tab1[0] ||tab1[6] == tab1[1] || tab1[6] == tab1[2] || tab1[6] == tab1[3] || tab1[6] == tab1[4] || tab1[6] == tab1[5])
tab1[6] = rand()% 45 + 1;

cela va de TAB1[0] à TAB1[5] = 6 nombres

invitee1464df2 · 22/09/2011, 09h45

Je pense d'avoir terminé mon programme!
Certe que ce n'est pas un super programme, mais pour un début ça peut aller!

Merci pour tout

Code:

int i,tab1[6];
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                             Fonctions                             //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void) 
{

}
/*** FONCTION RAND TEST ***/
void RAND_TEST()
{ 
   tab1[i] = rand()% 45 + 1;//CHIFFRE ALEATOIRE ENTRE 1-45 DANS TAB1 EN FONCTION DE i
   
   // *******TEST DES NOMBRES***************//
   //TANT QUE TAB1[1] EST EGAL TAB1[0]
   while(tab1[1] == tab1[0])
      tab1[1] = rand()% 45 + 1;//CHIFFRE ALEATOIRE ENTRE 1-45 DANS TAB1[1]
                    
   //TANT QUE TAB1[2] EST EGAL TAB1[0] OU TAB1[1]               
   while(tab1[2] == tab1[0] ||tab1[2] == tab1[1])
      tab1[2] = rand()% 45 + 1;//CHIFFRE ALEATOIRE ENTRE 1-45 DANS TAB1[2]
   
   //TANT QUE TAB1[3] EST EGAL TAB1[0] OU TAB1[1] OU TAB1[2]
   while(tab1[3] == tab1[0] ||tab1[3] == tab1[1] || tab1[3] == tab1[2])
      tab1[3] = rand()% 45 + 1;//CHIFFRE ALEATOIRE ENTRE 1-45 DANS TAB1[3]
   
   //TANT QUE TAB1[4] EST EGAL TAB1[0] OU TAB1[1] OU TAB1[2] OU TAB1[3]
   while(tab1[4] == tab1[0] ||tab1[4] == tab1[1] || tab1[4] == tab1[2] || tab1[4] == tab1[3])
      tab1[4] = rand()% 45 + 1;//CHIFFRE ALEATOIRE ENTRE 1-45 DANS TAB1[4]
   
   //TANT QUE TAB1[5] EST EGAL TAB1[0] OU TAB1[1] OU TAB1[2] OU TAB1[3] OU TAB1[4]
   while(tab1[5] == tab1[0] ||tab1[5] == tab1[1] || tab1[5] == tab1[2] || tab1[5] == tab1[3] || tab1[5] == tab1[4])
      tab1[5] = rand()% 45 + 1;//CHIFFRE ALEATOIRE ENTRE 1-45 DANS TAB1[5]

}
void main()
{
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Initialisation                          //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   port_b_pullups(TRUE);
   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
//---------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////
//                           Programme principal                     //
///////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------
   while(TRUE)//TANT QUE VRAI
   {
      i=0;//INITALISE i A 0
      do
      {
         if(input(SW0) == 0)//TANT QUE LE SWITCH EST ACTIF
         {
              do
              {
                  output_high(LED0);//ALLUME LA LED 1
              }
              while(!input(SW0)); // TANT QUE LE SWITCH EST ACTIF
       
              RAND_TEST();//APPEL A LA FONCTION RAND TEST
              printf("%d ",tab1[i]);//AFFICHE tab1 EN FONCTION DE i
              i++;
         }  
         else
              output_low(LED0);//ETEINT LA LED 1   
      }while(i<6);//TANT QUE i EST PLUS PETIT QUE 6
      printf("\n\r\n");  // à la ligne, retour au début de la ligne, à la ligne
      
      for(i=0;i<6;i++)//i ALLANT 0 A 6, INCREMENTE PAR 1
          tab1[i] = 0; //INITIALISE LE TAB1 EN FONCTION DE i A 0
   }
}

inviteaca451ba · 22/09/2011, 09h48

oui là ça me semble correct

pas forcément très élégant, mais c'est un bon début! L'essentiel étant que tu ais trouvé TA solution.

Fonction rand

Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Re : Fonction rand

Discussions similaires

Eviter les doublons avec la fonction rand()

Fonction rand

calculs rand()

rand dans langage c

Matlab...Help... rand