int main(void){
int n,i,tmp;
unsigned long long a,b,min,max;
while(scanf("%d", &n), n){
init_pile();
for(i=0; i<n; ++i){
scanf("%d", &tmp);
insert_maxpile(tmp);
insert_minpile(tmp);
}
while(1){
a=delete_maxpile();
if(Mtop==0){
min=a;
break;
}else{
b=delete_maxpile();
insert_maxpile(a*b+1);
}
}
while(1){
a=delete_minpile();
if(mtop==0){
max=a;
break;
}else{
b=delete_minpile();
insert_minpile(a*b+1);
}
}
printf("%llu\n", max-min);
}
return 0;
}
void rapide(pos_t taille, unsigned int nb_threads) {
arg_t args;
pthread_t *tab;
bloc_t bloc;
int i, j;
bloc.debut = 0;
bloc.fin = taille - 1;
if (nb_threads == 1) {
rapide_seq(bloc);
return;
}
else{
assert(nb_threads > 1);
//creer une pile dans rapide
init_pile(&ma_pile);
//empile(&ma_pile, bloc);
//creation de n threads
tab = (pthread_t *) malloc(sizeof(pthread_t) * nb_threads);
for (i=0; i <= nb_threads;i++){
pthread_create(&tab[i],NULL,wrapper,&args);
}
//attente des n threads
for (j=0; j <= nb_threads;j++){
pthread_join(tab[j],NULL);
}
}
}
void test_pile()
{
int choix = 0;
int valeur;
int bool;
pile_t * lifo = NULL;
while(choix != -1)
{
printf("Fonctions de test de la pile\n");
printf("1) Initialisation de la pile\n");
printf("2) test si pile vide \n");
printf("3) test si pile pleine\n");
printf("4) empiler une valeur\n");
printf("5) depiler une valeur\n");
printf("6) valeur du sommet\n");
printf("autre: retour au menu\n");
scanf("%d",&choix);
switch(choix)
{
case 1:
printf("taille maximale souhaitee? \n");
scanf("%d",&valeur);
lifo = init_pile(valeur);
break;
case 2:
bool = vide_pile(lifo);
if(bool)
printf("pile vide\n");
else
printf("pile non vide\n");
break;
case 3:
bool = pleine_pile(lifo);
if(bool)
printf("pile pleine\n");
else
printf("pile non pleine\n");
break;
case 4:
printf("la valeur a empiler?\n");
scanf("%d",&valeur);
bool = empiler(lifo,valeur);
if(bool)
printf("empilation reussi\n");
else
/* Effectue un tri rapide séquentiel */
void rapide_seq(bloc_t bloc_init) {
pile p;
int i, nb_blocs;
bloc_t bloc;
bloc_t blocs[2];
init_pile(&p);
empile(&p, bloc_init);
/* Principe du tri rapide séquentiel :
* tant qu’il y a des blocs à trier, dépile un bloc, le découpe en
* (au maximum) deux sous-blocs non-encore triés et les empile */
do {
bloc = depile(&p);
nb_blocs = rapide_decoupebloc(bloc, blocs);
for (i = 0; i < nb_blocs; i++)
empile(&p, blocs[i]);
} while (!pile_vide(&p));
}
/*
Fonction principale
*/
int main(int argc, char **argv)
{
int mode, rep;
int nb_coups = 0, i, j, passe=0;
char joueur;
char gagnant = '-';
//TODO: changer la force de l'ordi en diminuant/augmentant la max depth j1 et/ou j2
int max_depth_j1 = 5;
int max_depth_j2 = 1;
srand(time(NULL));
init_pile();
printf("Bienvenue dans SPIOTHELLO, l'othello des L2 SPI de l'Université du Maine !\n");
/* mode de jeu */
do{
printf("Choisissez le mode de jeu:\n");
printf("\t1. J1 [Humain] vs. J2 [Humain]\n");
printf("\t2. J1 [Humain] vs. J2 [Ordinateur]\n");
printf("\t3. J1 [Ordinateur] vs. J2 [Ordinateur]\n");
printf("Choix : ");
scanf("%d",&mode);
if(mode!=1 && mode!=2 && mode!=3)
printf("Le mode %d n'existe pas, saisissez à nouveau.", mode);
} while(mode!=1 && mode!=2 && mode!=3);
/* demander qui commence */
do {
printf("Qui commence ? J1 [%c] -> 1 ou J2 [%c] -> 2\nChoix : ", J1, J2);
scanf("%d", &rep);
if(rep != 1 && rep != 2)
printf("Saisie incorrecte, recomencez");
} while(rep!=1 && rep!=2);
if(rep==1) joueur = J1;
else joueur = J2;
printf("Le joueur J%d [%c] commence ...\n", rep, joueur);
othello *jeu = creer_othello();
afficher_othello(jeu);
while(!partie_finie(nb_coups, passe)){
if(mode == 1 || (mode==2 && joueur==J1)){ // Si humain-humain ou humain-ordi et joueur courant == J1
//demander une case
if(humain_joue_un_coup(jeu, joueur)) {
nb_coups++;
passe = 0;
}
else {
printf("J%d [%c], vous ne pouvez pas jouer ... !\n", joueur==J1?1:2, joueur);
scanf(" ");
passe++;
}
} else { // si humain-ordi et joueur courant == J2 ou ordi-ordi
//déterminer la case à jouer
fprintf(stderr, "C'est à J%d [%c] de jouer !\n", joueur==J1?1:2, joueur);
min_max(jeu, joueur, joueur, nb_coups, &i, &j, 0, joueur==J1?max_depth_j1:max_depth_j2);
// on joue le meilleur coup s'il existe
if(i==-1 && j==-1){
printf("Aucun coup possible ... je passe mon tour\n");
passe++;
} else {
jouer_un_coup(jeu, joueur, i, j);
nb_coups++;
passe = 0;
}
}
afficher_othello(jeu);
joueur = adversaire(joueur); // on change de joueur
}
int sc1 = score(jeu, J1, 0, nb_coups);
int sc2 = score(jeu, J2, 0, nb_coups);
gagnant = sc1>sc2?J1:(sc1<sc2?J2:'-');
if(gagnant == J1)
printf("Le joueur J1 [%c] a gagné !!\n", gagnant);
else if(gagnant == J2)
printf("Le joueur J2 [%c] a gagné !!\n", gagnant);
else
printf("Les joueurs n'ont pas pu se départager ... !!\n");
return 0;
}
/*****Programme principal*****/
int main()
{
file f;
pile p;
p = malloc (sizeof(struct e_pile)); //Allocation de mémoire pour la pile
f = malloc (sizeof(struct e_file)); //Allocation de mémoire pour la file
init_pile(&p); //Initialisation de p
init_file(&f); //Initialisation de f
/*Manipulation des file*/
printf("\nManipulation des files :\n\n");
/**Insertion dans la file**/
enfile(&f,5); //Insertions de la valeur 5
affiche_file (f);
enfile(&f,4); //Insertions de la valeur 4
affiche_file (f);
enfile(&f,3); //Insertions de la valeur 3
affiche_file (f);
enfile(&f,2); //Insertions de la valeur 2
affiche_file (f);
enfile(&f,1); //Insertions de la valeur 1
affiche_file (f);
enfile(&f,0); //Insertions de la valeur 0
/**Partie suppression**/
defile(&f); //Suppressions dans la file
affiche_file (f);
defile(&f); //Suppressions dans la file
affiche_file (f);
defile(&f); //Suppressions dans la file
affiche_file (f);
defile(&f); //Suppressions dans la file
affiche_file (f);
/**Réinsertion dans la file**/
enfile(&f,6); //Insertions de la valeur 6
enfile(&f,7); //Insertions de la valeur 7
enfile(&f,8); //Insertions de la valeur 8
affiche_file (f);
/*Manipulation des pile*/
printf("\nManipulation des piles :\n\n");
empile(&p,1); //Insertions de la valeur 0
affiche_pile(p);
empile(&p,1); //Insertions de la valeur 1
affiche_pile(p);
empile(&p,2); //Insertions de la valeur 2
affiche_pile(p);
empile(&p,3); //Insertions de la valeur 3
affiche_pile(p);
empile(&p,4); //Insertions de la valeur 4
affiche_pile(p);
empile(&p,5); //Insertions de la valeur 5
affiche_pile(p);
depile(&p); //Suppressions dans la pile
affiche_pile (p);
depile(&p); //Suppressions dans la pile
affiche_pile (p);
depile(&p); //Suppressions dans la pile
affiche_pile (p);
depile(&p); //Suppressions dans la pile
affiche_pile (p);
free (f); //Libération de mémoire pour la file f
free (p); //Libération de mémoire pour la pile p
return 0;
}