/* pour 5 bateaux de taille respectives 1, 2, 2, 3, 4, demande au joueur de rentrer une position et une direction qui sera représentée par un entier (0 pour horizontal et 1 pour vertical), plaçant automatiquement les positions correspondantes dans la listeMorceaux de chaque bateau et ajoute le bateau dans la flotte du joueur */
Joueur placerBateau(Joueur J)
{
int i = 0;
int j = 0;
int sortDeBoucle=0;
while (i < 5)
{
sortDeBoucle=0;
Bateau BateauCourant = tableauBateaux(flotte(J))[i];
printf("\n[Placement] Bateau %d taille: %d\n",(i+1),taille(BateauCourant));
j=0;
/* Prompt de position */
Position pos1 = choixPosition();
/* Prompt de direction */
int D;
printf("\nEntrez une direction (0 horizontal - 1 vertical): ");
scanf("%d",&D);
if (!(D == 0 || D == 1))
{
printf("[ERREUR] Direction non valide !\n");
/* Pour refaire la dernière saisie ? */
i=i-1;
}
/* Générer toutes les positions et les tester (estValide(Position))*/
while (j < taille(BateauCourant) && sortDeBoucle == 0)
{
/* Sélection des morçeaux de bateaux un par un */
/* Ajouts positions dans la liste des morçeaux */
if (!(aLaPosition(flotte(J),pos1)))
{
/*printf("\n[Placement] Bateau %d, Morceau %d\n",i,j);*/
/* CAS D'ERREURS ? */
BateauCourant=ajoutMorceau(BateauCourant,pos1);
/*printf("[Info] Le bateau %d, Morceau %d a bien été placé\n",i,j);*/
if (D == 0){
pos1.X = pos1.X+1;
}
else
{
pos1.Y = pos1.Y+1;
}
}
else
{
printf("ERREUR: Case déjà occupée !\n");
i=i-1;
sortDeBoucle=1;
}
j=j+1;
}
/* Ajouts du bateau dans la flotte */
i=i+1;
}
return J;
}
liste interclasse(liste l1, liste l2) {
// liste resultat
liste l_result = nouvListe();
// indice courant l1 et l2
int ind1 = 0, ind2 = 0;
int t1 = taille(l1), t2 = taille(l2);
// tq fin d'une des listes non atteinte
while (ind1 < t1 && ind2 < t2) {
if (elt(ind1, l1) < elt(ind2, l2)) {
adjq(elt(ind1, l1), l_result);
++ind1;
} else {
adjq(elt(ind2, l2), l_result);
++ind2;
}
}
// on est arrive a la fin d'une des deux listes, dans la suite, on entre dans un seul while
while (ind1 < t1) {
adjq(elt(ind1, l1), l_result);
++ind1;
}
while (ind2 < t2) {
adjq(elt(ind2, l2), l_result);
++ind2;
}
return l_result;
}
int taille(sabr *a)
{
if (a == NULL)
{ return 0; }
else
{
return (taille(a -> g) + taille(a -> d) + 1);
}
}
//OK
//Même règle que pour l'affichage. Parcourt sous arbre gauche, on compte, puis sous arbre droit
int taille(Arbre* racine)
{
//Static permet d'instancier une seule fois la variable
static int nbnoeud=0;
if(racine!=NULL)
{
taille(racine->gauche);
nbnoeud++;
taille(racine->droit);
}
return nbnoeud;
}
liste trie(liste l) {
liste l_result=nouvListe();
// pour chaque element de l
int i, ind, cur;
for(i=0; i < taille(l); ++i) {
cur = elt(i, l); // l'element a placer
// recherche dans l_result l'indice ou placer cur
ind=0;
while(ind < taille(l_result) && elt(ind, l_result) < cur) { ++ind; }
insert(cur, l_result, ind);
}
return l_result;
}
int main(void) {
ListeChainee maliste = LISTE_VIDE;
type_el un_element = 3;
printf("J'insere (en tete) "); affiche_el(un_element); putchar('\n');
insere_entete(&maliste, un_element);
printf("J'insere (en tete) 2, puis 1, 0 et -1.\n");
insere_entete(&maliste, 2);
insere_entete(&maliste, 1);
insere_entete(&maliste, 0);
insere_entete(&maliste, -1);
printf("Voici la liste : \n\t");
affiche_liste(maliste); putchar('\n');
printf("Je supprime la tete de liste.\n");
supprime_tete(&maliste);
printf("Voici la liste : \n\t");
affiche_liste(maliste); putchar('\n');
printf("Je supprime le 4e element.\n");
supprime_suivant(maliste->suite->suite);
printf("Voici la liste : \n\t");
affiche_liste(maliste); putchar('\n');
printf("J'insere 156 en 3e position.\n");
insere_apres(maliste->suite, 156);
printf("Voici la liste : \n\t");
affiche_liste(maliste); putchar('\n');
printf("de taille %u.\n", taille(maliste));
return 0;
}
void main()
{
srand(time(NULL));
Liste l = vide();
Liste m = vide();
Liste n = vide();
int t, i;
for(i = 0; i < 10; i++)
{
t = rand()%100;
l = ajouttri(t, l);
t = rand()%100;
m = ajouttri(t, m);
affiche(l);
affiche(m);
t = rand()%100;
printf("\n %d, %d\n", t, src(l, t));
}
triBulle(l);
affiche(l);
l = flip(l, vide());
affiche(l);
l = triFusion(l);
affiche(l);
t = testtri(l);
printf("\ntri = %d \n", t);
printf("\ntaille = %d \n", taille(l));
}
void trierListe(intervalle t[], int n) {
int boolean;
int cpt;
intervalle tmp;
do {
boolean = 0;
for(cpt=0; cpt<n-1; cpt++){
if(taille(t[cpt]) > taille(t[cpt+1])){
tmp=t[cpt];
t[cpt]=t[cpt+1];
t[cpt+1]=tmp;
boolean = 1;
}
}
} while(boolean==1);
}
void affiche(liste l) {
int i;
for(i=0; i < taille(l); ++i) {
printf("%d ", elt(i, l));
}
printf("\n");
}
liste concatenation(liste l1, liste l2) {
liste l_result;
l_result = nouvListe();
int i;
// ajout de chaque element de l1
for(i=0; i < taille(l1); ++i) {
adjq(elt(i,l1), l_result);
}
// ajout de chaque element de l2
for(i=0; i < taille(l2); ++i) {
adjq(elt(i,l2), l_result);
}
return l_result;
}
int cherche(int nb, liste l) {
int ind=-1;
int i;
for(i=0;i<taille(l) && ind == -1;++i) {
if (elt(i, l) == nb) { ind = i; }
}
return ind;
}
void trierListe2(intervalle t[], int ordre[], int n){
int boolean;
int cpt;
int tmp;
for(cpt=0; cpt<n; cpt++){
ordre[cpt]=cpt;
}
cpt=0;
do {
boolean = 0;
for(cpt=0; cpt<n-1; cpt++){
if(taille(t[ordre[cpt]]) > taille(t[ordre[cpt+1]])){
tmp=ordre[cpt];
ordre[cpt]=ordre[cpt+1];
ordre[cpt+1]=tmp;
boolean = 1;
}
}
}while(boolean==1);
}
int nbOccurences(int nb, liste l) {
int nboccur=0; // compteur
int i;
// pour chaque element de la liste
for(i=0;i<taille(l);++i) {
if (elt(i, l) == nb) { nboccur++; }
}
return nboccur;
}
/* version iterative */
liste renverse_iter(liste l) {
liste l_result = nouvListe();
int i=0, fin = taille(l);
while(i < fin) {
adjt(elt(i, l), l_result);
++i;
}
return l_result;
}
/* version iterative */
int palindrome_iter(liste l) {
int result = 1; // par defaut l est un palindrome (jusqu a preuve du contraire)
// ind1 : indice de debut, ind2 : indice de fin
int ind1 = 0, ind2 = taille(l)-1;
result = 1;
while (ind1 < ind2 && result == 1) {
if (elt(ind1, l) != elt(ind2, l)) {
result = 0;
}
++ind1;
--ind2;
}
return result;
}
Image imageCollee (Image image1, Image image2, ListePoints decalage)
{
Image imageFinale;
int teinteMax;
int* size;
int** matImageFinale;
char* type;
if(strcmp(image1.type,"P2")==0 && strcmp(image2.type,"P2")==0) type="P2";
if(strcmp(image1.type,"P3")==0 && strcmp(image2.type,"P3")==0) type="P3";
teinteMax=max(image1.teinteMax,image2.teinteMax);
size=taille(&decalage,image1.height,image2.height,image1.width,image2.width);
matImageFinale=fusion(&decalage, size[0], size[1],image1,image2);
imageFinale=creationImage(type,size[0],size[1],teinteMax, matImageFinale);
return(imageFinale);
}
Liste triFusion(Liste l)
{
int i;
Liste res = vide();
Liste tmp1 = l;
Liste tmp2;
if(l->nxt == NULL)
{
return(l);
}
for(i = 0; i < taille(l)/2 - 1; i++)
{
tmp1 = tmp1->nxt;
}
tmp2 = tmp1->nxt;
tmp1->nxt = NULL;
affiche(l);
affiche(tmp2);
return(concattri(triFusion(l),triFusion(tmp2), res));
}
t_graphe *parcours_profondeur(t_graphe* graphe, char *n_s)
{
int *visite;
int *names;
t_pile *pile;
int s;
int u;
int v;
int i;
int succ;
int size;
t_ch_int *tmp;
t_ch_ch_int *ttmp;
t_graphe *T;
void *data;
u = 0;
v = 0;
data = 0;
succ = 0;
size = taille(graphe);
visite = xmalloc(sizeof(*visite)*size);
names = xmalloc(sizeof(*names)*size);
pile = xmalloc(sizeof(*pile));
pile->pile = xmalloc(sizeof(*pile->pile)*size);
pile->taille_pile = 0;
T = init(GO);
empiler(name_to_number(graphe, n_s), pile);
for (i = 0, ttmp = graphe->graphe; i < size; i++, ttmp = ttmp->next)
names[i] = ttmp->number;
inserer(get_index(s, names, size), visite);
while (pile->taille_pile != 0)
{
u = sommet(pile);
succ = 0;
for (ttmp = graphe->graphe; ttmp != NULL; ttmp = ttmp->next)
if (ttmp->number == u)
break;
for (tmp = ttmp->liste; tmp != NULL; tmp = tmp->next)
if (!visite[get_index(tmp->number, names, size)])
succ++;
if (succ != 0)
{
for (ttmp = graphe->graphe; ttmp != NULL; ttmp = ttmp->next)
if (ttmp->number == u)
break;
for (tmp = ttmp->liste; tmp != NULL; tmp = tmp->next)
if (!visite[get_index(tmp->number, names, size)])
{
v = tmp->number;
data = tmp->data;
break;
}
ajouterArc(T, number_to_name(graphe, u), number_to_name(graphe, v), data);
empiler(v,pile);
inserer(get_index(v, names, size), visite);
}
else
depiler(pile);
}
return (T);
}
//OK
//No comment
int moyenne(Arbre* racine)
{
return somme(racine)/taille(racine);
}
//Donne le nombre de noeud présent dans l'arbre
int taille (arbre a)
{
if (a == NULL) return 0;
else return 1+(taille(a->gauche))+(taille(a->droit));
}
int main()
{
arbre a,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7,tmp8,tmp9;
tmp1 = (arbre)malloc(sizeof(struct noeud));
tmp1->val = 1;
tmp1->gauche = NULL;
tmp1->droit = NULL;
tmp2 = (arbre)malloc(sizeof(struct noeud));
tmp2->val = 3;
tmp2->gauche = NULL;
tmp2->droit = NULL;
tmp3 = (arbre)malloc(sizeof(struct noeud));
tmp3->val = 7;
tmp3->gauche = NULL;
tmp3->droit = NULL;
tmp4 = (arbre)malloc(sizeof(struct noeud));
tmp4->val = 9;
tmp4->gauche = NULL;
tmp4->droit = NULL;
tmp5 = (arbre)malloc(sizeof(struct noeud));
tmp5->val = 2;
tmp5->gauche = tmp1;
tmp5->droit = tmp2;
tmp6 = (arbre)malloc(sizeof(struct noeud));
tmp6->val = 6;
tmp6->gauche = NULL;
tmp6->droit = tmp3;
tmp7 = (arbre)malloc(sizeof(struct noeud));
tmp7->val = 10;
tmp7->gauche = tmp4;
tmp7->droit = NULL;
tmp8 = (arbre)malloc(sizeof(struct noeud));
tmp8->val = 4;
tmp8->gauche = tmp5;
tmp8->droit = NULL;
tmp9 = (arbre)malloc(sizeof(struct noeud));
tmp9->val = 8;
tmp9->gauche = tmp6;
tmp9->droit = tmp7;
a = (arbre)malloc(sizeof(struct noeud));
a->val = 5;
a->gauche = tmp8;
a->droit = tmp9;
printf("La hauteur de 10 est %d\n",hauteur(a,10));
printf("Taille de l'arbre a = %d\n",taille(a));
printf("Affiche prefixe : ");
affiche_prefixe (a);
inserer (&a,1);
printf("\n");
printf("Affiche infixe : ");
affiche_infixe (a);
inserer (&a,11);
printf("\n");
printf("Affiche suffixe : ");
affiche_suffixe (a);
printf("\n");
printf ("Recherche de 2 = %d\n",recherche(a,2));
printf ("Recherche de 12 = %d\n",recherche(a,12));
printf ("Recherche de 2 = %d\n",recherche(a,5));
printf ("Recherche de 12 = %d\n",recherche(a,0));
detruit(&a);
printf("Affiche suffixe : ");
affiche_suffixe (a);
printf("\n");
return 0;
}
/* fonction auxiliaire */
void renverse_cur(liste l, liste l_result, int ind) {
if (ind == taille(l)) return;
adjt(elt(ind, l), l_result);
renverse_cur(l, l_result, ind+1);
return;
}
//cree une table de longueur pachageMerge a partir d'une liste chainee
unsigned char *creeTableLongueurMerge(ListeCouple *tete,int longMax){
ListeCouple *Ajouts = NULL ;
//liste des symboles + regroupements
ListeCouple *Liste ;
ListeCouple *Copie ;//copie de la Liste pour pouvoir supprimer des elts
int nombreSymboles = taille(tete) ;
int iteration = 2 ;
//variable pour la recherche dans Ajouts
ListeCouple *Symbolecourant = tete ;
ListeCouple *AjoutCourant ;
unsigned char *tableLongueur = initialiserTableauChar(TAILLE) ;
unsigned char charCourant ;
//int inferieurNMoins2 ;
while(/*taille(Ajouts)*/ iteration <= longMax){
//tant qu'il que l'on a pas fait N-2 regroupements
Liste = copie(tete) ;
//Ajout des regroupements dans la liste et supprimer ceux ci de Ajouts
while(Ajouts!=NULL) {
ajout(Ajouts->noeud,&Liste) ;
supprimeTete(&Ajouts) ;
}
Copie = copie(Liste) ;
//calcul de tous le Ajouts possibles
while(Copie != NULL) {
//au moins 2 elts dans dans Copie -> on ne groupe pas quand 1 seul elt
regroupement(&Copie,&Ajouts);
}
iteration++ ;
}
//on a suffisament de regroupement il faut donc compter pour chaque caracteres,
//le nombre d'apparission dans Ajouts
AjoutCourant = Ajouts ;
// printf("nb symbole = %d\nnb elt dans Ajouts = %d\n",taille(tete),taille(Ajouts)) ;
//inferieurNMoins2 = 1 ;
while(/*inferieurNMoins2 <= nombreSymboles &&*/ Symbolecourant != NULL) {
//courant contient toujours des feuilles
//on ne prend que les N-2 premiers elts de Ajouts
charCourant = Symbolecourant->noeud->value ;
tableLongueur[(int)charCourant] =
1 + nbOccurences(charCourant,
Ajouts,
nombreSymboles-2) ;
// printf("long(%c) = %d\n",charCourant,tableLongueur[(int)charCourant]) ;
Symbolecourant = Symbolecourant->suivant ;
//inferieurNMoins2++ ;
}
return tableLongueur ;
}
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;
}
/* fonction principale */
int palindrome_recur(liste l) {
return palindrome_recur_aux(l, 0, taille(l)-1);
}
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;
}
