begin process at 2010 03 20 16:14:19
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Astuces

 > ALGORITHME DE RECHERCHE DICHOTOMIQUE

ALGORITHME DE RECHERCHE DICHOTOMIQUE


 Information sur la source

Note :
Aucune note
Catégorie :Astuces Classé sous :dichotomique, recherche, algo, algorithme, recherche Niveau :Initié Date de création :27/07/2005 Vu / téléchargé :25 583 / 276

Auteur : deck_bsd

Ecrire un message privé
Site perso
Commentaire sur cette source (41)
Ajouter un commentaire et/ou une note

 Description

Bonjour,

Voila, beaucoup sur ce site cherche souvent des méthodes pour recherche une variable dans un tableau ou autre. Je me susi dit pourquoi pas mettre cet algorithme bien pratique et surtout TRES éfficace; Ici il est programmer pour la recherche d'un entier dans un tableau. La fonction de test est aussi programée. Il n'y a pas de commentaire car le code est simple. Mais si il y à quand mm des questions, n'hésité pas.


++All

Source

  • #include "entete.h"
  • int rechDich (int D_intt[], int D_intvaleurRecherchee, int D_intborneInf, int D_intborneSup)
  • {
  • int D_intmilieu; /* milieu */
  • /*int x; valeur de la borne du milieu (facultatif) */
  • if (D_intborneSup<D_intborneInf)
  • {
  • return -1;
  • }
  • else
  • {
  • D_intmilieu = ((D_intborneInf + D_intborneSup)/2);
  • /*x = t[milieu]; (facultatif)*/
  • if (D_intvaleurRecherchee==D_intt[D_intmilieu])
  • {
  • return D_intmilieu;
  • }
  • else
  • {
  • if (D_intvaleurRecherchee<D_intt[D_intmilieu])
  • {
  • return(rechDich(D_intt,D_intvaleurRecherchee,D_intborneInf,D_intmilieu-1));
  • }
  • else
  • {
  • return(rechDich(D_intt,D_intvaleurRecherchee,D_intmilieu+1, D_intborneSup));
  • }
  • }
  • }
  • }
  • void main()
  • {
  • short int D_intchoix = -1, test = 0;
  • int D_intt[15]={-2,0,1,2,5,9,11,45,56,100,101,205,236,360,1001};
  • int D_intborneInf = 0;
  • int D_intborneSup =14;
  • int D_intvaleurRecherchee;
  • char D_chrep='o';
  • do
  • {
  • D_intborneSup = 14;
  • clrscr();
  • textcolor(4);
  • cprintf("\n Tableau paire ou impaire? (1/2) :");scanf ("%d", &D_intchoix);
  • if (D_intchoix==2)
  • {
  • D_intborneSup -= 1;
  • }
  • if (D_intchoix <= 2)
  • {
  • textcolor(4);
  • cprintf("\nintroduisez une valeur a rechercher :"); scanf ("%d",&D_intvaleurRecherchee);
  • if (rechDich (D_intt,D_intvaleurRecherchee,D_intborneInf,D_intborneSup) == -1)
  • {
  • textcolor(1);
  • cprintf("\n\n\t\a !! La valeur ne se trouve pas dans le tableau !!");
  • }
  • else
  • {
  • textcolor(2);
  • printf("\n\n\tindice de la valeur dans le tableau : %d" , rechDich(D_intt,D_intvaleurRecherchee,D_intborneInf,D_intborneSup));
  • }
  • textcolor(4);
  • fflush(stdin);
  • printf("\n\n voulez-vous introduire une nouvelle valeur? (o/n) :");scanf("%c", &D_chrep);
  • }
  • else
  • {
  • textcolor(1);
  • cprintf("\n\t!! vous avez introduit un choix non conforme !!");
  • getch();
  • D_chrep='o';
  • }
  • }while (D_chrep=='o');
  • }
#include "entete.h"





int rechDich (int D_intt[], int D_intvaleurRecherchee, int D_intborneInf, int D_intborneSup)
{
	
	int D_intmilieu; /* milieu */
	/*int x; valeur de la borne du milieu (facultatif) */

	if (D_intborneSup<D_intborneInf)
	{
		return -1;
	}
	else
	{
		D_intmilieu = ((D_intborneInf + D_intborneSup)/2);
		/*x = t[milieu]; (facultatif)*/
			if (D_intvaleurRecherchee==D_intt[D_intmilieu])
			{
				return D_intmilieu;
			}

			else 
			{
				if (D_intvaleurRecherchee<D_intt[D_intmilieu])
				{
					return(rechDich(D_intt,D_intvaleurRecherchee,D_intborneInf,D_intmilieu-1));
				}
				else
				{	
					return(rechDich(D_intt,D_intvaleurRecherchee,D_intmilieu+1, D_intborneSup));
				}

			}
	}
}


void main()
{
	
	short int D_intchoix = -1, test = 0;
	int D_intt[15]={-2,0,1,2,5,9,11,45,56,100,101,205,236,360,1001};
	int D_intborneInf = 0;
	int D_intborneSup =14;
	int D_intvaleurRecherchee;
	char D_chrep='o';

	do
	{
		D_intborneSup = 14;
		clrscr();
		textcolor(4);
		cprintf("\n Tableau paire ou impaire? (1/2) :");scanf ("%d", &D_intchoix);
      if (D_intchoix==2)
      {
      	D_intborneSup -= 1;
      }
      if (D_intchoix <= 2)
      {
      	textcolor(4);
         cprintf("\nintroduisez une valeur a rechercher :"); scanf ("%d",&D_intvaleurRecherchee);
         if (rechDich (D_intt,D_intvaleurRecherchee,D_intborneInf,D_intborneSup) == -1)
         {
         	textcolor(1);
            cprintf("\n\n\t\a !! La valeur ne se trouve pas dans le tableau !!");
         }
         else
         {
         	textcolor(2);
            printf("\n\n\tindice de la valeur dans le tableau : %d" , rechDich(D_intt,D_intvaleurRecherchee,D_intborneInf,D_intborneSup));
         }
			textcolor(4);
			fflush(stdin);
			printf("\n\n voulez-vous introduire une nouvelle valeur? (o/n) :");scanf("%c", &D_chrep);
      }
      else
      {
			textcolor(1);
			cprintf("\n\t!! vous avez introduit un choix non conforme !!");
			getch();
			D_chrep='o';
      }

	}while (D_chrep=='o');
}

 Conclusion

Ya t-il des questions? ;)

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

Source avec Zip Source avec une capture [C/WIN32][DRIVER] DÉTECTION DE CRÉATION OU DE SUPPRESSION DE...
Source avec Zip Source avec une capture [C/WIN32] INJECTION DE DLL 2 MÉTHODES (REMOTETHREAD PROPRE &...
Source avec Zip Source avec une capture [C/WIN32][VISTA] EXEMPLE D'UTILISATION DES TRANSACTIONS.
Source avec Zip Source avec une capture [C/WIN32] GÉNÉRATEUR DE CODE POUR UNE INITIALISATION SPÉCIAL...
Source avec Zip Source avec une capture [C/WIN32] AFFICHE TOUT LES LIENS D'UNE PAGE (X)HTML.

 Sources de la même categorie

Source avec Zip Source avec une capture [C++] CLASS REGISTER par Miwik
SMART POINTEUR À COMPTEUR DE RÉFÉRENCE par nirgal76
POINTEUR INTELLIGENT par snpier wolf
ALIGNER TEXTE CONSOLE par CptPingu
QWERTY - AZERTY AVEC SDL, UNE ALTERNATIVE par Scheb

 Sources en rapport avec celle ci

COMPARAISON DES PERFORMANCE D'ALGORITHMES POUR OPTIMISER UN ... par fuliculi
GESTION D'UN ARBRE BINAIRE PAR LES CLASSES par UKR6900
GESTION D'UNE PILE PAR LES CLASSES par UKR6900
ALGO GÉNÉRAL DE RECHERCHE DICHOTOMIQUE APRÈS UN TRIE BUBBLE ... par sbeuz
Source avec Zip Source avec une capture RECHERCHE OPERATIONNELLE : ALGORITHME DU SIMPLEXE par susur2002

Commentaires et avis

Commentaire de cosmobob le 27/07/2005 10:17:58

salut,
t'as oublié de dire qu'il fallait que ton tableau soit trié pour que ca marche bien, ce qui est une condition très forte.

a+

Commentaire de deck_bsd le 27/07/2005 10:28:09

Bien joué, j'ai oublié de le mensionner.

Merci pour le rapelle.

Commentaire de BruNews le 27/07/2005 10:37:03 administrateur CS

Clair que pour une recherche dichotomique faut que le tableau soit trié.

Quel besoin de la récursivité ??? On fait idem en itératif et c'est nettement plus rapide, on supprime en plus un param en ne donnant que le nbr d'élements du tableau.

Commentaire de LiBe444 le 27/07/2005 10:57:48

Je regrette d'avoir mis ma source en très débutant s'il faut être initié pour connaître la recherche dichotomique...

Penche toi plutôt sur cet exemple : comment trouver une valeur dans un tableau trié de longueur inconnue (sans chercher à la connaître) ?
On part du predicat que l'on ne cherche pas le maximum.
(c'est aussi de la dicotomie)
A méditer...

Commentaire de BruNews le 27/07/2005 11:35:09 administrateur CS

allez c'est pas dramatique le niveau de la source.

Lui fournir un exemple itératif sera plus profitable (enlevez les goto s'ils vous font mal aux yeux):

int __stdcall RechDicho(const int *parray, int nelem, int val)
{
  int i, n; // i = PIVOT CENTRAL
  if(nelem <= 0) goto notFOUND;
  i = nelem / 2;
  if(parray[i] == val) goto okFOUND;
  if(parray[i] < val) {
    while(++i < nelem) {
      n = parray[i];
      if(n == val) goto okFOUND;
      if(n > val) break; // ON SORT ILLICO
    }
  }
  else {
    while(--i >= 0) {
      n = parray[i];
      if(n == val) goto okFOUND;
      if(n < val) break; // ON SORT ILLICO
    }
  }
notFOUND: return -1;
okFOUND: return i;
}

Commentaire de deck_bsd le 27/07/2005 11:42:54

Je ne voi pas ou est le problem, il suffit de tester si il y à une valeur après chaque recherche après l'indice de la valeur trouvée, si il n'y en a pas, on arrete la recherche et selon que l'on aie trouver le résultat ou non, on renvoie la valeur apropriée, voila g méditer satisfait?. (Je sais , ce n'est pas très clair comme explication lol)

Commentaire de deck_bsd le 27/07/2005 11:49:44

Merci BruNews pour l'exemple itératif, mais je l'avai déjà fait :D, oui car c'était un exercice de labo algo et nous avions du faire les deux. Mais j'ai réfèrée mettre le récursif, car il est plus facile a la compréhension.
Comme le dit mon profs de concept, il est parfois préfèrable de ne pas optimiser au maximum un code , car il se pourrai que après celui-ci ne sois plus très compréhensible. Donc je préfères 100fois utilisé un peu plus de mémoire et que mon code soit compréhensible que de tout rétressir lol, surtout que maintenant la mémoire n'est plus une denrée rare comme dans le temps. Mais c'est vrai qu'il faut optimiser sont code, mais pas jusqu'a le rendre incompréhensible. Mais tu a raison que pour la recherche dico on aurai pus prendre l'itératif.

PS: j'ai mis cette source dans initié car, un débutant ds la programmation en générale ne sais pas ce qu'est un algorithme ou alors en à une idée très vague.

++All

Commentaire de LiBe444 le 27/07/2005 12:27:06

- D'accord. Ca se tient comme argument.
- La solution que tu m'a proposé ensuite est un parcours sequentiel donc ce n'est pas de la dicotomie.
L'idée est de tester si T[n] est inferieur ou superieur à la valeur cherchée. En fonction de ce test, soit on effectue une recherche dicotomique entre n/2 et n (car T[n/2]<x et T[n]>x), soit on multiplie n par deux.

Commentaire de LiBe444 le 27/07/2005 12:37:22

Tiens un problème de partiel tant qu'on y est.
Est ce que la recherche dicothomique marche sur un tableau tel que pour tout i, |T[i+1]-T[i]|<=1 ?
Essaie et conclue avec un exemple.
S'il est vrai que tu ne t'es jamais posé de telles questions, reflechir dessus te fera prendre de l'avance si tu veux faire de l'informatique ton metier.

Commentaire de BruNews le 27/07/2005 12:55:10 administrateur CS

OUPS, exact ça manque de dichotomie.
J'y ai repensé après avoir posté, je revois la question dès que possible.

Commentaire de deck_bsd le 27/07/2005 13:37:00

Libe444 , Pour ton 1er problème ma réponse, sur le test d'une valeur supérieur etait évidement incorporer ds la recherche dicotomique, je voulai juste dire, que on test comme dans l'algo que g mis si le tableau n'est pas vide, si c'est le cas, on effectue une 1er fois la recherche , une fois cette recherche effectuée on fait alors le test que j'ai décrit plus haut, si le test est positif on continue la recherche dico, si il est négatif, c'est qu'il n'y a plus de valeur et donc la recherche s'arrèt et l'on renvoie le résultat.
Pour ce qui est dut 2ième, je doit avouer que ca me parait bizar, je doit prouver en faite que pour tout i, si on fait la valeur pointée par l'indice i + 1 - cette mm valeur on doit aboutir a une résultat plus petit ou égale a 1?

Commentaire de deck_bsd le 27/07/2005 13:42:34

Raaaa, co oublié un truc . Dans mon explication du problem 1 (lol on va y arriver ptdr) quand je dit que si le test est négatif on arrete, je veu préciser que l'on arret que si le test est négatif ou si on a trouvé l'élément recherché.

Commentaire de deck_bsd le 27/07/2005 13:45:33

a première vue pour ton problem n°2 je dirai oui car vu que c'est un tableau d'élément trier, le chiffre après est tjrs supérieur ou égale a au précédent donc si on le soustrait le 2ième du prémié on tombe forcément en négatif ou = a 1, sauf si l'entier est 0. Mais je v y réfléchir plus longuement. Je sais que tu fait ca pour comment dirai je me faire souffrire lol mais c'est quand mm cool.

Commentaire de deck_bsd le 27/07/2005 13:48:27

ou un nombre négatif exemple -3 -(-5) = 2

Commentaire de BruNews le 27/07/2005 13:49:42 administrateur CS

Révisons les classiques, rien de tel que Robert Sedgewick:

int __stdcall RechDicho(const int *parray, int nelem, int val)
{
  int pos, n, i;
  if((n = nelem) <= 0) goto notFOUND;
  if(val == parray[0]) return 0;
  pos = 1;
  while(n >= pos) {
    i = (pos + n) / 2;
    if(val < parray[i]) n = i - 1;
    else pos = i + 1;
    if(val == parray[i]) return i;
  }
notFOUND: return -1;
}

Commentaire de deck_bsd le 27/07/2005 14:20:47

Looooooooool on va bientot faire un cours ici mdr

Commentaire de LiBe444 le 27/07/2005 14:30:17

N'oublie pas la valeur absolue dans l'inegalité |T[i+1]-T[i]|<=1
Cela signifie que le tableau varie d'amplitude maximale un de proche en proche ; exemple :

la suite 8 7 7 6 5 4 5 6 7 8 9 9 8 7 6 5 4 3

Aucun ordre total ne régit deux éléments isolés.

Commentaire de deck_bsd le 27/07/2005 14:36:21

A c'est bien vu ça :s .

Commentaire de deck_bsd le 27/07/2005 14:44:05

Mais avec cette suite la rech dico ne saurai pas fonctionnée ou partiellement

Commentaire de vecchio56 le 27/07/2005 15:33:52 administrateur CS

Moi je trouve que la version itérative est très compréhensible si on choisit bien ses noms de variables:

/* dicho: cherche x dans v[0..n], avec (0 <= i < j < n) => v[i] < v[j]
int dicho(int x, int v[], int n)
{
  int droite = n - 1, gauche = 0;
  while(gauche <= droite)
  {
    int milieu = (gauche + droite) / 2;
    if(x < v[milieu]) droite = milieu - 1;
    else if(x > v[milieu]) gauche = milieu + 1;
    else return milieu;
  }
  return -1;
}

Commentaire de vecchio56 le 27/07/2005 15:37:39 administrateur CS

LiBe444 j'ai pas trop compris ton problème... ya même pas de piège, la réponse est évidemment non

Commentaire de deck_bsd le 27/07/2005 16:07:23

vecchio -> oui moi aussi je la trouve compréhensible je l'ai d'ailleur mis ds un de mais post en réponse a brunews. Pour ce qui est du problème , oui tu a raison lol, mais bon c lui ki la posser donc c'est pas a nous de mettre un piège ;)

Commentaire de LiBe444 le 27/07/2005 20:21:51

Vecchio la réponse est oui justement (je l'ai étudié en plus). Fais toi un petit exemple.

Quand on varie de un ou de zéro en croissant ou en décroissant, prendre un plus petit intervalle implique que la valeur se trouve dedans. Or nécessairement elle y est puisque on a par hypothèse soit que la valeur n'y est pas (et dans ce cas pas dans le tableau tout entier) soit elle y est au moins une fois car T[inf]<x et T[sup]>x ou alors T[inf]<x et T[sup]>x. Comme les valeurs de T sont "surjectives" (pour vous l'imager bien que T ne soit pas une fonction), x figure obligatoirement dans le sous ensemble. Donc la recherche dicothomique marche.
Un doute ? Demandez le à votre professeur d'informatique (même s'il est à la plage ça peut bouillonner)

Commentaire de LiBe444 le 27/07/2005 20:23:09

euh zut T[inf]<=x et T[sup]>=x ou alors T[inf]>=x et T[sup]<=x

Commentaire de vecchio56 le 28/07/2005 15:16:30 administrateur CS

Je crois que les professeurs sont en vacances actuellement, tu peux donc nnous montrer ici comme tu fais ca avec dichotomie (j'ai pas trop compris ton explication)
Pour le coup du surjectif, tu parle de l'application x->T[x]? Celle la a l'air plutot injective non? j'ai un peu oublié tout ca...

Commentaire de cosmobob le 28/07/2005 16:07:05

ouais comment tu trouves 1 par dichotomie dans le tableau 2 1 2 3 2 3 4 5 ?

Commentaire de LiBe444 le 29/07/2005 19:27:43

Essayons :
RD(#(2,1,2,3,2,3,4,5),1,plancher(1+8/2)) = RD(#(2,1,2,3),1,plancher(1+4/2)) = 2

où #() est un tableau en Scheme.

Essayez le avec mon interpreteur de langage "K" (c'est mon script que personne ne regarde)

Commentaire de vecchio56 le 29/07/2005 19:52:47 administrateur CS

Soit tu expliques très mal, soit c'est moi qui comprends rien.

Commentaire de cosmobob le 01/08/2005 11:42:59

je pense qu'il a du mal a piger lui meme ce qu'il raconte ...
ca n'explique pas pourquoi tu t'orientes vers la sous partie gauche du tableau plutot que vers la droite ce que tu racontes...

Commentaire de vecchio56 le 01/08/2005 19:28:40 administrateur CS

Il doit y a voir une recherche sous jacente qu'il ne prend pas en compte pour que le problème soit dichotomique. Par exemple, je recherche 2 dans le tableau non trié
[1,2,5,4,3,7,6,8]=[1, 2, 5, 4] [3, 7, 6, 8]
Je vois que 2 est dans la partie gauche donc je prend celle ci
[1, 2, 5, 4] = [1, 2], [5, 4] idem
[1, 2] = [1], [2] je vois que 2 est à droite

Commentaire de cosmobob le 02/08/2005 00:52:31

comment voir que 2 est a gauche ou a droite ?
tu peux pas le deduire de la valeur des extrémités de ton sous tableau si le tableau est pas ordonné

Commentaire de vecchio56 le 02/08/2005 08:37:48 administrateur CS

Bien sur, je le vois avec mes yeux, on dirait que c'est comme ca que LiBe444 fait lui aussi

Commentaire de deck_bsd le 02/08/2005 08:59:26

Lol oui mais sont programme lui il n'en à pas ptdr. Ckler aucun moyen de savoir de quelle coté il est le 2.


++All

Commentaire de vecchio56 le 02/08/2005 17:47:01 administrateur CS

Attendons au moins ses explications

Commentaire de deck_bsd le 05/08/2005 19:39:03

oui attendons.

Commentaire de LiBe444 le 07/08/2005 14:38:25

C'est normal que vous doutiez de mes propos en les jugeant peu crédibles car je ne suis pas un professeur mais on vous enseignera tout ça aussi...

le "2" en résultat représentait bien sûr l'indice où se trouve le un cherché.
L'exemple que je vous ai montré est ce qu'il y a de plus simple.

Commentaire de LiBe444 le 07/08/2005 14:41:06

RD n'est rien de plus qu'une recherche dicothomique sur le modèle proposé par DECK_BSD, mais dans une écriture plus formelle.

Commentaire de BruNews le 07/08/2005 15:00:00 administrateur CS

Mais à part des paroles, on pourrait avoir la fonction en C qui fait ce que tu dis ???

Commentaire de LiBe444 le 10/08/2005 23:53:16

Justement, Deck_Bsd l'a écrite, c'est la fonction de prototype int rechDich (int D_intt[], int D_intvaleurRecherchee, int D_intborneInf, int D_intborneSup) ;

Commentaire de zoneg le 26/09/2005 18:58:46

Deck_bsd, tu peux au moins dire merci à Mathy (prof d'algorithmique qui a donné cette exercice début 2005)...

(Pour ceux qui n'aurait pas compris, on est dans le même établissement scolaire...)

A+ Deck ;)

Commentaire de mslider le 31/03/2009 22:09:07

bien moi j'ai essayé d'utiliser une méthode de recherche dichotomique sur mon problème(celui qui suit) et je me suis cassé les dents(pas toute) apparemment la dichotomie çà marche que pour la recherche de valeurs distinctes dans une liste et pas pour comparer des intervalles.
Bon, soit voilà le problémo:


je cherche à faire correspondre des intervalles entre eux, je m'explique:

- soit dans un premier fichier texte, disons file1.txt une suite d'intervalles de la forme:

id1 3455 3463
id2 3535 3544
id3 3601 3608
id4 3622 3630
id5 3631 3913
id6 3631 3759
id7 3631 5899
id8 3760 3913
id9 3760 5630
id10 3996 4276
id11 4486 4605
id12 4706 5095
id13 5174 5326
.../...

- dans un second fichier texte, disons file2.txt une aure suite d'intervalles de la forme:

acc_2419732 3268 3285
acc_3041065 3565 3583
acc_362358 3640 3656
acc_3279485 3793 3813
acc_3091017 3794 3811
acc_2807380 3832 3848
acc_3105138 3832 3848
acc_3105139 3832 3848
acc_3105140 3832 3848
acc_3116450 3832 3848
acc_86708 3832 3848
acc_1987802 3922 3938
acc_1679660 4113 4129
acc_891489 4113 4129
acc_2829973 4299 4318
acc_298381 4603 4619
.../...

la question est la suivante: quels sont les intervalles de mon fichier 2 (file2.txt) qui se retrouvent inclus parmi ceux du fichier 1 (file1.txt) ?
en écrivant un simple script en awk (pour les vieux pervers comme moi c sympa le awk):

#!/usr/bin/awk -f
#usage: myprog.awk file2.txt

BEGIN {
while((getline < "file1.txt") > 0){
cpt++
descr[cpt]=$1
start[cpt]=$2
end[cpt]=$3
}
close("file1.txt")
}
{
j=1
while(start[j]<=$2 && j<=cpt){
if(end[j]>=$3){print $1,$2,$3,descr[j],start[j],end[j];j++}
else{j++}
}
}

on obtient comme résultat:

acc_362358 3640 3656 id5 3631 3913
acc_362358 3640 3656 id6 3631 3759
acc_362358 3640 3656 id7 3631 5899
acc_3279485 3793 3813 id5 3631 3913
acc_3279485 3793 3813 id7 3631 5899
acc_3279485 3793 3813 id8 3760 3913
acc_3279485 3793 3813 id9 3760 5630
acc_3091017 3794 3811 id5 3631 3913
acc_3091017 3794 3811 id7 3631 5899
acc_3091017 3794 3811 id8 3760 3913
acc_3091017 3794 3811 id9 3760 5630
acc_2807380 3832 3848 id5 3631 3913
acc_2807380 3832 3848 id7 3631 5899
acc_2807380 3832 3848 id8 3760 3913
acc_2807380 3832 3848 id9 3760 5630
acc_3105138 3832 3848 id5 3631 3913
acc_3105138 3832 3848 id7 3631 5899
acc_3105138 3832 3848 id8 3760 3913
acc_3105138 3832 3848 id9 3760 5630
acc_3105139 3832 3848 id5 3631 3913
acc_3105139 3832 3848 id7 3631 5899
acc_3105139 3832 3848 id8 3760 3913
acc_3105139 3832 3848 id9 3760 5630
acc_3105140 3832 3848 id5 3631 3913
acc_3105140 3832 3848 id7 3631 5899
acc_3105140 3832 3848 id8 3760 3913
acc_3105140 3832 3848 id9 3760 5630
acc_3116450 3832 3848 id5 3631 3913
acc_3116450 3832 3848 id7 3631 5899
acc_3116450 3832 3848 id8 3760 3913
acc_3116450 3832 3848 id9 3760 5630
acc_86708 3832 3848 id5 3631 3913
acc_86708 3832 3848 id7 3631 5899
acc_86708 3832 3848 id8 3760 3913
acc_86708 3832 3848 id9 3760 5630
acc_1987802 3922 3938 id7 3631 5899
acc_1987802 3922 3938 id9 3760 5630
acc_1679660 4113 4129 id7 3631 5899
acc_1679660 4113 4129 id9 3760 5630
acc_1679660 4113 4129 id10 3996 4276
acc_891489 4113 4129 id7 3631 5899
acc_891489 4113 4129 id9 3760 5630à
acc_891489 4113 4129 id10 3996 4276
acc_2829973 4299 4318 id7 3631 5899
acc_2829973 4299 4318 id9 3760 5630
acc_298381 4603 4619 id7 3631 5899.
acc_298381 4603 4619 id9 3760 5630

voili, voilo, bon courage à tous ceux qui n'ont pas encore de dentiers

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

recherche dichotomique [ par aketostar ] AKETOSTARSalut, c'est la première fois que j'écris ici.je recherche le code source de la recherche dichotomique de tableau d'entiers trié en ordre cro recherche de l'algo pour faire un keygen [ par daru ] salut !je voulais savoir si a partir d'un nombre de serials d'un seul soft on peut deviner l'algorthme que le soft a utilisé pour les generer ,si oui recherche d'un code ou de l'algorithme [ par mohamedbzeouich ] je veux un programme ecrit en c qui peut generer des vaariable aléatoire suivant la loi normale (gaussienne) Recherche algo de la fonction ulltoa() [ par akboy7015 ] Actuellement, je développe sur VC7 et je travail beaucoup avec des __int64. Le problème est que la fonction ulltoa() n'a pas l'air d'exister.Bien ente recherche d'un algorithme [ par boumarsel ] J&#8217;explique mon probl&#232;me par un petit exemple Imaginons un menuisier qui doit fabriquer plusieurs cadres de fen&#234;tres avec des tailles d Recherche D'1 algorithme en langage C [ par mooch ] je cherche 1 algorithme en C de la FFT(fonction de transfert de Fourier Recherche sur l'algorithme de Hough [ par luke63 ] Bonjour,Je recherche de la documentation et des sources en C++&nbsp;sur l'algorithme de Hough pour d&#233;tecter des lignes dans une image bitmap apr& HELP !!!! Algorithme de recherche d'occurence dans une chaine [ par ratp ] hello, je souhaiterai cr&#233;er une fonction en C ANSI qui permet de rechercher et d'afficher le nombre d'occurences dans une chaine jusqu'as '\0' . Bellman Kalaba Simplifié en C [ par sanka113 ] Bonjour,Je suis étudiant en  2ème informatique et je me retrouve face à un dilemme en recherche opérationel.Nous avons un exercice qui consiste à prog Recherche : Algorithme Matrice d'Adjacence -> Dessin du graphe [ par olafleur ] Bonjour, je suis à la recherche d'un algorithme qui me permettrait de prendre la matrice d'adjacence d'un graphe et de dessiner celui-ci. Quelqu'un a


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,296 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales