diff --git a/Data Structures/readme_fr.md b/Data Structures/readme_fr.md new file mode 100644 index 00000000..c8c1aefb --- /dev/null +++ b/Data Structures/readme_fr.md @@ -0,0 +1,254 @@ +# Structures de Données +En informatique, une structure de données est un format d'organisation, de gestion et de stockage des données qui permet un accès et une modification efficaces. Plus précisément, une structure de données est une collection de valeurs de données, les relations entre elles et les fonctions ou opérations qui peuvent être appliquées aux données. + +## Types de Structures de Données +- [Tableau](#tableau) +- [Liste Chaînée](#liste-chaînée) +- [Pile](#pile) +- [File](#file) +- [Table de Hachage](#table-de-hachage) +- [Tas](#tas) +- [Arbre](#arbre) +- [Graphe](#graphe) +- [Trie](Trie.md) +- [Pointeurs](Pointers.md) + +## Tableau +Un tableau est une structure de données qui stocke une collection de valeurs de données dans des emplacements de mémoire contigus. + +### Exemple +``` +let array = [4,3,8,1,0,14,6]; +``` + +| Emplacement Mémoire | Valeur | +|---------------------|--------| +| 1000 | 4 | +| 1001 | 3 | +| 1002 | 8 | +| 1003 | 1 | +| 1004 | 0 | +| 1005 | 14 | +| 1006 | 6 | + +L'accès à un élément dans un tableau se fait par indexation. +``` +array[0] // 4 (l'index 0 est le premier élément) (1000) +array[1] // 3 (l'index 1 est le deuxième élément) (1001) +array[2] // 8 (l'index 2 est le troisième élément) (1002) +array[3] // 1 (l'index 3 est le quatrième élément) (1003) +array[4] // 0 (l'index 4 est le cinquième élément) (1004) +array[5] // 14 (l'index 5 est le sixième élément) (1005) +array[6] // 6 (l'index 6 est le septième élément) (1006) +``` + +#### Complexités temporelles de certaines opérations de base sur les tableaux + +| Opération | Complexité Temporelle | +|-------------------------|-----------------------| +| Accès à un élément | O(1) | +| Recherche d'un élément | O(N) | +| Insertion d'un élément | O(N) | +| Suppression d'un élément| O(N) | + +[Plus sur les Tableaux](Array.md) + + +## Liste Chaînée +Une liste chaînée est une structure de données qui consiste en un groupe de nœuds où chaque nœud contient une valeur de données et une référence (ou lien) vers le nœud suivant dans la liste. + +### Exemple +``` +let list = [4,3,1,0,14,6]; +``` + +| Emplacement Mémoire | Valeur | +|---------------------|--------| +| 1000 | 4 | +| 1001 | 1008 | +| 1002 | 1 | +| 1003 | 1004 | +| 1004 | 0 | +| 1005 | 1006 | +| 1006 | 14 | +| 1007 | 1010 | +| 1008 | 3 | +| 1009 | 1002 | +| 1010 | 6 | +| 1011 | 1000 | + +L'accès à un élément dans une liste chaînée se fait en parcourant la liste et en trouvant l'élément à l'index correct. +``` +index 0 valeur est 4 avec emplacement mémoire 1000 et un pointeur vers le nœud suivant 1008 +index 1 valeur est 3 avec emplacement mémoire 1008 et un pointeur vers le nœud suivant 1002 +index 2 valeur est 1 avec emplacement mémoire 1002 et un pointeur vers le nœud suivant 1004 +index 3 valeur est 0 avec emplacement mémoire 1004 et un pointeur vers le nœud suivant 1006 +index 4 valeur est 14 avec emplacement mémoire 1006 et un pointeur vers le nœud suivant 1010 +index 5 valeur est 6 avec emplacement mémoire 1010 et un pointeur vers le premier nœud 1000 +``` + +#### Complexités temporelles de certaines opérations de base sur les listes chaînées + +| Opération | Complexité Temporelle | +|-------------------------|-----------------------| +| Accès à un élément | O(N) | +| Recherche d'un élément | O(N) | +| Insertion d'un élément | O(1) | +| Suppression d'un élément| O(1) | + + +#### Il peut y avoir différents types de listes chaînées : + +### Liste Chaînée Simple +Une liste chaînée simple est un type de liste chaînée qui est unidirectionnelle, c'est-à-dire qu'elle peut être parcourue dans une seule direction, de la tête au dernier nœud (queue). + +### Liste Chaînée Circulaire +Ici, le dernier nœud de la liste contient un pointeur vers le premier nœud de la liste. Nous parcourons la liste chaînée circulaire jusqu'à ce que nous atteignions le même nœud où nous avons commencé. Elle n'a ni début ni fin. Tous les nœuds ne peuvent pas être nuls. + +### Liste Chaînée Double +Dans une liste chaînée double, un nœud se compose de trois parties : les données du nœud, un pointeur vers le nœud suivant dans la séquence (pointeur suivant) et un pointeur vers le nœud précédent (pointeur précédent). Nous pouvons parcourir dans n'importe quelle direction. + +[Plus sur les Listes Chaînées](LinkedList.md) + + +## Pile +Une pile est une structure de données qui stocke une collection de valeurs de données dans un ordre LIFO (dernier entré, premier sorti).\ +Les opérations sur la pile ne peuvent se faire que par l'une de ses extrémités, appelée le _sommet_ de la pile.\ +L'implémentation peut être de type tableau (statique et contigu) ou de type liste chaînée (dynamique et discontiguë). + +[Plus sur les Piles](Stack.md) + +## File +Une file stocke une collection de valeurs de données dans un ordre FIFO (premier entré, premier sorti). Le premier élément ajouté à la file sera le premier à être traité (retiré).\ +Une file ne peut être accédée que par ses extrémités, appelées _tête_ pour son arrière et _queue_ pour son avant.\ +L'implémentation peut être de type tableau (statique et contigu) ou de type liste chaînée (dynamique et discontiguë). + +[Plus sur les Files](Queue.md) + + +## Graphe + +Le graphe est une structure de données qui consiste en des sommets (pour stocker les données) et des arêtes (pour connecter les sommets) afin de créer une structure de type réseau. Dans le graphe, chaque relation est une arête d'un sommet à un autre. + +#### Types de Graphe + +**1. Graphe Dirigé** : Les graphes dans lesquels la direction de l'arête d'un sommet à un autre est donnée sont appelés graphes dirigés.\ +**2. Graphe Non Dirigé** : Les graphes dans lesquels la direction de l'arête d'un sommet à un autre n'est pas donnée sont appelés graphes non dirigés. Ils ont une relation bidirectionnelle.\ +**3. Graphe Cyclique** : Un graphe dans lequel le cycle est présent (capable de revenir au même sommet) est appelé graphe cyclique.\ +**4. Graphe Acyclique** : Les graphes dans lesquels le cycle n'est pas présent (incapable de revenir au même sommet) sont appelés graphes acycliques.\ +**5. Graphe Pondéré** : Si un poids est présent sur l'arête du graphe, alors nous appelons ce graphe un graphe pondéré.\ + +### Terminologies de Base Concernant le Graphe + +**Degré** : Dans un graphe non dirigé, le nombre d'arêtes connectées à un sommet est appelé le degré du sommet.\ +**Degré d'Entrée** : Dans un graphe dirigé, le nombre d'arêtes entrant dans le sommet est appelé le degré d'entrée du sommet.\ +**Degré de Sortie** : Dans un graphe dirigé, le nombre d'arêtes sortant du sommet est appelé le degré de sortie du sommet.\ + +### Représentation du Graphe + +Nous pouvons représenter le graphe de deux manières : + +**1. Matrice d'Adjacence** : Dans cette représentation, s'il y a une arête entre les sommets i et j, alors nous assignons la valeur INT_MAX à cet endroit et sinon Zéro. + +| | 0 | 1 | 2 | 3 | +|--|---|---------|---|---------| +| **0** | 0 | INT_MAX | 0 | INT_MAX | +| **1** | INT_MAX | 0 | 0 | INT_MAX | +| **2** | 0 | INT_MAX | 0 | INT_MAX | +| **3** | 0 | INT_MAX | 0 | 0 | + +**2. Liste d'Adjacence** : Dans cette représentation, nous créons une liste de voisins avec le sommet. + +| sommet | voisins | +|--------|---------| +0 -> | 1 , 3 | +1 -> | 0 , 3 | +2 -> | 1 , 3 | +3 -> | 1 | + +[Plus sur les Graphes](graph.md) + + +## Tas + +Un tas est une structure de données qui est un arbre binaire complet dans lequel le nœud parent est soit supérieur à ses deux nœuds enfants, soit inférieur à ses nœuds enfants. + +### Implémentation du Tas + ``` + priority_queue,greater> (heap_name); // tas min + priority_queue> (heap_name); // tas max + + ``` + +### Types de Tas + +**1. Tas Max** : Dans un tas max, le nœud racine contient la plus grande valeur parmi toutes les valeurs de ses nœuds enfants. +**2. Tas Min** : Dans un tas min, le nœud racine contient la plus petite valeur parmi toutes les valeurs de ses nœuds enfants. + +### Avantages du Tas + +**1.** En utilisant un tas, nous pouvons accéder aux données les plus grandes ou les plus petites en temps constant.\ +**2.** Le temps de parcours d'un tas en utilisant l'algorithme de graphe (BFS, DFS) est réduit à un ordre polynomial.\ +**3.** Comme le tas est un arbre binaire complet, pour N nœuds, la hauteur maximale d'un tas est log(N), donc la complexité temporelle pour accéder au nombre maximum et minimum est réduite à un temps constant et pour le Kème élément, elle est réduite à une complexité linéaire.\ + +[Plus sur les Tas](Heap.md) + + +#### Table de Hachage + +La table de hachage est une structure de données qui stocke les données de manière associative. Dans une table de hachage, les données sont stockées sous forme de tableau, où chaque valeur de données a sa propre valeur d'index unique. L'accès aux données devient très rapide si nous connaissons l'index des données souhaitées. + +### Exemple + +``` +La fonction de hachage H(x) = [11,12,13,14,15] +// elle sera stockée aux positions {1,2,3,4,5} +// dans le tableau ou la table de hachage respectivement. +``` +[Plus sur les Tables de Hachage](HashTable.md) + +## Tas + +Un tas est une structure de données spécialisée basée sur les arbres qui est un arbre presque complet qui satisfait la propriété du tas. La propriété du tas signifie que l'élément avec la clé la plus grande est toujours dans le nœud racine, un tel tas est parfois appelé un tas max. + +### Exemple + +``` +Laissez le tableau de nombres être [100, 7, 2, 17, 3, 25, 1, 36, 19] +// Il sera sous forme d'arbre où le plus grand nombre pointera vers un nombre plus petit et le plus petit nombre pointera vers un nombre encore plus petit, et ainsi de suite + +Une représentation en tas du tableau ressemblerait à ceci : + 100 + / \ + 19 36 + / \ / \ + 17 3 25 1 + / \ + 2 7 +``` +[Plus sur les Tas](Heap.md) + +## Arbre + +Un arbre est une structure de données non linéaire et hiérarchique composée d'une collection de nœuds de telle sorte que chaque nœud de l'arbre stocke une valeur et une liste de références vers d'autres nœuds (les "enfants"). + +### Exemple + +``` +Laissez le tableau de nombres être [100, 7, 2, 17, 3, 25, 1, 36, 19] +// L'arbre est une méthode spécialisée pour organiser et stocker les données dans l'ordinateur pour être utilisé plus efficacement +Une représentation en arbre du tableau ressemblerait à ceci : + 100 + / \ + 19 36 + / \ / \ + 17 3 25 1 + / \ + 2 7 +``` +[Plus sur les Arbres](Tree.md) + +## Graphe +Un graphe est une structure de données non linéaire composée de sommets et d'arêtes. Les sommets sont parfois également appelés nœuds et les arêtes sont des lignes ou des arcs qui connectent deux nœuds quelconques dans le graphe. Plus formellement, un graphe est composé d'un ensemble de sommets (V) et d'un ensemble d'arêtes (E). Le graphe est noté G(E, V). + +[Plus sur les Graphes](Graph.md) diff --git a/Data Types/readme_fr.md b/Data Types/readme_fr.md new file mode 100644 index 00000000..9767bb96 --- /dev/null +++ b/Data Types/readme_fr.md @@ -0,0 +1,630 @@ +# [Types de données](#types-de-données) +Un type de données, en programmation, est une classification qui spécifie quel type de valeur une variable a et quel type d'opérations mathématiques, relationnelles ou logiques peuvent être appliquées sans provoquer d'erreur. + +En informatique et en programmation informatique, un type de données est un ensemble de valeurs possibles et un ensemble d'opérations autorisées sur celui-ci. Un type de données indique au compilateur ou à l'interpréteur comment le programmeur a l'intention d'utiliser les données. + +--- + +## Principaux Types de Données + +- [Types de Données Primitifs](#types-de-données-primitifs) +- [Types de Données Non Primitifs](#types-de-données-non-primitifs) + +--- + +## [Types de Données Primitifs](#types-de-données-primitifs) + +Les types de données primitifs sont les types de données les plus basiques dans un langage de programmation. Ils sont les blocs de construction de types de données plus complexes. Les types de données primitifs sont prédéfinis par le langage de programmation et sont nommés par un mot-clé réservé. + +### Types de Données Primitifs Courants(#types-de-données-primitifs-courants) + +- [Entier](#entier) +- [Flottant](#flottant) +- [Booléen](#booléen) +- [Caractère](#caractère) +- [Chaîne de caractères](#chaîne-de-caractères) + +--- + +### [Entier](#entier) + +Un entier est un nombre entier qui peut être positif, négatif ou zéro. Dans la plupart des langages de programmation, un entier est un entier signé de 32 bits, ce qui signifie qu'il peut avoir une valeur comprise entre -2,147,483,648 et 2,147,483,647. Dans certains langages de programmation, un entier peut être de 64 bits, ce qui signifie qu'il peut avoir une valeur comprise entre -9,223,372,036,854,775,808 et 9,223,372,036,854,775,807. +#### Exemple : + +##### **C, C++, C#, Java** + +```c +// Initialisation de la variable int 'x' avec la valeur '5'. +int x = 5; +``` + +##### **Python** + +```python +# Initialisation de la variable int 'x' avec la valeur '5'. +x = 5 +``` + +##### **JavaScript** + +```javascript +// Initialisation de la variable int 'x' avec la valeur '5'. +let x = 5; +``` + +--- + +### [Flottant](#flottant) + +Un flottant est un nombre qui peut avoir un point décimal. Dans la plupart des langages de programmation, un flottant est un nombre à virgule flottante de 32 bits, ce qui signifie qu'il peut avoir une valeur comprise entre 1,175494351e-38 et 3,402823466e+38. Dans certains langages de programmation, un flottant peut être de 64 bits, ce qui signifie qu'il peut avoir une valeur comprise entre 2,2250738585072014e-308 et 1,7976931348623157e+308. + +#### Exemple : + +##### **C, C++** + +```c +// Initialisation de la variable float 'x' avec la valeur '5.5'. +float x = 5.5; +``` + +##### **C#** + +```c# +// Initialisation de la variable float 'x' avec la valeur '5.5'. +float x = 5.5D; +``` + +##### **Python** + +```python +# Initialisation de la variable float 'x' avec la valeur '5.5'. +x = 5.5 +``` + +##### **Java** + +```java +// Initialisation de la variable float 'x' avec la valeur '5.5'. +float x = 5.5f; +``` + +##### **JavaScript** + +```javascript +// Initialisation de la variable float 'x' avec la valeur '5.5'. +let x = 5.5; +``` + +--- + +### [Booléen](#booléen) + +Un booléen est un type de données qui ne peut avoir que l'une des deux valeurs : vrai ou faux. + +#### Exemple : + +##### **C, C++, C#** + +```c +// Initialisation de la variable bool 'x' avec la valeur 'true'. +bool x = true; +``` + +##### **Python** + +```python +# Initialisation de la variable bool 'x' avec la valeur 'True'. +x = True +``` + +##### **Java** + +```java +// Initialisation de la variable bool 'x' avec la valeur 'true'. +boolean x = true; +``` + +##### **JavaScript** + +```javascript +// Initialisation de la variable bool 'x' avec la valeur 'true'. +let x = true; +``` + +--- + +### [Caractère](#caractère) + +Un caractère est une seule lettre, un nombre ou un symbole. Dans la plupart des langages de programmation, un caractère est un entier non signé de 16 bits, ce qui signifie qu'il peut avoir une valeur comprise entre 0 et 65,535. + +#### Exemple : + +##### **C, C++, C#, Java** + +```c +// Initialisation de la variable char 'x' avec la valeur 'a'. +char x = 'a'; +``` + +##### **Python** + +```python +# Python n'a pas de type 'caractère'. Tous les caractères uniques sont considérés comme des chaînes de longueur un par Python. +x = "a" +``` + +##### **JavaScript** + +```javascript +// Initialisation de la variable char 'x' avec la valeur 'a'. +let x = "a"; +``` + +--- + +### [Chaîne de caractères](#chaîne-de-caractères) + +Une chaîne de caractères est une séquence de caractères. Dans la plupart des langages de programmation, une chaîne de caractères est un tableau de caractères. + +#### Exemple : + +##### **C** + +```c +// Initialisation de la variable chaîne 'sayHello' avec la valeur 'Hello World!' +char sayHello[] = "Hello World!"; +``` + +##### **C++, C#** + +```c++ +// Initialisation de la variable chaîne 'sayHello' avec la valeur 'Hello World!' +string sayHello = "Hello World!"; +``` + +##### **Python** + +```python +# Initialisation de la variable chaîne de caractères 'say_hello' avec la valeur 'Hello World!' +say_hello = "Hello World!" +``` + +##### **Java** + +```java +// Initialisation de la variable chaîne de caractères de caractères 'sayHello' avec la valeur 'Hello World!' +String sayHello = "Hello World!"; +``` + +##### **JavaScript** + +```javascript +// Initialisation de la variable chaîne de caractères 'x' avec la valeur 'Hello World!' +let x = "Hello World!"; +``` + +--- + +## [Types de Données Non Primitifs](#types-de-données-non-primitifs) + +Les types de données non primitifs sont également appelés types de données de référence. Ils sont créés par le programmeur et ne sont pas définis par le langage de programmation. Les types de données non primitifs sont également appelés types de données composites car ils sont composés d'autres types. + +### Types de Données Non Primitifs Courants(#types-de-données-non-primitifs-courants) + +- [Tableau](#tableau) +- [Structure](#structure) +- [Union](#union) +- [Pointeur](#pointeur) +- [Fonction](#fonction) +- [Classe](#classe) +- [Liste](#liste) +- [Map/Dictionnaire](#mapdictionnaire) +- [Ensemble](#ensemble) +- [Paire/Tuple](#pairetuple) + +--- + +### [Tableau](#tableau) + +Un tableau est une collection d'éléments stockés à des emplacements de mémoire contigus. L'idée est de stocker plusieurs éléments du même type ensemble. Cela facilite le calcul de la position de chaque élément en ajoutant simplement un décalage à une valeur de base, c'est-à-dire l'emplacement de mémoire du premier élément du tableau (généralement désigné par le nom du tableau). + +#### Exemple : + +##### **C, C++** + +```c +// Initialisation d'un tableau 'x' qui peut stocker des valeurs int. +int x[] = {5, 10, 15, 20, 25}; +``` + +##### **C#** + +```c# +// Initialisation d'un tableau 'x' qui peut stocker des valeurs int. +int[] x = {5, 10, 15, 20, 25}; +``` + +##### **Java** + +```java +// Initialisation d'un tableau 'x' qui peut stocker des valeurs int. +int[] x = {5, 10, 15, 20, 25}; +``` + +##### **JavaScript** + +```javascript +// Initialisation d'un tableau 'x' qui peut stocker des valeurs int. +const x = [5, 10, 15, 20, 25]; +``` + +--- + +### [Structure](#structure) + +Une structure est une collection de variables de différents types de données sous un seul nom. Elle est utilisée pour combiner des éléments de données de différents types. + +#### Exemple : + +##### **C, C++** + +```c +// Création d'une structure qui stocke trois variables. +struct Personne { + char nom[50]; + int age; + float salaire; +}; +``` + +##### **C#** + +```c# +// Création d'une structure qui stocke trois variables. +struct Personne +{ + public string nom; + public int age; + public float salaire; +} +``` + +--- + +### [Union](#union) + +Une union est un type de données spécial disponible en C qui permet de stocker différents types de données dans le même emplacement mémoire. Vous pouvez définir une union avec plusieurs membres, mais un seul membre peut contenir une valeur à un moment donné. Les unions offrent un moyen efficace d'utiliser le même emplacement mémoire à des fins multiples. + +#### Exemple : + +##### **C** + +```c +// Créer une union +union Data { + int i; + float f; + char str[20]; +}; +``` + +--- + +### [Pointeur](#pointeur) + +Un pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe de l'emplacement mémoire. Comme toute variable ou constante, vous devez déclarer un pointeur avant de l'utiliser pour stocker une adresse de variable. La forme générale d'une déclaration de variable pointeur est : + +```c +type *nom-var; +``` + +Ici, type est le type de base du pointeur ; il doit être un type de données C valide et nom-var est le nom de la variable pointeur. L'astérisque \* utilisé pour déclarer un pointeur est le même astérisque utilisé pour la multiplication. Cependant, dans cette déclaration, l'astérisque est utilisé pour désigner une variable comme un pointeur. +Exemple : + +```c +int *ip; // ip est un pointeur vers un entier +``` + +--- + +### [Fonction](#fonction) + +Une fonction est un groupe d'instructions qui exécutent ensemble une tâche. Chaque programme C a au moins une fonction, qui est main(), et tous les programmes les plus triviaux peuvent définir des fonctions supplémentaires. La bibliothèque standard C fournit de nombreuses fonctions intégrées que votre programme peut appeler. + +#### Exemples : + +##### **C, C++** + +```c +// Créez votre propre fonction en utilisant le format suivant : +void nomDeLaFonction() { + // code à exécuter +} +``` + +##### **C#, Java** + +```c# +// En C# et Java, les fonctions sont appelées méthodes et sont définies comme suit : +static void nomDeLaFonction() +{ + // code à exécuter +} +``` + +##### **Python** + +```python +# Définir une fonction en Python : +def nom_de_la_fonction(): + # code à exécuter +``` + +##### **JavaScript** + +```javascript +// Définir une fonction en JavaScript : +function nomDeLaFonction() { + // code à exécuter +} +``` + +--- + +### [Classe](#classe) + +Une classe est un type de données défini par l'utilisateur, qui contient ses propres membres de données et fonctions membres, qui peuvent être accessibles et utilisés en créant une instance de cette classe. Une classe est comme un plan pour un objet. + +#### Exemples : + +##### **C++** + +```c++ +class Personne { + public: + string nom; + int age; + float salaire; +}; +``` + +##### **C#** + +```c# +class Voiture +{ + string marque; + string couleur; +} +``` + +##### **Python** + +```python +class Pays: + nom = "États-Unis" + capitale = "Washington" +``` + +##### **Java** + +```java +public class Candidat { + String nom; + int age; +}; +``` + +##### **JavaScript** + +```javascript +class Bateau { + constructor(marque, annee) { + this.marque = marque; + this.annee = annee; + } +} +``` + +--- + +### [Liste](#liste) + +Une liste est spécifiée comme une collection d'objets ordonnés. Les listes sont similaires aux tableaux, mais la taille d'une liste peut augmenter ou diminuer selon les besoins. Les listes sont également connues sous le nom de tableaux dynamiques. + +#### Exemples : + +##### **Python** + +```python +x = [1, 2, 3] +``` + +--- + +### [Map/Dictionnaire](#mapdictionnaire) + +Une map est une structure de données qui stocke des éléments de manière à permettre une récupération rapide. Chaque élément est stocké sous forme de paire clé-valeur. Une map ne peut pas contenir de clés en double. Chaque clé peut correspondre à au plus une valeur. + +#### Exemples : + +##### **Python** + +```python +x = {"nom": "John", "âge": 30} +``` + +##### **C++** + +```c++ +#include +map x = {{"nom", "John"}, {"âge", 30}}; +``` + +--- + +### [Ensemble](#ensemble) + +Un ensemble est une collection d'éléments où aucun élément n'est répété. Les ensembles sont non ordonnés, ce qui signifie que l'ordre dans lequel les éléments sont ajoutés à un ensemble n'a pas d'importance. Les ensembles sont également connus sous le nom de listes non ordonnées. + +#### Exemples : + +##### **Python** + +```python +x = {"pomme", "banane", "cerise"} +``` + +##### **C++** + +```c++ +#include +set x = {"pomme", "banane", "cerise"}; +``` + +--- + +### [Paire/Tuple](#pairetuple) + +Une paire est un conteneur qui stocke deux valeurs ensemble. Un tuple est un conteneur qui stocke un nombre fixe de valeurs ensemble. Les valeurs peuvent être de types différents. + +#### Exemples : + +##### **Python** + +```python +x = ("pomme", "banane", "cerise") +``` + +##### **C++** + +```c++ +#include +tuple x = {"pomme", "banane", "cerise"}; +``` + +--- + +## Conversion de Type de Données + +La conversion de type de données est la conversion de données d'un type à un autre. Dans la plupart des cas, la conversion de type de données est effectuée automatiquement par le compilateur. Cependant, parfois, vous devez effectuer manuellement la conversion de type de données pour obtenir le résultat attendu. + +### Conversion de Type de Données Courante + +- [Conversion Implicite](#conversion-implicite) +- [Conversion Explicite](#conversion-explicite) + +### [Conversion Implicite](#conversion-implicite) + +La conversion implicite est la conversion automatique de données d'un type à un autre. Cette conversion est effectuée par le compilateur lorsqu'il détecte qu'une conversion est nécessaire. Par exemple, lorsque vous assignez une valeur d'un type de données plus petit à une variable d'un type de données plus grand, le compilateur convertit automatiquement la valeur au type de données plus grand. +Exemple : + +```c +int x = 10; // x est un entier +float y = x; // y est un flottant +``` + +```python +x = 10 # x est un entier +y = float(x) # y est un flottant +``` + +### [Conversion Explicite](#conversion-explicite) + +La conversion explicite est la conversion de données d'un type à un autre effectuée par le programmeur. Cette conversion est effectuée en utilisant un opérateur de conversion de type. Par exemple, lorsque vous assignez une valeur d'un type de données plus grand à une variable d'un type de données plus petit, le compilateur ne convertira pas automatiquement la valeur au type de données plus petit. Dans ce cas, vous devez utiliser un opérateur de conversion de type pour convertir explicitement la valeur au type de données plus petit. +Exemple : + +```c +float x = 10.5; // x est un flottant +int y = (int)x; // y est un entier +``` + +```python +x = 10.5 # x est un flottant +y = int(x) # y est un entier +``` + +## Remarque + +Nous devons être prudents lors de la conversion explicite de type, comme : + +- Convertir une valeur de type flottant en valeur de type entier, car cela entraînerait une perte des valeurs décimales. +- Un type de données plus grand, s'il est converti en type de données plus petit, entraînera une perte de données car le nombre sera tronqué. + +--- +## Concept de Signé et Non Signé (Signedness) + +En C et dans de nombreux autres langages de programmation, y compris C++, Java et autres, les concepts de "signé" et "non signé" sont utilisés pour spécifier comment les données des types entiers (comme 'int', 'short', 'long', etc.) doivent être interprétées en termes de représentation de leur valeur. Ces concepts déterminent si les données peuvent représenter à la fois des valeurs positives et négatives (signé) ou uniquement des valeurs non négatives (non signé). + +### Types Courants de Signedness + +- [Type Signé](#type-signé) +- [Type Non Signé](#type-non-signé) + +### [Type Signé](#type-signé) + +Un type entier signé peut représenter à la fois des valeurs positives et négatives. +Le bit le plus significatif (le bit le plus à gauche) est généralement utilisé pour indiquer le signe du nombre : 0 pour positif et 1 pour négatif (en utilisant la représentation en complément à deux). + +Par exemple, un entier signé de 8 bits peut représenter des valeurs dans la plage de -128 à 127, car le MSB est occupé par le signe du nombre, donc 7 bits sont laissés pour la représentation du nombre. Formule pour trouver la plage en représentation en complément à deux : +-(2^(n-1)) à (2^(n-1)-1), où 'n' est le nombre de bits dans le registre. + +#### Exemple : + +##### **C** + +```c +signed int a = -10; +``` + +### [Type Non Signé](#type-non-signé) + +Les types de données non signés peuvent représenter uniquement des valeurs non négatives, y compris zéro. +Tous les bits dans la représentation binaire sont utilisés pour représenter la magnitude du nombre. +Les types de données non signés courants incluent unsigned int, unsigned short, unsigned long, etc. + +Par exemple, un entier non signé de 8 bits peut représenter des valeurs dans la plage de 0 à 255, car il n'y a pas de bit de signe présent, donc tous les bits sont utilisés pour la représentation du nombre, augmentant ainsi la plage positive. Formule pour trouver la plage : 0 à ((2^n)-1), où 'n' est le nombre de bits dans le registre. + +#### Exemple : + +##### **C** + +```c +unsigned int unsignedValue = 42; +``` + +### Signé vs Non Signé + +### Avantages des Types Entiers Signés : + +Représentation des Valeurs Négatives : Les entiers signés peuvent représenter à la fois des valeurs positives et négatives, ce qui les rend adaptés aux scénarios où vous devez gérer une large gamme de nombres, y compris les valeurs négatives. + +Opérations Arithmétiques : Les entiers signés sont essentiels pour les opérations arithmétiques qui peuvent produire des résultats négatifs. Par exemple, la soustraction ou la division peuvent produire des résultats négatifs, et les entiers signés sont nécessaires pour gérer correctement ces cas. + +Compatibilité : Les entiers signés sont largement utilisés dans de nombreux langages de programmation et bibliothèques, ce qui les rend compatibles avec une large gamme de logiciels et de systèmes. + + +### Avantages des Types Entiers Non Signés : + +Valeurs Non Négatives : Les entiers non signés sont utiles lorsque vous devez travailler exclusivement avec des valeurs non négatives. Ils sont idéaux pour les scénarios où les valeurs négatives n'ont aucun sens ou ne sont pas applicables, comme les indices de tableau, les tailles ou les opérations au niveau des bits. + +Plage de Valeurs Maximale : Les entiers non signés offrent une plage de valeurs positives plus large que leurs homologues signés avec le même nombre de bits. Cela peut être bénéfique lorsque vous devez stocker de grandes valeurs positives. + +Opérations au Niveau des Bits : Les entiers non signés sont couramment utilisés dans les opérations au niveau des bits, où le signe de la valeur n'est pas pertinent. Ils sont souvent utilisés pour manipuler des bits individuels ou effectuer des opérations comme le masquage de bits. + +Prévention des Bugs de Dépassement : Dans certains cas, l'utilisation d'entiers non signés peut aider à prévenir les bugs de dépassement qui peuvent survenir lors de la manipulation de grandes valeurs, car les entiers non signés reviennent à zéro lorsqu'ils dépassent leur valeur maximale représentable. + +## Taille des Types de Données + +La taille des types de données est la quantité de mémoire nécessaire pour stocker une valeur d'un type de données particulier. La taille d'un type de données dépend du compilateur et de l'architecture de l'ordinateur. La taille d'un type de données peut varier d'un ordinateur à un autre. La taille d'un type de données peut également varier d'un compilateur à un autre. La taille d'un type de données peut également varier d'un système d'exploitation à un autre. + +### Comparaison de la Taille des Types de Données (Basée sur un système 64 bits utilisant l'architecture x86-64) + +- Caractère (1 octet) +- Booléen (1 octet) +- Entier (4 octets) +- Entier Court (2 octets) +- Entier Long (8 octets) +- Flottant (4 octets) +- Double (8 octets) +- Double Long (16 octets) diff --git a/Programming_Languages/readme_fr.md b/Programming_Languages/readme_fr.md index 7459bbc7..8b3b8b6f 100644 --- a/Programming_Languages/readme_fr.md +++ b/Programming_Languages/readme_fr.md @@ -1,85 +1,83 @@ # Langages de programmation -On peut distinguer deux types de langages de programmation : +>On peut distinguer deux types de langages de programmation : -1. Les langages dit de "haut-niveau" qui utilisent une syntaxe proche du langage humain. Le code source y est plus intelligible et il est compilé en code executable via un compilateur ou un interpréteur. Java et Python sont deux exemples de langages de "haut-niveau". +1. Les langages dit de "haut-niveau" qui utilisent une syntaxe proche du langage humain. Le code source y est plus intelligible et il est compilé en code executable via un compilateur ou un interpréteur. Java et Python sont deux exemples de langages de "haut-niveau". Ceux-ci sont généralement plus lents que les langages de bas niveau, mais cela s'accompagne d'une plus grande facilité. +2. Les langages de programmation de bas niveau fonctionnent plus étroitement avec le matériel et offrent plus de contrôle sur celui-ci. Ils interagissent directement avec le matériel. Deux exemples courants de langages de bas niveau sont le langage machine et le langage assembleur. Ceux-ci sont généralement plus rapides que les langages de haut niveau, mais cela se fait au prix d'une grande complexité. - +La POO utilise largement les classes, qui sont une manière de créer de nouveaux objets à partir d'un modèle ou d'une structure prédéfinie que le programmeur définit. Les objets créés à partir d'une classe sont appelés des instances. \ No newline at end of file diff --git a/README_fr.md b/README_fr.md index fe610f0e..a15261b9 100644 --- a/README_fr.md +++ b/README_fr.md @@ -1,7 +1,7 @@

Computer Science

- English | + English | Italiano | Español | Français | @@ -15,14 +15,14 @@ ## Guide de contribution -Si vous souhaitez participez à ce projet, prenez le temps de jeter un oeil au guide contribution [CONTRIBUTING.md](https://github.com/shhossain/computer_science/blob/main/CONTRIBUTING.md) pour obtenir plus de détail sur comment participer et comment commencer. Votre aide est grandement appréciée. +Si vous souhaitez participer à ce projet, prenez le temps de jeter un œil au guide de contribution [CONTRIBUTING.md](https://github.com/shhossain/computer_science/blob/main/CONTRIBUTING.md) pour obtenir plus de détails sur comment participer et comment commencer. Votre aide est grandement appréciée. ## Table des matières - [Introduction](#introduction) -- [Ordinateur électronique](#oridnateur-electronique) -- [Logique booléenne](#logique-booleene) -- [Langages de programmation](#langages-de-programation) +- [Ordinateur électronique](#ordinateur-electronique) +- [Logique booléenne](#logique-booleenne) +- [Langages de programmation](#langages-de-programmation) ## Introduction @@ -31,33 +31,119 @@ L'informatique est l'étude des ordinateurs mais également de l'application th ## [Ordinateur électronique](/Electronic%20Computer/readme_fr.md) Un ordinateur électronique est un appareil qui calcule et plus particulièrement une machine électronique programmable qui effectue des calculs ou des opérations logiques à grande vitesse. Elle peut également assembler, stocker, mettre en corrélation ou traiter l'information. -## [Logique booléenne (ou opérateurs logiques)](Boolean%20Logic/readme.md) +## [Logique booléenne (ou opérateurs logiques)](Boolean%20Logic/readme_fr.md) La logique booléenne est une branche des mathématiques qui traite des valeurs dites vraies ou fausses (true ou false). C'est un système logique qui utilise 2 valeurs, 0 et 1, pour différencier respectivement le vrai et le faux. Elle est également appelée algèbre de Boole par son créateur George Boole en 1854. - -### Opérateurs booléen récurrents +### Opérateurs booléens récurrents | Opérateur | Nom | Description | | :------: | :--: | :-------------------------------------: | -| ! | NON | Inverse l'état d'une variable booléene. (0 -> 1 ; 1 -> 0) | -| && | ET | Retoune **vrai** si TOUTES les conditions sont respéctées. | -| \|\| | OU | Retoune **vrai** si au moins UNE des conditions est respéctées. | +| ! | NON | Inverse l'état d'une variable booléenne. (0 -> 1 ; 1 -> 0) | +| && | ET | Retourne **vrai** si TOUTES les conditions sont respectées. | +| \|\| | OU | Retourne **vrai** si au moins UNE des conditions est respectée. | ### Opérateurs booléens utiles | Opérateur | Nom | Description | | :------: | :--: | :-------------------------------------: | -| () | Parenthèses | Permet de regrouper des mots-clés et/ou controler l'ordre de recherche. (priorité) | +| () | Parenthèses | Permet de regrouper des mots-clés et/ou contrôler l'ordre de recherche. (priorité) | | “” | Guillemets | Renvoie le résultat comprenant la phrase exacte. | -| * | Astérix | Renvoie le résultat comprenant un mot-clé. | +| * | Astérisque | Renvoie le résultat comprenant un mot-clé. | | ⊕ | XOR - OU exclusif | Retourne **vrai** si les entrées sont différentes. | | ⊽ | NOR - OU inversé | Retourne **vrai** si toutes les entrées sont fausses. | -| ⊼ | NAND - ET inversé | Retourne **faux** si les deux valeurs d'entrée sont vrais. | +| ⊼ | NAND - ET inversé | Retourne **faux** si les deux valeurs d'entrée sont vraies. | + +## [Langages de programmation](/Programming_Languages/readme_fr.md) +Un langage de programmation est un ensemble de règles qui convertit des chaînes de caractères, ou des éléments graphiques de programme dans le cas des langages de programmation visuels, en différents types de code machine. Les langages de programmation sont un type de langage informatique utilisé dans la programmation pour implémenter des algorithmes. + +Les langages de programmation sont souvent divisés en deux grandes catégories : +1. Les langages dits de "haut niveau" qui utilisent une syntaxe proche du langage humain. Le code source y est plus intelligible et il est compilé en code exécutable via un compilateur ou un interpréteur. Java et Python sont deux exemples de langages de "haut niveau". Ils sont plus simples d'utilisation et plus génériques. En contrepartie, ils peuvent apparaître moins optimisés. +2. Les langages de programmation de bas niveau fonctionnent plus étroitement avec le matériel et offrent un plus grand contrôle sur celui-ci. Ils interagissent directement avec le matériel. Deux exemples courants de langages de bas niveau sont le langage machine et le langage assembleur. Ces langages sont généralement plus rapides que ceux de haut niveau, mais cela se fait au prix d'une grande complexité et d'un manque de lisibilité. + +### [Paradigmes de programmation](/Programming_Languages/readme_fr.md#paradigmes-de-programmation) +Il existe également plusieurs *paradigmes de programmation* différents. Les paradigmes de programmation sont des façons ou styles différents selon lesquels un programme ou un langage de programmation peut être organisé. Chaque paradigme comporte certaines structures, fonctionnalités et opinions sur la manière dont les problèmes courants de programmation doivent être abordés. + +Les paradigmes de programmation *ne sont pas* des langages ou des outils. Vous ne pouvez pas "construire" quoi que ce soit avec un paradigme. Ce *sont* plutôt un ensemble d'idéaux et de lignes directrices sur lesquels de nombreuses personnes se sont mises d'accord, qu'elles ont suivis et sur lesquels elles ont développé. Les langages de programmation ne sont pas toujours liés à un paradigme particulier. Il existe des langages qui ont été conçus en tenant compte d'un certain paradigme et qui ont des fonctionnalités facilitant ce type de programmation plus que d'autres (Haskell et la programmation fonctionnelle en sont un bon exemple). Mais il existe également des langages "multi-paradigmes" dans lesquels vous pouvez adapter votre code pour correspondre à un certain paradigme ou à un autre (JavaScript et Python sont de bons exemples). + +## [Types de données](Data%20Types/readme_fr.md#types-de-données) +Un type de données, en programmation, est une classification qui spécifie quel type de valeur une variable peut avoir et quel type d'opérations mathématiques, relationnelles ou logiques peuvent lui être appliquées sans provoquer d'erreur. + +### [Types de données primitifs](Data%20Types/readme_fr.md#types-de-données-primitifs) +Les types de données primitifs sont les types de données les plus basiques dans un langage de programmation. Ils sont les blocs de construction de types de données plus complexes. Les types de données primitifs sont prédéfinis par le langage de programmation et sont nommés par un mot-clé réservé. + +### [Types de données primitifs courants](Data%20Types/readme_fr.md#types-de-données-primitifs-courants) +- [Entier](Data%20Types/readme_fr.md#entier) +- [Flottant](Data%20Types/readme_fr.md#flottant) +- [Booléen](Data%20Types/readme_fr.md#booléen) +- [Caractère](Data%20Types/readme_fr.md#caratère) +- [Chaîne de caractères](Data%20Types/readme_fr.md#chaîne-de-caractères) + +### [Types de données non primitifs](Data%20Types/readme_fr.md#types-de-données-non-primitifs) +Les types de données non primitifs sont également connus sous le nom de types de données de référence. Ils sont créés par le programmeur et ne sont pas définis par le langage de programmation. Les types de données non primitifs sont également appelés types de données composites car ils sont composés d'autres types. + +### [Types de données non primitifs courants](Data%20Types/readme_fr.md#types-de-données-non-primitifs) +- [Tableau](Data%20Types/readme_fr.md#tableau) +- [Structure](Data%20Types/readme_fr.md#structure) +- [Union](Data%20Types/readme_fr.md#union) +- [Pointeur](Data%20Types/readme_fr.md#pointeur) +- [Fonction](Data%20Types/readme_fr.md#fonction) +- [Classe](Data%20Types/readme_fr.md#classe) + +## [Instructions et fonctions](Statements%20and%20Functions/readme_fr.md) +En programmation informatique, une instruction est une unité syntaxique d'un langage de programmation impératif qui exprime une action à effectuer. Un programme écrit dans un tel langage est formé par une séquence d'une ou plusieurs instructions. Une instruction peut avoir des composants internes (par exemple, des expressions). +Il existe deux principaux types d'instructions dans tout langage de programmation nécessaires pour construire la logique d'un code. + +1. [Instructions conditionnelles](Statements%20and%20Functions/readme_fr.md#instructions-conditionnelles) + +Il existe principalement deux types d'instructions conditionnelles : +- if +- if-else +- switch case + +2. [Boucles](Statements%20and%20Functions/readme_fr.md#boucles) + +Il existe principalement trois types de boucles : +- boucle for +- boucle while +- boucle do-while (une variation de la boucle while) +- boucle do-until + +------------ +Une fonction est un bloc d'instructions qui effectue une tâche spécifique. Les fonctions acceptent des données, les traitent et renvoient un résultat ou les exécutent. Les fonctions sont principalement écrites pour soutenir le concept de réutilisabilité. Une fois qu'une fonction est écrite, elle peut être appelée facilement sans avoir à répéter le même code. + +Différents langages fonctionnels utilisent des syntaxes différentes pour écrire des fonctions. + +Lisez plus sur les fonctions [ici](Statements%20and%20Functions/readme.md#functions) + + +## [Structures de données](Data%20Structures/readme_fr.md) +En informatique, une structure de données est un format d'organisation, de gestion et de stockage des données qui permet un accès et une modification efficaces. Plus précisément, une structure de données est une collection de valeurs de données, les relations entre elles et les fonctions ou opérations qui peuvent être appliquées aux données. + +### [Recherche](Algorithms/Searching/readme.md) +La recherche est un algorithme permettant de trouver un certain élément cible à l'intérieur d'un conteneur. Les algorithmes de recherche sont conçus pour vérifier la présence d'un élément ou récupérer un élément à partir de toute structure de données où il est stocké. -1. Les langages dit de "haut-niveau" qui utilisent une syntaxe proche du langage humain. Le code source y est plus intelligible et il est compilé en code executable via un compilateur ou un interpréteur. Java et Python sont deux exemples de langages de "haut-niveau". Ils sont plus simple d'utilisation et plus génériques. En contre partie il peuvent apparaître moins optimisés. +### [Algorithmes basés sur les chaînes de caractères](Algorithms/String%20Based%20Algorithms/readme.md) +Les chaînes de caractères sont l'une des structures de données les plus utilisées et les plus importantes en programmation. Ce dépôt contient quelques-uns des algorithmes les plus utilisés qui aident à améliorer le temps de recherche, rendant notre code plus efficace. - +### [Recherche de graphes](Algorithms/Graph/readme.md) +La recherche de graphes est le processus de recherche à travers un graphe pour trouver un nœud particulier. Un graphe est une structure de données qui consiste en un ensemble fini (et éventuellement mutable) de sommets ou de nœuds ou de points, ainsi qu'un ensemble de paires non ordonnées de ces sommets pour un graphe non orienté ou un ensemble de paires ordonnées pour un graphe orienté. Ces paires sont connues sous le nom d'arêtes, arcs ou lignes pour un graphe non orienté, et sous le nom de flèches, arêtes dirigées, arcs dirigés ou lignes dirigées pour un graphe orienté. Les sommets peuvent faire partie de la structure du graphe ou être des entités externes représentées par des indices entiers ou des références. Les graphes sont l'une des structures de données les plus utiles pour de nombreuses applications du monde réel. Les graphes sont utilisés pour modéliser les relations par paires entre les objets. Par exemple, le réseau de routes aériennes est un graphe dans lequel les villes sont les sommets, et les routes aériennes sont les arêtes. Les graphes sont également utilisés pour représenter des réseaux. Internet peut être modélisé comme un graphe dans lequel les ordinateurs sont les sommets, et les liens entre les ordinateurs sont les arêtes. Les graphes sont également utilisés sur les réseaux sociaux comme LinkedIn et Facebook. Les graphes sont utilisés pour représenter de nombreuses applications du monde réel : réseaux informatiques, conception de circuits et planification aéronautique pour n'en nommer que quelques-unes. --> \ No newline at end of file diff --git a/Statements and Functions/readme_fr.md b/Statements and Functions/readme_fr.md new file mode 100644 index 00000000..5b8d254b --- /dev/null +++ b/Statements and Functions/readme_fr.md @@ -0,0 +1,356 @@ +# Conditional Statements + +Les instructions conditionnelles sont une partie très fondamentale de tout programme car elles aident à changer le flux de contrôle (qui est généralement de haut en bas) en fonction d'une condition donnée. + +Considérons un exemple où nous imprimons si un nombre donné est Pair ou Impair. + +Extrait de code : +* [Python](#python) +* [C++](#cpp) + +## Python +```python +if number % 2 == 0: + print ("Le nombre est pair") +else: + print ("Le nombre est impair") +``` +## CPP +```cpp +if (number % 2 == 0) + cout << "Le nombre est pair"; +else + cout << "Le nombre est impair"; +``` + +Maintenant, si le nombre entré est 5, l'instruction if vérifiera si le reste de 5 divisé par 2 est 0 ou non. Comme ce n'est pas 0, il saute les lignes de code dans l'instruction if et le flux de contrôle est déplacé vers la partie else et les lignes de code écrites sous celle-ci sont exécutées. + +**Types d'instructions conditionnelles** : +## 1. if - else if - else + **Voici un code qui imprime la note en fonction des marques.** + +* En C++ : +```cpp +if (marks >= 90) { + cout << "A"; +} +else if (marks >= 80) { + cout << "B"; +} +else if (marks >= 70) { + cout << "C"; +} +else if (marks >= 40) { + cout << "D"; +} +else { + cout << "F"; +} +``` + **En Python,** **`else if` est écrit comme `elif`.** + +* En Python : + ```python +if marks >= 90: + print ("A") +elif marks >= 80: + print ("B") +elif marks >= 70: + print ("C") +elif marks >= 40: + print ("D") +else: + print ("F") +``` + +## 2. instructions switch case + +Dans switch case, nous prenons une valeur de l'utilisateur qui est généralement un entier ou de type de données caractère en fonction de laquelle le cas correspondant est exécuté. + +Il est utilisé à la place de l'instruction if si les branches de prise de décision sont indépendantes les unes des autres. + +*Supposons qu'un joueur choisit une couleur pour jouer au Ludo, et en fonction de ce qu'il entre, c'est-à-dire R, B, Y et G, il obtient respectivement Rouge, Bleu, Jaune et Vert. Dans le cas où il entre une autre lettre, le code renvoie un message d'erreur car aucune couleur n'est associée à cette lettre.* + +* Un code en C++ pour implémenter la même chose : + +```cpp +switch (alphabet) { + case 'R': + cout << "Rouge"; + break; + case 'B': + cout << "Bleu"; + break; + case 'Y': + cout << "Jaune"; + break; + case 'G': + cout << "Vert"; + break; + default: + cout << "Aucune autre couleur n'existe"; + } +``` +* *Remarque : Python n'a pas d'instructions switch case.* + +## 3. Instructions if-else imbriquées : + +L'instruction if...else imbriquée est utilisée lorsqu'un programme nécessite plus d'une expression de test. Elle est également appelée instruction de sélection multiple. Lorsqu'une série de décisions est impliquée dans une instruction, nous utilisons l'instruction if-else sous forme imbriquée. Les instructions if-else imbriquées peuvent être utiles lorsque nous avons plusieurs sources d'expression et en fonction de la valeur spécifique, nous devons vérifier les conditions imbriquées. + +Il est recommandé pour une meilleure pratique de codage d'éviter d'utiliser l'instruction if-else imbriquée car elle peut se transformer en une situation de bouillonnement conditionnel, il est préférable d'utiliser le switch case pour une meilleure gestion des conditions. + +* Syntaxe de if-else imbriqué en C++ : + +```cpp +if(condition_1){ + if(condition_2){ + if(condition_3){ + statement_1; + } + else{ + statement_2; + } + } + else{ + statement_3; + } +} +else{ + statement_4; +} +``` + +* Il est considéré comme une meilleure pratique de codage d'utiliser `if...elif...elif...else` en Python + +------------ + +# Opérateurs ternaires + +Il existe également un autre moyen d'obtenir la fonctionnalité de if-else avec une syntaxe plus compacte et concise. +Oui, nous parlons des opérateurs ternaires. + +Prenons un exemple typique d'un if-else pour vérifier si un nombre est pair ou impair. + +Méthode traditionnelle : + + if(num%2==0): + print("c'est un nombre pair") + else: + print("c'est un nombre impair") + +Maintenant en utilisant les opérateurs ternaires : +* [Exemple Python](#exemple-python) +* [Exemple C++](#exemple-cpp) + +## Exemple Python +```python +print("c'est un nombre pair") if num%2==0 else print("c'est un nombre impair") +``` +__Remarque__: En python, cela s'appelle une instruction if-else abrégée. + +## Exemple CPP +```cpp +(num%2==0)?cout<<"c'est un nombre pair":cout<<"c'est un nombre impair"; +``` + +La façon dont cela fonctionne est la suivante : d'abord, il y a une condition que nous voulons vérifier qui est entre parenthèses suivie d'un point d'interrogation, l'instruction qui vient après le point d'interrogation est l'instruction qui sera exécutée si la condition de vérification est satisfaite, c'est-à-dire si elle est vraie, sinon elle exécutera l'instruction qui est après les deux-points. + +# Boucles + +Les boucles sont utilisées pour exécuter un bloc de code autant de fois que nous le souhaitons sans écrire le même code encore et encore. Le flux de contrôle sort de la boucle lorsque la condition fournie est fausse ou qu'une instruction `break` est utilisée. + +Prenons un exemple où nous imprimons tous les nombres pairs jusqu'à 10. + +#### **Il existe deux types d'instructions de boucle** : +## 1. instruction for +**Prenons un exemple où nous imprimons tous les nombres pairs jusqu'à 10.** + +* En C++ : +```cpp +for (int i = 2; i <= 10; i+=2) { + cout << i << "\n"; +} +``` +`int i = 2` initialise la valeur de i à 2 + +et `i += 2` continue d'incrémenter la valeur de i de 2 + +jusqu'à ce que `i <= 10` devienne `faux` + +
+* En Python : + ```python +for i in range(2, 11, 2): + print (i) +``` + +***Sortie : +2 +4 +6 +8 +10** + +La fonction range prend trois paramètres - le premier paramètre est la **valeur de départ**, le deuxième paramètre est la **valeur de fin + 1**, et le troisième paramètre est la **valeur d'incrément**. + +Ici, `range(2, 11, 2)` indique au programme qu'il doit exécuter la boucle pour toutes les valeurs de i entre 2 et (11-1) et continuer d'incrémenter la valeur de i de 2. + +## 2. instructions while / do while + +Une instruction while vérifie toujours si la condition fournie est Vraie ou Fausse au début de la boucle et dans le cas où elle est Vraie, le bloc de code dans la boucle est exécuté. Sinon, la boucle est terminée. Comme elle vérifie toujours la condition au début, elle est également appelée boucle contrôlée par entrée. + +* Un code en C++ pour implémenter la même chose : +```cpp +int i = 2; +while (i <= 10) { + cout << i << "\n"; + i += 2; +} +``` + +* En Python : + ```python +i = 2 +while i <= 10: + print (i) + i += 2 +``` + +Dans les codes ci-dessus, la boucle while s'exécute jusqu'à ce que la valeur de i soit 10. + +Dans une boucle do while, la validité de la condition est vérifiée à la fin de la boucle. Par conséquent, le code s'exécute au moins une fois même si la condition fournie est Fausse. Également connue sous le nom de boucle contrôlée par sortie car la condition est vérifiée après l'exécution du corps de la boucle. + +Si je modifie le code ci-dessus en une boucle do while, il imprimera les nombres pairs jusqu'à 12 car il vérifie la condition après l'exécution de la boucle. + +Extrait de code pour do-while : + +```cpp +int i = 2; +do { + cout << i << "\n"; + i += 2; +}while (i <= 10); +``` + +**Sortie : +2 +4 +6 +8 +10 +12** + +* *Remarque : En Python, nous n'avons pas de boucles do-while.* +------------ + +# Fonctions + +En programmation, nous avons souvent un bloc de code qui effectue une tâche spécifique et de nombreuses fois dans le programme, nous pouvons avoir besoin d'utiliser exactement le même morceau de code. Dans ce cas, pour éliminer l'écriture répétée du même code encore et encore et également pour maintenir la lisibilité du code, nous définissons des fonctions pour cela. + +* Une fonction peut être réutilisée plusieurs fois. +* Vous pouvez envoyer des données à une fonction qu'elle utilise pour effectuer une tâche. +* Une fonction renvoie généralement une valeur à la fonction principale qui est ensuite utilisée pour effectuer d'autres opérations. +* Chaque langage de programmation a des fonctions intégrées que vous pouvez utiliser. +* Vous pouvez également écrire des fonctions par vous-même. +* Lorsque vous appelez une fonction, le flux de contrôle passe de la fonction principale à la fonction qui est **toujours exécutée de haut en bas**. +* Une fonction peut appeler une autre fonction ou même s'appeler elle-même (connue sous le nom de fonctions récursives). +* Une fonction de retour prend le flux de contrôle hors de la fonction et revient à la fonction principale. +* Les fonctions rendent le code modulaire. Un gros fichier contenant de nombreuses lignes de code devient simple à lire si le code est divisé en fonctions. +* Les fonctions fournissent une abstraction. Nous pouvons utiliser des fonctions de bibliothèque sans nous soucier de leur fonctionnement interne. + +------------ + +Considérons une situation où je veux imprimer tous les nombres premiers entre 1 et 100 : + +Nous pouvons donc écrire une fonction pour vérifier si un nombre est premier ou non. Elle renvoie une valeur de type booléen en fonction de laquelle nous décidons si le nombre doit être imprimé ou non. + +Extrait de code pour la fonction `isPrime` : + +```python +def isPrime (number: int) -> bool: + factors = 0 + for i in range (2, (number // 2) + 1): + if number % i == 0: + factors += 1 + if factors == 0: + return True + return False +``` +**

  • La ligne la plus haute d'une fonction est appelée en-tête de fonction.
    • ** + +Dans, `def isPrime (number: int) -> bool:` , +les paramètres entre parenthèses indiquent au programme combien de paramètres cette fonction acceptera et comment ils sont appelés. + +Dans ce cas, l'en-tête de fonction indique au programme qu'il doit passer un paramètre à la fonction `isPrime` et que ce paramètre/variable sera référé comme `number` à l'intérieur de la fonction. +
    + +Utilisons maintenant cette fonction pour imprimer les nombres premiers jusqu'à 100 : +```python +for i in range(1, 101): + if isPrime(i): + print (i) +``` + +* Ce code utilise la fonction `isPrime` pour déterminer si le nombre est premier ou non pour chaque valeur de i de 1 à 100 et imprime uniquement les nombres premiers. +* Cela augmente non seulement la lisibilité du programme principal, mais la fonction isPrime peut également être utilisée par d'autres programmes. + +------------ + +## Types de fonctions + +* Fonction définie par l'utilisateur : +Les fonctions définies par l'utilisateur sont des blocs de code définis par l'utilisateur/client spécialement personnalisés pour réduire la complexité des grands programmes. Elles sont également communément appelées "fonctions sur mesure" qui sont construites uniquement pour répondre au problème spécifique auquel l'utilisateur est confronté. Une fois que vous avez défini une fonction, vous pouvez l'appeler de la même manière que les fonctions intégrées. + +* Fonction de bibliothèque : +Les fonctions de bibliothèque sont également appelées "fonctions intégrées" qui sont regroupées et placées dans un emplacement commun appelé bibliothèque. Chaque fonction ici effectue une opération spécifique. Nous pouvons utiliser ces fonctions de bibliothèque pour obtenir la sortie prédéfinie. Ces fonctions font partie d'un package de compilateur qui est déjà défini. Les fonctions intégrées nous donnent un avantage car nous pouvons les utiliser directement sans nous soucier de les définir. Alors que dans la fonction définie par l'utilisateur, nous devons déclarer et définir une fonction avant de les utiliser. + +------------ + +## Passer des paramètres aux fonctions + +### 1. Passage par valeur +Dans cette méthode de passage de paramètres, les valeurs des paramètres réels sont copiées dans les paramètres formels de la fonction et les deux types de paramètres sont stockés dans des emplacements mémoire différents. Ainsi, toute modification apportée à l'intérieur des fonctions n'est pas reflétée dans les paramètres réels de l'appelant. + +### 2. Passage par référence +Les paramètres réels et formels se réfèrent tous deux aux mêmes emplacements. Par conséquent, toute modification apportée à l'intérieur de la fonction est réellement reflétée dans les paramètres réels de l'appelant. + +------------ + +## Surcharge de fonction +Certains langages de programmation permettent la surcharge de fonction, qui est la capacité de créer plusieurs fonctions avec le même nom mais avec des implémentations différentes. Par exemple, C++ vous permet de spécifier plus d'une fonction du même nom dans le même champ. La détermination de la fonction à utiliser pour un appel particulier est résolue au moment de la compilation et est basée sur le nombre de paramètres que la fonction prend ou le type de données des paramètres. + +------------ + +# Fonction Lambda + +Une fonction lambda est une petite fonction *anonyme* ou également connue sous le nom de fonction *inconnue*, ce qui signifie que la fonction n'a pas de nom. Elles réduisent la taille du code et permettent au programmeur de développer des logiciels plus rapidement. + +* Syntaxe : +```python +lambda arguments: expression +``` + +**Caractéristiques de la fonction lambda :** + +* La fonction lambda prend un nombre illimité d'arguments mais n'a qu'une seule expression. Cette expression renvoie le résultat lorsque la fonction lambda est appelée. +* Comme elle ne contient qu'une seule expression qui renvoie le résultat par défaut, elle ne nécessite pas l'instruction *return*. + +* Un exemple de fonction lambda : +```python +result = lambda x: x + 10 +print(result(5)) +``` + +**Sortie : +15** + +**Ici**, +* *lambda* est le mot-clé, +* x est un argument, et +* x + 10 est l'expression lambda. + +**Différence entre les fonctions lambda et les fonctions définies par l'utilisateur** + +Les fonctions lambda sont des fonctions anonymes, ce qui signifie qu'une fonction est définie à l'aide d'un mot-clé *lambda* et sans nom, tandis qu'une fonction définie par l'utilisateur est définie à l'aide d'un mot-clé *def* et a un nom de fonction. + +---------