fonction nbDatesAGenerer():entier
{
        variable nbd : entier
        
        Repeter
        {
                Afficher("Entrez le nombre de dates à générer")
                Saisir(nbd)
                Si (nbd > 100/3) alors
                {
                        Afficher("Attention, le vecteur ne peut pas contenir plus de 33 dates.\n")
                }
                
        } jusqu'à (nbd <= 100/3)

        retourner nbd
}

procedure Affichage_andreas(E U: vecteur de 100 entier, E nb : entier)
{
        variable i : entier
        
        Pour i de 0 à nb-1
        {
        
                Si (i mod 3 = 2) alors
                {
                        Afficher(U[i],"\n")
                }
                sinon
                {
                        Afficher(U[i],"/")
                }
        }
}

procedure Affichage(E U: vecteur de 100 entier, E nb : entier)
{
        variable i : entier
        
        Pour i de 0 à nb-1 par pas de 3
        {
                Afficher(U[i],"/",U[i+1],"/",U[i+2],"\n")
        }
}

fonction Recherche(E U: vecteur de 100 entier, E nb : entier, E J, M, A : entier):entier
{
        variable i : entier
        
        Pour i de 0 à nb-1 par pas de 3
        {
                Si ((U[i]=J) ET (U[i+1]=M) ET (U[i+2]=A)) alors
                        retourner (i div 3)+1
        }
        retourner -1
}

procedure Generation(E U: vecteur de 100 entier, E N : entier)
{
        variable i,j,m,a : entier
        
        Pour i de 0 à N-1
        {
                Repeter
                {
                        j <-- hasard(31)+1
                        m <-- hasard(12)+1
                        a <-- hasard(2031)
                jusqu'à (Recherche(U,i*3,j,m,a)=-1)
        
                U[3*i]<--j
                U[3*i+1]<--m
                U[3*i+2]<--a
        }
}

procedure Generation_80(E U: vecteur de 100 entier, E N : entier)
{
        variable i,pos : entier
        
        pos <-- 0
        Pour i de 1 à N
        {       
                Repeter
                {
                        j <-- hasard(31)+1
                        m <-- hasard(12)+1
                        a <-- hasard(2031)
                jusqu'à (Recherche(U,i*3,j,m,a)=-1)
        
                U[pos]<--j
                pos <- pos + 1
                U[pos]<--m
                pos <- pos + 1
                U[pos]<--a
                pos <- pos + 1
        }
}

procedure Generation_90(E U: vecteur de 100 entier, E N : entier)
{
        variable i,pos : entier
        
        pos <-- 0
        i <-- 1
        Tant que (i <=N)
        {
                Repeter
                {
                        j <-- hasard(31)+1
                        m <-- hasard(12)+1
                        a <-- hasard(2031)
                jusqu'à (Recherche(U,i*3,j,m,a)=-1)
        
                U[pos]<--j
                pos <- pos + 1
                U[pos]<--m
                pos <- pos + 1
                U[pos]<--a
                pos <- pos + 1
                i <-- i + 1
        }
}


Algorithme Dates
{
        constante entier MAX <-- 100
        variable U : vecteur de MAX entier
                NBD,NBE : entier
                JR,MR,AR : entier
                Position : entier
                
                
        NBD <-- nbDatesAGenerer()
        Generation_90(U, NBD, NBE)
        Affichage(U, NBE)
        Afficher("Saisir la date à rechercher sous la forme JJ/MM/AAAA")
        Saisir(JR,MR,AR)
        
        Position <-- Recherche(U, NBE, JR, MR, AR)
        Si (Position = -1) alors
        {
                Afficher("La date ",JR,"/",MR,"/",AR," n'est pas présente dans le vecteur.\n")
        }
        sinon
        {
                Afficher("La date ",JR,"/",MR,"/",AR," est présente dans le vecteur à la position ",Position,".\n")
        }
}