Paquet rammasser_cette_ligne(Paquet paq,int carte,int ligne,Paquet *client,int num_client)
{
int j;
for(j=0;j<5;j++)
{
client[num_client].moi.deck[client[num_client].moi.n_deck][j]=0;
}
//on sauvegarde les cartes pour les comptabiliser pour le joueur
for(j=0;j<5;j++)
{
client[num_client].moi.deck[client[num_client].moi.n_deck][j]=paq.grille[ligne][j];
}
//On ajoute calcule les têtes récupérées
for(j=0;j<5;j++)
{
client[num_client].moi.tete_partie=client[num_client].moi.tete_partie + tete(client[num_client].moi.deck[client[num_client].moi.n_deck][j]);
}
client[num_client].moi.n_deck++;
//on initialise la ligne (= 'on en enlève les cartes')
for(j=0;j<5;j++)
{
paq.grille[ligne][j]=0;
}
paq.grille[ligne][0]=carte;
return paq;
}
//fonction qui rammasse la ligne contenant le plus petit nb de taureau
int rammasser_plus_petit(Paquet paq)
{
int nb_tete[4]={0},i,j;
//On récupère le nombre de tete de chaque ligne
for(i=0;i<4;i++)
{
for(j=0;j<5;j++)
{
nb_tete[i]=nb_tete[i]+tete(paq.grille[i][j]);
}
}
return minimum(nb_tete,4);
}
file * trier_monotonie (file * fileSource)
{
unsigned i = 0,
nbMono = 1, /* on aura toujours au moins une monotonie */
nbMonotonies = 1; /* */
int comp;
int *nbelem1,
*nbelem2;
file *f1 = (file *) malloc( sizeof( file* ) ),
*f2 = (file *) malloc( sizeof( file* ) );
file_creer(f1, &string_copier, &string_liberer);
file_creer(f2, &string_copier, &string_liberer);
/* compte le nb de monotonies */
while ( i < file_taille( fileSource )-1 )
{
comp = string_file_comparer_elements( fileSource, fileSource, (unsigned)i, (unsigned)i+1, &strcmp );
if ( comp > 0 )
{
nbMono++;
}
i++;
}
if (nbMono == 1)
{
return fileSource;
}
if ( nbMono % 2 )
{
nbelem1 = malloc( (( nbMono / 2 ) + 1) * sizeof( int ) );
nbelem2 = malloc( (( nbMono / 2 ) + 1) * sizeof( int ) );
}
else
{
nbelem1 = malloc( ( nbMono / 2 ) * sizeof( int ) );
nbelem2 = malloc( ( nbMono / 2 ) * sizeof( int ) );
}
do /* Processus de tri */
{
i = 0;
while( i < nbMono - 1 )
{
nbelem1[i] = 0;
nbelem2[i] = 0;
i++;
}
nbMono = 1;
nbMonotonies = 1;
do /* Séparation en deux files */
{
comp = string_file_comparer_elements( fileSource, fileSource, (unsigned)0, (unsigned)1, &strcmp );
if ( nbMono % 2 )
{
enfiler( f2, tete( fileSource ) );
nbelem2[nbMonotonies-1]++;
defiler( fileSource );
}
else
{
enfiler( f1, tete( fileSource ) );
nbelem1[nbMonotonies-1]++;
defiler( fileSource );
}
if ( comp > 0 )
{
nbMono++;
if ( nbMono % 2 )
nbMonotonies++;
}
} while ( file_taille( fileSource ) > 1 );
if ( nbMono % 2 )
{
enfiler( f2, tete( fileSource ) );
nbelem2[nbMonotonies-1]++;
defiler( fileSource );
}
else
{
enfiler( f1, tete( fileSource ) );
nbelem1[nbMonotonies-1]++;
defiler( fileSource );
}
nbMono = 0;
if (nbMonotonies != 1)
{
while( !file_vide( f1 ) || !file_vide( f2 ) ) /* tant qu'il existe des elements dans une des deux files... */
{
if( ! nbelem1[nbMono] && ! nbelem2[nbMono] ) /* Si les deux files sont vides */
{
nbMono++; /* passe a la monotonie suivante */
}
else /* sinon */
{
if ( !nbelem1[nbMono] ) /* si la monotonie actuelle dans f1 est vide et l'autre dans f2 contient des elements */
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMono]--;
}
else if ( !nbelem2[nbMono] ) /* sinon si la monotonie actuelle dans f2 est vide et l'autre dans f1 contient des elements */
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMono]--;
}
else /* sinon les deux monotonies contiennent des elements : on peut donc les comparer */
{
comp = string_file_comparer_elements( f1, f2, (unsigned)0, (unsigned)0, &strcmp ) ;
if ( comp <= 0 )
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMono]--;
}
else
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMono]--;
}
}
}
}
}
else /* On a fini : */
{
while( !file_vide( f1 ) || !file_vide( f2 ) ) /* Tant que f1 et f2 ne sont pas vide */
{
/* on insere la plus petite valeur */
if ( !nbelem1[nbMonotonies-1] ) /* si la monotonie actuelle dans f1 est vide et l'autre dans f2 contient des elements */
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMonotonies-1]--;
}
else if ( !nbelem2[nbMonotonies-1] ) /* sinon si la monotonie actuelle dans f2 est vide et l'autre dans f1 contient des elements */
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMonotonies-1]--;
}
else
{
comp = string_file_comparer_elements( f1, f2, (unsigned)0, (unsigned)0, &strcmp ) ;
if ( comp <= 0 )
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMonotonies-1]--;
}
else
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMonotonies-1]--;
}
}
}
}
/* compte le nb de monotonies */
i = 0;
nbMono = 1;
while ( i < file_taille( fileSource ) - 1 )
{
comp = string_file_comparer_elements( fileSource, fileSource, (unsigned)i, (unsigned)i+1, &strcmp );
if ( comp > 0 )
{
nbMono++;
}
i++;
}
} while (nbMono != 1);
free(nbelem1);
free(nbelem2);
return fileSource;
}
int createArchive(char** files, int nb_fichiers) {
if (strcmp(nom_archive, "") == 0 || nom_archive == NULL)
nom_archive = files[0];
int archive = open(nom_archive, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
if (archive == -1) // si on a pas pu ouvrir le fichier
{
printf("L'archive n'a pas pu être ouverte\n");
return EXIT_FAILURE;
}
printf("Création de l'archive %s\n", nom_archive);
ListeDescripteurs descripteurs; // pour mémoriser les descripteurs de tous les fichiers / dossiers + archive (spécial)
int nb_descripteurs = 0;
descripteurs = construireListeVide();
nb_descripteurs = createFiles(files, nb_fichiers, &descripteurs, archive); // on traite tous nos fichiers en paramètre
tete(descripteurs);
uint** all_d = getTousLesDescripteursToInt(descripteurs);
int j;
uint premierDescripteur = (uint) lseek(archive, 0, SEEK_CUR);
int i;
if (affiche)
printf("Ecriture de la configuration de l'archive...... ");
for (i = 0; i < nb_descripteurs; i++) {
int nb_int = taille(all_d[i]);
int dernier_int = taille(all_d[0]);
all_d[0] = (uint*) realloc(all_d[0], nb_int * sizeof(int) * sizeof(all_d[0]));
for(j=0 ; j<nb_int ; j++){
all_d[0][j+dernier_int] = all_d[i][j];
}
int ecrit = write(archive, &all_d[i], nb_int);
if ((ecrit < 0) || (ecrit != nb_int))
printf("Erreur lors l'écriture de la configuration de l'archive !\n");
}
detruireListeInt(all_d, nb_descripteurs);
detruireListeDescripteurs(descripteurs);
write(archive, &premierDescripteur, sizeof(uint));
if (affiche)
printf("Done\n");
if (compresse)
compression(archive);
if (close(archive) == -1) {
printf("Attention, l'archive n'a pas pu être fermée... Possibilité de corruption du fichier !");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main() {
int i;
liste li = nouvListe(), li2 = nouvListe();
adjt(1, li);
adjt(5, li);
adjt(-7, li);
printf ("liste : "); affiche(li);
printf("taille : %d\n", taille(li));
printf("vide ? : %s\n", (estVide(li)?"oui":"non"));
for(i=1; i <= 10; ++i) {
adjq(i*i, li2);
}
printf ("liste : "); affiche(li2);
printf("tete : %d queue : %d\n", tete(li2), queue(li2));
printf("====== suppressions =========\n");
supt(li2);
printf ("apres supt : "); affiche(li2);
supq(li2);
printf ("apres supq : "); affiche(li2);
// creation de deux listes avec des elements choisis au hasard
printf("====== tris et renversement =========\n");
srand(time(NULL)); // initialisation de la suite aleatoire
printf("liste 11 : ");
liste l1 = nouvListe();
for(i=0; i < 15; ++i) {
adjt(rand()%30, l1);
}
affiche (l1);
printf("liste 12 : ");
liste l2 = nouvListe();
for(i=0; i < 10; ++i) {
adjt(rand()%30, l2);
}
affiche (l2);
liste l1t = trie(l1);
liste l2t = trie(l2);
printf("liste 11 apres trie : "); affiche(l1t);
printf("liste 12 apres trie : "); affiche(l2t);
liste l3t = interclasse(l1t,l2t);
printf("interclassement : "); affiche(l3t);
printf("renversement iter : "); affiche(renverse_iter(l3t));
printf("renversement recur : "); affiche(renverse_recur(l3t));
printf("====== palindrome =========\n");
liste lpalin = nouvListe();
adjt(1, lpalin);
adjt(2, lpalin); adjq(2, lpalin);
adjt(8, lpalin); adjq(8, lpalin);
printf("liste : "); affiche(lpalin);
printf("Palindrome (iter) ? %s\n", (palindrome_iter(lpalin)?"oui":"non"));
printf("Palindrome (recur) ? %s\n", (palindrome_recur(lpalin)?"oui":"non"));
supt(lpalin);
printf("liste : "); affiche(lpalin);
printf("Palindrome (iter) ? %s\n", (palindrome_iter(lpalin)?"oui":"non"));
printf("Palindrome (recur) ? %s\n", (palindrome_recur(lpalin)?"oui":"non"));
return 0;
}
