void affiche_liste(ListeChainee liste){
putchar('(');
while(! est_vide(liste)){
affiche_el(liste->value);
liste = liste->suite;
if(!est_vide(liste)){
putchar(',');
}
}
putchar(')');
}
void start_or_continue_test(){
while( ! est_vide(fifo) ){
Test* data = (Test*) retirer_fifo( fifo );
int (*test)();
test = data->test;
liberer_test( data );
nb_total_test += 1;
int res = test();
printf("================================================================================\n");
if(res){
printf("... \033[32mvalidé.\033[0m\n");
}else{
printf("... \033[31mECHEC !\033[0m\n");
}
printf("================================================================================\n\n");
nb_test += res;
}
liberer_fifo( fifo );
printf( "\n" );
printf( "\n Nb de tests effectués : %d", nb_total_test);
printf( "\n Nb de tests validés : \033[32m%d\033[0m", nb_test);
printf( "\n Nb de tests ratés : \033[31m%d\033[0m", nb_total_test - nb_test);
printf( "\n" );
exit( nb_test );
}
void supprime_tete(ListeChainee* liste){
if(! est_vide(*liste)){
ListeChainee nouvelle= (*liste)->suite;
free(*liste);
*liste = nouvelle;
}
}
liste supprimer_tete(liste l){
if( !est_vide(l)){
liste p;
p = l->suiv;
free(l);
return p;}
else return NULL;
}
void afficher(t_ptr_liste liste) {
if(est_vide(liste)) {
printf("NULL\n");
return;
}
printf("%d, ", liste->value);
return afficher(liste->next);
}
/*@requires: p non NULL, p initialisée
@assigns: p
@ensures: on a dépilé un élément de p,
retourne l'élément retiré si le retrait est réussi, 0 sinon*/
int depiler(pile *p) {
if(est_vide(*p))
return 0;
int r = p->t[p->sommet];
p->sommet -= 1;
return r;
}
File defiler(File F, Arbre* A) {
if(est_vide(F) == 0) {
*A = F.f[F.tete];
F.tete ++;
F.tete %= 1000;
}
return F;
}
void freeListe(t_ptr_liste liste) {
t_ptr_liste next;
while(!est_vide(liste)) {
next = liste->next;
free(liste);
liste = next;
}
}
size_t taille(ListeChainee liste){
size_t size = 0;
while(! est_vide(liste)){
++size;
liste = liste->suite;
}
return size;
}
double nb_occurences_fibonacci(liste valeur_fibonacci, int nbr){
double occurence = 0;
while(!est_vide(valeur_fibonacci)){
if(prem(valeur_fibonacci)==nbr)
occurence ++;
valeur_fibonacci=reste(valeur_fibonacci);
}
return occurence;
}
t_ptr_liste copyListADT(t_ptr_liste liste) {
t_ptr_liste tmp = liste;
t_ptr_liste newList = creer_vide();
while(!est_vide(tmp)) {
newList = ajout_liste(newList, tmp->value);
tmp = queue_liste(tmp);
}
return newList;
}
t_ptr_liste ajout_liste(t_ptr_liste liste, int val) {
maillon* mail = (maillon*) malloc(sizeof(maillon));
mail->value = val;
mail->next = creer_vide();
if(est_vide(liste))
return mail;
mail->next = liste;
return mail;
}
/*@requires: p non NULL, p initalisée
@assigns: p
@ensures: on empile le sommet moins un puis le produit des deux derniers
éléments (en ayant préalablement dépilé ces deux éléments),
retourne 1 si l'opération est réussie, 0 sinon*/
void empiler_produit_deuxpremierselements(pile *p) {
if(est_vide(*p))
return 0;
int n, m;
n = depiler(p);
m = depiler(p);
empiler(p, n*m);
empiler(p, n-1);
return 1;
}
t_ptr_liste inversionListeADT(t_ptr_liste liste) {
t_ptr_liste tmp = liste;
t_ptr_liste buff = creer_vide();
t_ptr_liste prec = creer_vide();
while(!est_vide(tmp)) {
prec = tmp;
tmp = queue_liste(tmp);
prec->next = buff;
buff = prec;
}
return buff;
}
void chargePiece(SDL_Surface* ecran, liste l){
liste l1 = l;
int i,j;
int premier_coord_x = 10;
int coeff_pos_y = 1;
int coeff_pos_x = 6;
SDL_Surface *carreR = NULL;
carreR = SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLE_CARRE, TAILLE_CARRE, 32, 0, 0, 0, 0);
SDL_FillRect(carreR, NULL, SDL_MapRGB(ecran->format, 255, 0, 0));
while(!est_vide(l1)){
if(l1->premier->id >= 1){
l1->premier->coord.y += (coeff_pos_y*l1->premier->taille_carre);
}
if(l1->premier->coord.y >= 720 - (l1->premier->ligne * l1->premier->taille_carre)){
l1->premier->coord.y = 10;
coeff_pos_y = 1;
premier_coord_x = (coeff_pos_x* l1->premier->taille_carre);
coeff_pos_x += 6;
}
for( i = 0; i < l1->premier->ligne; i++)
{
l1->premier->coord.y += l1->premier->taille_carre;
l1->premier->coord.x = premier_coord_x;
if(l1->premier->coord.x >= 1280){
//reduire taille carré
if(l1->premier->taille_carre -5 > 0){
l1->premier->taille_carre -= 5;
}
}
for(j = 0; j < l1->premier->colonne; j++)
{
l1->premier->coord.x += l1->premier->taille_carre;
if(l1->premier->tab[i][j] == 1){
SDL_BlitSurface(carreR, NULL, ecran, &l1->premier->coord);
}
}
}
coeff_pos_y += 5;
l1 = reste(l1);
}
SDL_FreeSurface(carreR);
}
POIS init_pois(POIS p, SERPENT s) {
//printf("entrée dans init_pois\n");
p.abscisse=rand()%(N-1);
p.ordonnee=rand()%(N-1);
Liste l = s;
while (est_vide(l) == 0) {
if (p.abscisse == l->coord.abscisse && p.ordonnee == l->coord.ordonnee) {
p = init_pois(p, s);
}
l = l->suiv;
}
return p;
}
int findListe(t_ptr_liste liste, int val) {
int pos = 0, trouve = 0;
t_ptr_liste tmp = liste;
while(!est_vide(tmp) && trouve == 0) {
if(tmp->value == val)
trouve = 1;
else {
tmp = tmp->next;
pos++;
}
}
if(trouve == 0)
pos = -1;
return pos;
}
void pos_souris_sur_piece(int pos_souris_x,int pos_souris_y, liste l){
liste l1 = l;
while(!est_vide(l1)){
//printf("pos_souris_x = %d\n",pos_souris_x );
//printf("pos_souris_y = %d\n",pos_souris_y );
if(pos_souris_x >= l1->premier->coord.x && pos_souris_x
<= ((l1->premier->colonne * l1->premier->taille_carre) +
l1->premier->coord.x)){
if(pos_souris_y >= l1->premier->coord.y && pos_souris_y
<= ((l1->premier->ligne * l1->premier->taille_carre) +
l1->premier->coord.y)){
printf("piece %d\n",l1->premier->id);
l1->premier->coord.x = pos_souris_x;
l1->premier->coord.y = pos_souris_y;
printf("l1->premier->coord.x = %d\n", l1->premier->coord.x);
printf("l1->premier->coord.y = %d\n", l1->premier->coord.y);
}
}
l1 = reste(l1);
}
}
Liste rech(ELEMENT e, Liste L)
{ Liste p=L;
while(!est_vide(p)&&(p->val!=e)) p=p->suiv;
return p;
}
/* Algorithme de Prim */
Prim* prim(Tas *tas, Reseau *res, Noeud *deb)
{
int *pred=NULL;
double *d=NULL;
int *M=NULL;
Elem *e;
CellNoeud *voisin;
int i;
Prim *prim;
prim = malloc(sizeof(Prim));
pred = malloc(res->nbNoeuds*sizeof(int));
d = malloc(res->nbNoeuds*sizeof(double));
M = malloc(res->nbNoeuds*sizeof(int));
prim->nbNoeuds = res->nbNoeuds;
for(i = 0; i < res->nbNoeuds; i++) {
pred[i] = -1;
d[i] = FLT_MAX;
M[i] = 0;
}
//mettre le noeud de départ à la racine du tas
tas->val[deb->num]->poids = 0.0;
miseAJour(tas, tas->val[deb->num]);
d[deb->num] = 0.0;
M[deb->num] = 1;
while(!est_vide(tas)) {
//rechercher le plus petit noeud non parcouru
e = recup_min(tas);
// parcourir tous les voisins du noeud
voisin = e->noeud->voisins;
while(voisin != NULL) {
if(M[voisin->cour->num] == 0) {
d[voisin->cour->num] = voisin->poids;
pred[voisin->cour->num] = e->noeud->num;
tas->val[voisin->cour->num]->poids = voisin->poids;
miseAJour(tas, tas->val[voisin->cour->num]);
M[voisin->cour->num] = 1;
}
else {
if((M[voisin->cour->num] != 2) &&
(d[voisin->cour->num] > voisin->poids )) {
d[voisin->cour->num] = voisin->poids;
pred[voisin->cour->num] = e->noeud->num;
tas->val[voisin->cour->num]->poids = voisin->poids;
miseAJour(tas, tas->val[voisin->cour->num]);
}
}
//traiter le voisin suivant
voisin = voisin->suiv;
}
M[e->noeud->num] = 2;
}
prim->pred = pred;
prim->d = d;
return prim;
}
/*******************************************************************************************************************************
***************************************************** menu_heterogene ***********************************************************/
void menuu2(PileGe pg,Pile* p){
printf("\t***********************************************************************\n");
printf("\t*************************** Pile Generique Heterogene *****************\n");
printf("\t***********************************************************************\n");
printf("\t*********************** 1. Tester si la pile est vide ***********\n");
printf("\t*********************** 2. Empiler un Element ***********\n");
printf("\t*********************** 3. Depiler ***********\n");
printf("\t*********************** 4. Visualiser le sommet de la pile ***********\n");
printf("\t*********************** 5. Retour au menu precedent ***********\n");
int i=0;
printf("\tn=");
scanf("%d",&i);
switch (i){
case 1:{
system("cls");
if(est_vide(p))
printf("\tLa pile est vide\n");
else{
printf("\tLa pile n'est pas vide\n");
}
menuu2(pg,p);
break;
}
case 2:{
system("cls");
int choix;
printf("\t1. Empiler un Int\n");
printf("\t2. Empiler un Livre\n");
scanf("%d",&choix);
if(choix==1){
int in;
printf("\tEnter le int a empiler:\n n=");
scanf("%d",&in);
empiler(p,in,entier);
}
else{
char ID[20];
printf("\tL'ID : ");
scanf("%s",ID);
char Titre[20];
printf("\tLe titre : ");
scanf("%s",Titre);
char Auteur[20];
printf("\tL'auteur : ");
scanf("%s",Auteur);
int np;
printf("\tLe numero de pages dan ce livre : ");
scanf("%d",&np);
int j,m,y;
printf("\tLa Date de publication en format jj/mm/yy : ");
char a,b;
scanf("%d %c %d %c %d",&j,&a,&m,&b,&y);
Date dd=cred(j,m,y);
Livre liv=crel(ID,Titre,Auteur,np,dd);
empiler(p,nv_livre(ID,Auteur,Titre,np,j,m,y),livre);
}
menuu2(pg,p);
break;
}
case 3:{
system("cls");
depiler(p);
menuu2(pg,p);
break;
}
case 4:{
system("cls");
printf("le sommet de la pile est :");
Element *E;
E=p->tete;
if(E!=NULL){
Afficher_element(E->donnee);
}
printf("\n");
menuu2(pg,p);
break;
}
case 5:{
system("cls");
menuu(pg,p);
break;
}
default :{
system("cls");
printf("Votre choix est invalide !!\n");
menuu2(pg,p);
}
}
}
liste tab2D_piece(liste l)
{
FILE* fichier = NULL;
fichier = fopen("Configuration.txt", "r");
char chaine[TAILLE_MAX] = "";
int nbLigne = 0, cmp_piece = 0;
liste l1 = l;
if (fichier != NULL)
{
while (fgets(chaine, TAILLE_MAX, fichier) != NULL)
{
if(cmp_piece >= 1)
{
if(strcmp(chaine,"\n") && strlen(chaine)>0)
{
for(unsigned int i=0; i<strlen(chaine);i++)
{
if(chaine[i] == '#')
{
l1->premier->tab[nbLigne][i]=1;
}
if(chaine[i] == ' ')
{
l1->premier->tab[nbLigne][i]=0;
}
}
nbLigne++;
}
}
if(!strcmp(chaine,"\n"))
{
if(cmp_piece >= 1 ){
printf("Piece %d\n", l1->premier->id);
afficherTab2D(l1->premier->tab,l1->premier->ligne,l1->premier->colonne);
l1 = reste(l1);
}
if(!est_vide(l1)){
printf("l1->premier->ligne %d\n", l1->premier->ligne);
printf("l1->premier->colonne %d\n", l1->premier->colonne);
l1->premier->tab = allocation2D(l1->premier->ligne,l1->premier->colonne);
}
cmp_piece++;
nbLigne = 0;
}
}
fclose(fichier);
}else{
printf("Impossible d'ouvrir Configuration.txt\n");
}
return l;
}
int sizeListADT(t_ptr_liste liste) {
if(est_vide(liste))
return 0;
return 1 + sizeList(queue_liste(liste));
}
void* sommet(Pile *p){
if(est_vide(p)==true)
return NULL;
else return p->tete->donnee;
}
