int appartient(const Arbre arbre, int val) {
if(estVide(arbre))
return 0;
if(val <= arbre->racine)
return appartient(arbre->gauche, val);
if(val > arbre->racine)
return appartient(arbre->droite, val);
return 1;
}
int main()
{
Liste L;
L=malloc(sizeof(struct Element));
L->valeur = 10;
L->suivant = NULL;
printf("appartient(L,10) = %d\n",appartient(L,10));
printf("appartient(L,11) = %d\n",appartient(L,11));
return 0;
}
int main(int argc, char *argv[]) {
size_t i;
HashTable *h = alloue(13);
for(i=0; i<50; ++i)
insere(i, h);
affiche(h);
insere(16, h);
insere(27, h);
insere(256, h);
insere(30, h);
affiche(h);
if(appartient(27, h))
puts("27 appartient à la table de hachage.");
else
puts("27 n'appartient pas à la table de hachage.");
supprime(256, h);
supprime(23, h);
for(i=0; i<30; ++i)
supprime(i, h);
affiche(h);
detruit(&h);
affiche(h);
return EXIT_SUCCESS;
}
int insere(int x, HashTable *h) {
if(appartient(x, h))
return 0;
Liste **old;
Liste *nw = malloc(sizeof(Liste));
assert(nw);
nw->valeur = x;
old = h->table + (x%(h->n));
nw->suivant = *old;
*old = nw;
return 1;
}
int main() {
int k;
Liste_proc processus = NULL;
// Créer un premier processus
inserer(99, PRET, &processus);
// Créer 10 processus dans la liste
for(k = 0; k < 10; k++){
inserer(k, PRET, &processus);
}
// Afficher la liste de processus
afficher(processus);
// Modifier l'état des processus 1, 4, 7
modifierEtat(1, SUSPENDU, processus);
modifierEtat(4, SUSPENDU, processus);
modifierEtat(7, SUSPENDU, processus);
// Afficher à nouveau la liste de processus
afficher(processus);
// Afficher le pid du premier processus
printf("Le processus en tête a pour pid %d\n\n", lireNumTete(processus));
// Supprimer le processus 5
supprimer(5, &processus);
// Dire si les processus 99, 5, 7, 13 appartiennent aux processus listés
printf("%d : 99 est dans la liste des processus (1=true, 0=false)\n\n", appartient(99, processus));
printf("%d : 5 est dans la liste des processus (1=true, 0=false)\n\n", appartient(5, processus));
printf("%d : 7 est dans la liste des processus (1=true, 0=false)\n\n", appartient(7, processus));
printf("%d : 13 est dans la liste des processus (1=true, 0=false)\n\n", appartient(13, processus));
return 0;
}
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
* Retourne TRUE si le noeud source est sur le
* segment [a,b] du noeud cible.
* Le sens indique la direction testée
* exemple : si sens == BAS on teste si la cible
* est un voisin bas.
* Sinon retourne FALSE.
* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
*/
int estDansSegment(noeud *source, noeud *cible, int sens)
{
point tmp1, tmp2;
if (sens == BAS)
{
tmp1.x = source->es->a.x+1; tmp1.y = source->es->a.y;
tmp2.x = source->es->ap.x-1; tmp2.y = source->es->ap.y;
if ( appartient(tmp1, cible->es->b, cible->es->bp) == TRUE
||appartient(tmp2, cible->es->b, cible->es->bp) == TRUE)
return TRUE;
}
else if (sens == HAUT)
{
tmp1.x = source->es->b.x+1; tmp1.y = source->es->b.y;
tmp2.x = source->es->bp.x-1; tmp2.y = source->es->bp.y;
if ( appartient(tmp1, cible->es->a, cible->es->ap) == TRUE
||appartient(tmp2, cible->es->a, cible->es->ap) == TRUE)
return TRUE;
}
else if (sens == DROITE)
{
tmp1.x = source->es->a.x; tmp1.y = source->es->a.y-1;
tmp2.x = source->es->b.x; tmp2.y = source->es->b.y+1;
if ( appartient(tmp1, cible->es->ap, cible->es->bp) == TRUE
||appartient(tmp2, cible->es->ap, cible->es->bp) == TRUE)
return TRUE;
}
else if (sens == GAUCHE)
{
tmp1.x = source->es->ap.x; tmp1.y = source->es->ap.y-1;
tmp2.x = source->es->bp.x; tmp2.y = source->es->bp.y+1;
if ( appartient(tmp1, cible->es->a, cible->es->b) == TRUE
||appartient(tmp2, cible->es->a, cible->es->b) == TRUE)
return TRUE;
}
return FALSE;
}
void execution(Commande *commande, Niveau *niveau){
fixDirectory(commande, niveau);
insertionString(niveau->history, commande->commande);
int nbArgument = nbArg(commande);
int ok = 1;
int redirect = 1;
// printw("nb arg : %d\n", nbArgument);
exceptionProcessing(niveau, commande);
// Vérifie que la commande ne soit pas vide
if (strlen(commande->commande) == 0){}
else
{
// Vérifie si la commande est autorisée dans ce niveau
if (!appartient(premierArg(commande->commande), niveau->charAutorise))
{
printw("Commande \"%s\" interdite !!\n", premierArg(commande->commande));
printw("Liste des commandes autorisées :\n");
String *temp = niveau->charAutorise->premier;
printw("\t %s\n", temp->string);
while((temp = temp->suivant) != NULL){
printw("\t %s\n", temp->string);
}
}
else
{
ListeString *listeArg = malloc(sizeof(ListeString));
buildArgsChain(listeArg, commande);
// Gestion particulière du cd
if (!strcmp(substr(commande->commande,0,2), "cd"))
{
// Vérifie qu'il n'y a qu'un seul argument après le cd
if (nbArgument == 1)
{
// Vérifie que le dossier visé existe et qu'il n'est pas un fichier et qu'il n'est pas au-dessus de la racine
if (dirExists(listeArg->premier->string) && accessible(commande))
{
// Vérifie que ce n'est pas un fichier
if(fileExists(listeArg->premier->string))
printw("\"%s\" est un fichier !!\n", listeArg->premier->string);
else{
chdir(listeArg->premier->string);
fixDirectory(commande, niveau);
commande->niveau = commande->niveau + incrementNiveau(commande);
}
}else
printw("Le répertoire \"%s\" n'existe pas !!\n", listeArg->premier->string);
}else{
goBackRoot(commande);
}
}
// gestion du pwd
else if (!strcmp(substr(commande->commande,0,3), "pwd"))
pwd(commande);
// Gestion de >>
else if((redirect = isRedirector(commande)) > 0)
redirection(niveau, commande, redirect);
// commandes autres
else
{
printw("%s", exec(listeArg, commande, &(*niveau)));
}
}
}
}
vector<Point> rebond (const Point coin[12],const Point boules[15], const Point blanche,const Point cane[2],const int rayon){
// tableau dynamique des points a et b
Point p;
vector<Point> apt;
for (int i =0 ; i < 100 ;i++){apt.push_back(p);}
vector<Point> bpt;
for (int i =0 ; i < 100 ;i++){bpt.push_back(p);
bpt[i].x = -10;
bpt[i].y = -10;
}
Point cb;
// coordonnées des points de départ
cb.x=blanche.x;cb.y=blanche.y; // boule blanche
if(distancepp(cane[0],blanche)<distancepp(cane[1],blanche)){
apt[0] = cane[0]; // pointe canne puis déplacement boule blanche
bpt[0] = cane[1]; // arrière canne puis déplacement symétrique
}else{
apt[0] = cane[1]; // pointe canne puis déplacement boule blanche
bpt[0] = cane[0]; // arrière canne puis déplacement symétrique
}
// equation des bords, des trous, et de la canne (vérifiées : OK )
Segment bord[6];
for(int i = 0; i < 12; i += 2){
bord[i/2]=segment(coin[i],coin[i+1]);
}
Segment trou[6];
for(int i=1;i < 12; i += 2){
int j = (i+1)%12;
trou[(i-1)/2] = segment(coin[i],coin[j]);
}
vector<Segment> canne;
Segment s;
for (int i =0 ; i < 6 ;i++){
canne.push_back(s);
}
canne[0].p1 = apt[0];
canne[0].p2 = bpt[0];
canne[0].d = droite(canne[0].p1,canne[0].p2);
// equation des points d'intersection
Segment bs[6];
int Lmax = 5;
int j = 0;
int r = rayon;
int t = 0;
while(j < Lmax){
//recherche du point d'intersection :
for(int i = 0; i < 6; i++){
if(appartient(trou[i],croisement(canne[j].d,trou[i].d))){
if(pscalaire(bpt[j],apt[j],apt[j],croisement(canne[j].d,bord[i].d)) > 0){
apt[j] = croisement(canne[j].d,trou[i].d);
t = 1;
}
}
else{
if(appartient(bord[i],croisement(canne[j].d,bord[i].d))){
if(pscalaire(bpt[j],apt[j],apt[j],croisement(canne[j].d,bord[i].d)) > 0){
apt[j+1] = croisement(canne[j].d,bord[i].d);
bs[j+1] = bord[i];
bpt[j+1] = sym(bs[j+1], apt[j]);
canne[j+1] = segment(apt[j+1],bpt[j+1]);
}
}
}
}
/*
for(int i = 0; i < 15;i++){
Droite d = droite(apt[j],apt[j+1]);
if(distancepd(boules[i],d)<r){
Point p = boules[i];
//apt[j+1].x = (-(int)sqrtf(-d.b*d.b*(-4*d.a*d.a*r*r+d.a*d.a*boules[i].x*boules[i].x+2*d.a*d.b*boules[i].x*boules[i].y+2*d.a*d.c*boules[i].x-4*d.b*d.b*r*r+d.b*d.b*boules[i].y*boules[i].y+2*d.b*d.c*boules[i].y+d.c*d.c))-d.a*d.b*boules[i].y-d.a*d.c+d.b*d.b*boules[i].x)/(d.a*d.a+d.b*d.b);
//apt[j+1].y =(d.a*(int)sqrtf(-d.b*d.b*(-4*d.a*d.a*r*r+d.a*d.a*boules[i].x*boules[i].x+2*d.a*d.b*boules[i].x*boules[i].y+2*d.a*d.c*boules[i].x-4*d.b*d.b*r*r+d.b*d.b*boules[i].y*boules[i].y+2*d.b*d.c*boules[i].y+d.c*d.c))+d.a*d.a*d.b*boules[i].y-d.a*d.b*d.b*boules[i].x-d.b*d.b*d.c)/(d.b*(d.a*d.a+d.b*d.b));
apt[j+1].x = (-(int)sqrtf(-d.b*d.b*(-4*d.a*d.a*r*r+d.a*d.a*p.x*p.x+2*d.a*d.b*p.x*p.y+2*d.a*d.c*p.x-4*d.b*d.b*r*r+d.b*d.b*p.y*p.y+2*d.b*d.c*p.y+d.c*d.c))-d.a*d.b*p.y-d.a*d.c+d.b*d.b*p.x)/(d.a*d.a+d.b*d.b);
apt[j+1].y = (d.a*(int)sqrtf(-d.b*d.b*(-4*d.a*d.a*r^2+d.a*d.a*p.x^2+2*d.a*d.b*p.x*p.y+2*d.a*d.c*p.x-4*d.b*d.b*r^2+d.b*d.b*p.y^2+2*d.b*d.c*p.y+d.c*d.c))+d.a*d.a*d.b*p.y-d.a*d.b*d.b*p.x-d.b*d.b*d.c)/(d.b*(d.a*d.a+d.b*d.b));
Droite d1 = droite(apt[j+1],boules[i]);
Vecteur v; v.x = d1.a; v.y = d1.b;
Droite d2 = droitev(apt[j+1],v);
bpt[j+1] = projection(d2,apt[j]);
canne[j+1] = segment(apt[j+1],bpt[j+1]);
t = 0;
}
}
*/
j = j+1;
if(t == 1 ){ break; }
}
return apt;
}