3 files changed, 264 insertions, 0 deletions
diff --git a/fr-fr/binary-search-fr.html.markdown b/fr-fr/binary-search-fr.html.markdown
new file mode 100644
index 00000000..4c34da0f
--- /dev/null
+++ b/fr-fr/binary-search-fr.html.markdown
@@ -0,0 +1,67 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+    - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+    - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+# Recherche Binaire
+
+## Pourquoi la Recherche Binaire ?
+
+La recherche est un des principaux problèmes dans le domaine de l'informatique. De nos jours, il y a plus de 1 milliard de recherches par année, et nous avons besoin d'algorithmes pour faire cela rapidement. La recherche binaire est un des algorithmes les plus fondamentaux en informatique. Pour pouvoir l'explorer en détail, nous allons d'abord établir une base théorique, puis nous allons utiliser cette base pour implémenter l'algorithme en soi.
+
+## Introduction
+
+Une façon simple d'implémenter la recherche est de faire une recherche linéaire. Cependant, cette approche prend beaucoup de temps, et ce temps augmente linéairement avec la quantité de données. Par exemple, partons du premier élément d'un tableau t[], et un par un, comparons x avec chaque élément de t[]. Si x est égal à un élément, nous retournons l'index, si x n'égale aucun élément, nous retournons -1.
+
+```
+Recherche Linéaire: O (n)               Temps Linéaire
+
+Recherche Binaire:  O ( log(n) )        Temps Logarithmique
+
+```
+```
+def search(arr, x):
+
+    for i in range(len(arr)):
+
+        if arr[i] == x:
+            return i
+
+    return -1
+
+```
+## L'Algorithme de Recherche Binaire
+
+Le prérequis fondamental de la recherche binaire est que les éléments soient triés.
+
+### Algo
+
+```
+L'idée derrière la recherche binaire est d'utiliser le fait que le tableau est trié afin de réduire la complexité à O(Log(n)). Nous pouvons ignorer la moitié des éléments après la première comparaison.
+1) Comparons x avec l'élément du milieu.
+2) Si x est égal à cet élément, nous retournons l'index du milieu.
+3) Sinon, si x est plus grand que l'élément du milieu, alors x peut seulement être dans la dernière moitié du tableau. Donc, nous recommençons la procédure avec cette dernière moitié.
+4) Sinon (x est plus petit), nous recommençons la procédure avec la première moitié du tableau.
+Ensuite nous avons une implémentation récursive de la recherche binaire.
+
+```
+
+### Note de la fin
+
+Partie en construction.
+
+## Livre
+
+* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms)
+* [Algorithmes EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Design d'Algorithmes EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Ressources en ligne
+
+* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
new file mode 100644
index 00000000..24e8c95f
--- /dev/null
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+
+# Programmation dynamique
+
+## Introduction
+
+La programmation dynamique est une technique très efficace pour résoudre une certaine classe de problèmes, comme nous allons le voir. L'idée est très simple, si nous avons résolu un problème avec une certaine entrée, alors nous sauvons le résultat pour pouvoir y accéder plus tard, pour éviter d'avoir à le calculer à nouveau.
+
+## Moyens de résoudre ces problèmes
+
+1.) *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
+
+2.) *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
+
+## Exemple de Programmation Dynamique
+
+Le problème de la plus grande sous-chaîne croissante est de trouver la plus grande sous-chaîne croissante dans une chaîne. Soit la chaîne `S = {a1, a2, a3, a4, ............., an-1, an}`, nous avons à trouver la plus grande chaîne telle que pour tout `j` et `i`, `j<i` dans la chaîne `aj<ai`.
+Premièrement, nous avons à trouver la valeur de la plus grande sous-chaîne (LSi) à chaque index `i`, avec le dernier élément de la sous-chaîne étant ai. Alors, la plus grande sous-chaîne sera le plus gros LSi. Pour commencer, LSi est égal à 1, car ai est le seul élément de la chaîne (le dernier). Ensuite, pour chaque `j` tel que `j<i` et `aj<ai`, nous trouvons le plus grand LSj et ajoutons le à LSi. L'algorithme fonctionne en temps *O(n2)*.   
+
+Pseudo-code pour trouver la longueur de la plus grande sous-chaîne croissante :
+La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme plus_grande_chaîne_jusqu'à_maintenant et son index, nous pourrions sauver beaucoup de temps. 
+
+Le même concept peut être appliqué pour trouver le chemin le plus long dans un graphe acyclique orienté.  
+
+```python
+ for i=0 to n-1
+            LS[i]=1
+            for j=0 to i-1
+                        if (a[i] >  a[j] and LS[i]<LS[j])
+                                    LS[i] = LS[j]+1
+ for i=0 to n-1
+            if (largest < LS[i])
+```
+
+### Problèmes classiques de programmation dynamique
+
+L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
+
+Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
+
+
+Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+
+## Online Resources
+
+* [codechef EN](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
new file mode 100644
index 00000000..1842e02b
--- /dev/null
+++ b/fr-fr/jquery-fr.html.markdown
@@ -0,0 +1,142 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["Sylvain Vaure", "https://github.com/Gnomino"]
+filename: jquery-fr.js
+lang: fr-fr
+---
+
+jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire plus en écrivant moins" (do more, write less). Elle facilite l'écriture de nombreuses fonctions, notamment au niveau d'AJAX, de la gestion d'événements, ou encore de la manipulation de documents. 
+C'est pourquoi aujourd'hui, jQuery est utilisée par de nombreuses grandes entreprises et par des développeurs du monde entier.
+
+Étant donné que jQuery est une bibliothèque JavaScript, vous devriez d'abord [apprendre le JavaScript](https://learnxinyminutes.com/docs/fr-fr/javascript-fr/)
+```js
+
+
+///////////////////////////////////
+// 1. Les sélecteurs
+
+// On utilise les sélecteurs de jQuery pour sélectionner des éléments
+var page = $(window); // Sélectionne tout le viewport
+
+// On peut aussi utiliser des sélecteurs CSS
+var paragraph = $('p'); // Sélectionne tous les éléments paragraphes
+var table1 = $('#table1'); // Sélectionne l'élément qui a l'id 'table1'
+var squares = $('.square'); // Sélectionne tous les éléments avec la classe 'square'
+var square_p = $('p.square') // Sélectionne tous les paragraphes avec la classe 'square'
+
+
+///////////////////////////////////
+// 2. Événements et effets
+// jQuery gère très bien ce qui se passe lorsqu'un événement est déclenché
+// L'événement 'ready' est très souvent utilisé sur le document
+// On utilise la méthode 'ready' pour attendre que l'élément ait fini de se charger
+$(document).ready(function(){
+  // Ce code ne s'exécutera pas avant que le document soit chargé (prêt)
+});
+// On peut aussi utiliser des fonctions définies
+function onAction() {
+  // Ceci est exécuté quand l'événement est déclenché
+}
+$('#btn').click(onAction); // Appelle onAction à chaque clic
+
+function onAction() {
+  // Ceci est exécuté quand un évènement est déclenché
+}
+
+// D'autres évènements communs :
+$('#btn').dblclick(onAction); // Double clic
+$('#btn').hover(onAction); // Survol de la souris
+$('#btn').focus(onAction); // Gain du focus
+$('#btn').blur(onAction); // Perte du focus
+$('#btn').submit(onAction); // Envoi (d'un formulaire)
+$('#btn').select(onAction); // Quand un élement est sélectionné
+$('#btn').keydown(onAction); // Quand une touche est enfoncée
+$('#btn').keyup(onAction); // Quand une touche est relâchée
+$('#btn').keypress(onAction); // Quand on appuie sur un touche
+$('#btn').mousemove(onAction); // Quand la souris se déplace
+$('#btn').mouseenter(onAction); // La souris entre dans l'élément
+$('#btn').mouseleave(onAction); // La souris sort de l'élément
+
+// On peut aussi utiliser des fonctions lambdas
+$('#btn').hover(function(){
+  // exécuté lors d'un survol de la souris
+});
+
+// Il est possible de déclencher l'événement sans le gérer
+// simplement en ne passant aucun paramètre à la méthode
+$('#btn').dblclick(); // Simule un double clic sur l'élément
+
+// On peut gérer plusieurs événements en utilisant le sélecteur une seule fois
+$('#btn').on(
+  {dblclick: myFunction1} // Déclenché à chaque double clic
+  {blur: myFunction1} // Déclenché quand l'élément perd le focus
+);
+
+// On peut déplacer et cacher des éléments grâce à des fonctions d'effets
+$('.table').hide(); // Cache le(s) élément(s)
+
+// Note: même avec un appel à une fonction dans ces méthodes 
+// cache quand même l'élément
+$('.table').hide(function(){
+    // L'élément est caché, puis la fonction est exécutée
+});
+
+// On peut stocker des sélecteurs dans des variables
+var tables = $('.table');
+
+// Des méthodes basique de manipulation de document :
+tables.hide(); // Cache un(des) élément(s)
+tables.show(); // Montre (dé-cache) un(des) élément(s)
+tables.toggle(); // Change le statut le statut caché/montré
+tables.fadeOut(); // Fait disparaître l'élément
+tables.fadeIn(); // Fait apparaître l'élément
+tables.fadeToggle(); // Fait apparaître ou disparaître
+tables.fadeTo(0.5); // Fondu jusqu'à une certaine opacité (entre 0 et 1)
+tables.slideUp(); // Cache l'élément avec un effet de glissement vers le haut
+tables.slideDown(); // Fait apparaître l'élément avec un glissement vers le bas
+tables.slideToggle(); // Cache/Montre l'élément avec un effet de glissement
+
+// Les méthodes ci-dessus prennent en arguments 
+// une vitesse (millisecondes) et une function callback
+tables.hide(1000, myFunction); // Animation d'une seconde, puis appel à la fonction
+
+// fadeTo doit avoir une opacité entre 0 et 1 comme deuxième argument
+tables.fadeTo(2000, 0.1, myFunction); // 2 sec. fade to 0.1 opacity then function
+
+// La méthode animate permet des animations légèrement plus poussées
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// La méthode prend un objet de css et de valeurs finales,
+// des paramètres d'options facultatifs pour régler l'animation,
+// et bien sûr la fonction callback
+
+///////////////////////////////////
+// 3. Manipulation
+
+// Ces méthodes sont similaires aux effets mais permettent d'aller plus loin
+$('div').addClass('taming-slim-20'); // Ajoute la classe taming-slim-20 aux div 
+
+// Méthodes ordinaires de manipulation
+$('p').append('Hello world'); // Ajoute à la fin de l'élément
+$('p').attr('class'); // Renvoie la valeur de l'attribut
+$('p').attr('class', 'content'); // Change la valeur de l'attribut
+$('p').hasClass('taming-slim-20'); // Renvoie vrai si l'élément est de la classe
+$('p').height(); // Renvoie la hauteur de l'élément ou la change
+
+
+// Pour beaucoup de méthodes de manipulation, récupérer des informations
+// d'un élément renverra SEULEMENT ceelles du premier
+$('p').height(); // Renvoie SEULEMENT la hauteur du premier élément 'p'
+
+// On peut utiliser 'each' pour parcourir tous les éléments
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Ajoute la hauteur de tous les éléments 'p' à la liste
+});
+
+
+``
+