Suite logique (portable)

Commenter

Contenu du snippet

le principe de la suite :
1
11
21
1211
111221
312211
...

la croissance du nombre generer etant exponentiel on se retrouve tres vite avec des nombre enorme, donc se programme suporte les grand nombres.
il utilise enormement de memoire malgrer un fonctionnement en base 4

Source / Exemple : 


#include    <stdio.h>
#include	<stdlib.h>
#include    <time.h>

typedef struct _bit2
{
    char    B1:1;
    char    B2:1;
} bit2;

int   Atol(const char *nbr)
{
    unsigned int    total = 0;
    while (*nbr)
        total = 10 * total + (*nbr++ - '0');
    return total;
}

char   GetBase4(bit2 Base4)
{
    char    Nbr = 0;
    if(Base4.B1)
        Nbr += 1;
    if(Base4.B2)
        Nbr += 2;
    return Nbr;
}

bit2  SetBase4(char Nbr)
{
    bit2    Base4;
    Base4.B1 = 0;
    Base4.B2 = 0;
    if((Nbr == 1) || (Nbr == 3))
        Base4.B1 = 1;
    if((Nbr == 2) || (Nbr == 3))
        Base4.B2 = 1;
    return Base4;
}

int main(int argc, char* argv[])
{
	FILE			*Fichier;
	unsigned int	Iteration, Taille, i = 1;
    bit2            *Buffer1, *Buffer2, *Cur1, *Cur2;
    char            Affiche = 0, Sauve = 0, Nbr, NbNbr;
	clock_t			Temp = clock();

	if(argc >= 2)
	{
        if(strchr(argv[1], '-'))
        {
            if(strchr(argv[1], 'a'))
                Affiche = 1;
            if(strchr(argv[1], 's'))
                Sauve = 1;
    		Iteration = Atol(argv[2]);
	       	Taille = Atol(argv[3]);
        }
        else
        {
    		Iteration = Atol(argv[1]);
	       	Taille = Atol(argv[2]);
        }
	}
	else
	{
		printf("\tCalcul d'une suite logique\n");
		printf("\tPar aerith\tVersion 1.0\n\n");
		printf("\tSyntax : %s -as <Iteration> <Buffer>\n", *argv);
		printf("\t  -a\t\t : Affiche le resulatat pendant le calcul\n");
		printf("\t  -s\t\t : Sauvegarde du resultat final dans suite.txt\n");
		printf("\t  <Iteration>\t : Nombre d'iteration dans la suite\n");
		printf("\t  <Buffer>\t : Taille du buffer stockant le nombre\n\n");
		return 0;
	}
	
	Buffer1 = calloc(Taille/4, 1);
	Buffer2 = calloc(Taille/4, 1);
	if((!Buffer1) || (!Buffer2))
        return 0;


    	
  • Buffer1 = SetBase4(1);


	do
	{
		Cur1 = Buffer1;
		Cur2 = Buffer2;
		Nbr = GetBase4(*Cur1);
		NbNbr = 1;
  		do
		{
            Cur1++;
            if(GetBase4(*Cur1) == Nbr)
                NbNbr++;
            else
            {


                    
  • Cur2++ = SetBase4(NbNbr);

    •                 
  • Cur2++ = SetBase4(Nbr);

                if(Affiche)
                    printf("%i%i", NbNbr, Nbr);
                Nbr = GetBase4(*Cur1);
                NbNbr = 1;
            }
		}
		while(GetBase4(*Cur1));

		Cur1 = Buffer1;
		Buffer1 = Buffer2;
		Buffer2 = Cur1;

		printf("\n%i \t : %i \t\t %i ms\n", i, strlen((char *)Buffer1)*4, clock() - Temp);
	}
	while(i++ < Iteration);

    if(Sauve)
    {
    	Fichier = fopen("suite.txt", "w");
        fprintf(Fichier, "Iteration : %i\nTaille : %i\n", i-1, strlen((char *)Buffer1)*4);
        Cur1 = Buffer1;
        do
        {
            fprintf(Fichier, "%i", GetBase4(*(Cur1++)));
        }
    	while(GetBase4(*Cur1));
        fprintf(Fichier, "\nExecuter en %i ms\n", clock() - Temp);
        fclose(Fichier);
    }
    
  	free(Buffer1);
  	free(Buffer2);

	return 1;
}

Conclusion :


il s'execute depuis une console, taper le nom du programme compiler et vous aurez l'aide.

j'ai pas reussi a calculer l'iteration 75, ce qui generer un nombre de 840 millions de chiffres (.txt de 840mo)

il utilise en memoire la moitier de se que vous entrer en buffer, soit 2Go pour un buffer de 4 000 000 000

A voir également

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 (cs_aerith)