mirror of
https://github.com/trekhleb/javascript-algorithms.git
synced 2025-12-19 08:59:05 +08:00
Chore(math-translation-FR-fr): a pack of translations for the math section (#558)
* chore(factorial): translation fr-FR * feat(math-translation-fr-FR): fast powering * feat(math-translation-fr-FR): fibonacci numbers * chore(math-translation-fr-FR): bits * chore(math-translation-fr-FR): complex number * chore(math-translation-fr-FR): euclidean algorithm * chore(math-translation-fr-FR): fibonacci number * chore(math-translation-fr-FR): fourier transform * chore(math-translation-fr-FR): fourier transform WIP * chore(math-translation-fr-FR): fourier transform done * chore(math-translation-fr-FR): fourier transform in menu
This commit is contained in:
Loïc TRUCHOT
295
src/algorithms/math/bits/README.fr-FR.md
Normal file
295
src/algorithms/math/bits/README.fr-FR.md
Normal file
@@ -0,0 +1,295 @@
|
||||
# Manipulation de bits
|
||||
|
||||
_Read this in other languages:_
|
||||
[english](README.md).
|
||||
|
||||
#### Vérifier un bit (_get_)
|
||||
|
||||
Cette méthode décale le bit correspondant (_bit shifting_) à la position zéro.
|
||||
Ensuite, nous exécutons l'opération `AND` avec un masque comme `0001`.
|
||||
Cela efface tous les bits du nombre original sauf le correspondant.
|
||||
Si le bit pertinent est `1`, le résultat est `1`, sinon le résultat est `0`.
|
||||
|
||||
> Voir [getBit.js](getBit.js) pour plus de détails.
|
||||
|
||||
#### Mettre un bit à 1(_set_)
|
||||
|
||||
Cette méthode met un bit à `1` en fonction d'un rang (`bitPosition`),
|
||||
créant ainsi une valeur qui ressemble à `00100`.
|
||||
Ensuite, nous effectuons l'opération `OU` qui met un bit spécifique
|
||||
en `1` sans affecter les autres bits du nombre.
|
||||
|
||||
> Voir [setBit.js](setBit.js) pour plus de détails.
|
||||
|
||||
#### Mettre un bit à 0 (_clear_)
|
||||
|
||||
Cette méthode met un bit à `1` en fonction d'un rang (`bitPosition`),
|
||||
créant ainsi une valeur qui ressemble à `00100`.
|
||||
Puis on inverse ce masque de bits pour obtenir un nombre ressemblant à `11011`.
|
||||
Enfin, l'opération `AND` est appliquée au nombre et au masque.
|
||||
Cette opération annule le bit.
|
||||
|
||||
> Voir [clearBit.js](clearBit.js) pour plus de détails.
|
||||
|
||||
#### Mettre à jour un Bit (_update_)
|
||||
|
||||
Cette méthode est une combinaison de l'"annulation de bit"
|
||||
et du "forçage de bit".
|
||||
|
||||
> Voir [updateBit.js](updateBit.js) pour plus de détails.
|
||||
|
||||
#### Vérifier si un nombre est pair (_isEven_)
|
||||
|
||||
Cette méthode détermine si un nombre donné est pair.
|
||||
Elle s'appuie sur le fait que les nombres impairs ont leur dernier
|
||||
bit droit à `1`.
|
||||
|
||||
```text
|
||||
Nombre: 5 = 0b0101
|
||||
isEven: false
|
||||
|
||||
Nombre: 4 = 0b0100
|
||||
isEven: true
|
||||
```
|
||||
|
||||
> Voir [isEven.js](isEven.js) pour plus de détails.
|
||||
|
||||
#### Vérifier si un nombre est positif (_isPositive_)
|
||||
|
||||
Cette méthode détermine un le nombre donné est positif.
|
||||
Elle s'appuie sur le fait que tous les nombres positifs
|
||||
ont leur bit le plus à gauche à `0`.
|
||||
Cependant, si le nombre fourni est zéro
|
||||
ou zéro négatif, il doit toujours renvoyer `false`.
|
||||
|
||||
```text
|
||||
Nombre: 1 = 0b0001
|
||||
isPositive: true
|
||||
|
||||
Nombre: -1 = -0b0001
|
||||
isPositive: false
|
||||
```
|
||||
|
||||
> Voir [isPositive.js](isPositive.js) pour plus de détails.
|
||||
|
||||
#### Multiplier par deux
|
||||
|
||||
Cette méthode décale un nombre donné d'un bit vers la gauche.
|
||||
Ainsi, toutes les composantes du nombre binaire (en puissances de deux) sont
|
||||
multipliées par deux et donc le nombre lui-même est
|
||||
multiplié par deux.
|
||||
|
||||
```
|
||||
Avant le décalage
|
||||
Nombre: 0b0101 = 5
|
||||
Puissances de deux: 0 + 2^2 + 0 + 2^0
|
||||
|
||||
Après le décalage
|
||||
Nombre: 0b1010 = 10
|
||||
Puissances de deux: 2^3 + 0 + 2^1 + 0
|
||||
```
|
||||
|
||||
> Voir [multiplyByTwo.js](multiplyByTwo.js) pour plus de détails.
|
||||
|
||||
#### Diviser par deux
|
||||
|
||||
Cette méthode décale un nombre donné d'un bit vers la droite.
|
||||
Ainsi, toutes les composantes du nombre binaire (en puissances de deux) sont
|
||||
divisées par deux et donc le nombre lui-même est
|
||||
divisé par deux, sans reste.
|
||||
|
||||
```
|
||||
Avant le décalage
|
||||
Nombre: 0b0101 = 5
|
||||
Puissances de deux: 0 + 2^2 + 0 + 2^0
|
||||
|
||||
Après le décalage
|
||||
Nombre: 0b0010 = 2
|
||||
Puissances de deux: 0 + 0 + 2^1 + 0
|
||||
```
|
||||
|
||||
> Voir [divideByTwo.js](divideByTwo.js) pour plus de détails.
|
||||
|
||||
#### Inverser le signe (_Switch Sign_)
|
||||
|
||||
Cette méthode rend positifs les nombres négatifs, et vice-versa.
|
||||
Pour ce faire, elle s'appuie sur l'approche "Complément à deux",
|
||||
qui inverse tous les bits du nombre et y ajoute 1.
|
||||
|
||||
```
|
||||
1101 -3
|
||||
1110 -2
|
||||
1111 -1
|
||||
0000 0
|
||||
0001 1
|
||||
0010 2
|
||||
0011 3
|
||||
```
|
||||
|
||||
> Voir [switchSign.js](switchSign.js) pour plus de détails.
|
||||
|
||||
#### Multiplier deux nombres signés
|
||||
|
||||
Cette méthode multiplie deux nombres entiers signés
|
||||
à l'aide d'opérateurs bit à bit.
|
||||
Cette méthode est basée sur les faits suivants:
|
||||
|
||||
```text
|
||||
a * b peut être écrit sous les formes suivantes:
|
||||
0 si a est zero ou b est zero ou les deux sont zero
|
||||
2a * (b/2) si b est pair
|
||||
2a * (b - 1)/2 + a si b est impair et positif
|
||||
2a * (b + 1)/2 - a si b est impair et negatif
|
||||
```
|
||||
|
||||
L'avantage de cette approche est qu'à chaque étape de la récursion
|
||||
l'un des opérandes est réduit à la moitié de sa valeur d'origine.
|
||||
Par conséquent, la complexité d'exécution est `O(log(b))`
|
||||
où `b` est l'opérande qui se réduit de moitié à chaque récursion.
|
||||
|
||||
> Voir [multiply.js](multiply.js) pour plus de détails.
|
||||
|
||||
#### Multiplier deux nombres positifs
|
||||
|
||||
Cette méthode multiplie deux nombres entiers à l'aide d'opérateurs bit à bit.
|
||||
Cette méthode s'appuie sur le fait que "Chaque nombre peut être lu
|
||||
comme une somme de puissances de 2".
|
||||
|
||||
L'idée principale de la multiplication bit à bit
|
||||
est que chaque nombre peut être divisé en somme des puissances de deux:
|
||||
|
||||
Ainsi
|
||||
|
||||
```text
|
||||
19 = 2^4 + 2^1 + 2^0
|
||||
```
|
||||
|
||||
Donc multiplier `x` par `19` est equivalent à :
|
||||
|
||||
```text
|
||||
x * 19 = x * 2^4 + x * 2^1 + x * 2^0
|
||||
```
|
||||
|
||||
Nous devons maintenant nous rappeler que `x * 2 ^ 4` équivaut
|
||||
à déplacer`x` vers la gauche par `4` bits (`x << 4`).
|
||||
|
||||
> Voir [multiplyUnsigned.js](multiplyUnsigned.js) pour plus de détails.
|
||||
|
||||
#### Compter les bits à 1
|
||||
|
||||
This method counts the number of set bits in a number using bitwise operators.
|
||||
The main idea is that we shift the number right by one bit at a time and check
|
||||
the result of `&` operation that is `1` if bit is set and `0` otherwise.
|
||||
|
||||
Cette méthode décompte les bits à `1` d'un nombre
|
||||
à l'aide d'opérateurs bit à bit.
|
||||
L'idée principale est de décaler le nombre vers la droite, un bit à la fois,
|
||||
et de vérifier le résultat de l'opération `&` :
|
||||
`1` si le bit est défini et `0` dans le cas contraire.
|
||||
|
||||
```text
|
||||
Nombre: 5 = 0b0101
|
||||
Décompte des bits à 1 = 2
|
||||
```
|
||||
|
||||
> Voir [countSetBits.js](countSetBits.js) pour plus de détails.
|
||||
|
||||
#### Compter les bits nécessaire pour remplacer un nombre
|
||||
|
||||
This methods outputs the number of bits required to convert one number to another.
|
||||
This makes use of property that when numbers are `XOR`-ed the result will be number
|
||||
of different bits.
|
||||
|
||||
Cette méthode retourne le nombre de bits requis
|
||||
pour convertir un nombre en un autre.
|
||||
Elle repose sur la propriété suivante:
|
||||
lorsque les nombres sont évalués via `XOR`, le résultat est le nombre
|
||||
de bits différents entre les deux.
|
||||
|
||||
```
|
||||
5 = 0b0101
|
||||
1 = 0b0001
|
||||
Nombre de bits pour le remplacement: 1
|
||||
```
|
||||
|
||||
> Voir [bitsDiff.js](bitsDiff.js) pour plus de détails.
|
||||
|
||||
#### Calculer les bits significatifs d'un nombre
|
||||
|
||||
Pour connaître les bits significatifs d'un nombre,
|
||||
on peut décaler `1` d'un bit à gauche plusieurs fois d'affilée
|
||||
jusqu'à ce que ce nombre soit plus grand que le nombre à comparer.
|
||||
|
||||
```
|
||||
5 = 0b0101
|
||||
Décompte des bits significatifs: 3
|
||||
On décale 1 quatre fois pour dépasser 5.
|
||||
```
|
||||
|
||||
> Voir [bitLength.js](bitLength.js) pour plus de détails.
|
||||
|
||||
#### Vérifier si un nombre est une puissance de 2
|
||||
|
||||
Cette méthode vérifie si un nombre donné est une puissance de deux.
|
||||
Elle s'appuie sur la propriété suivante.
|
||||
Disons que `powerNumber` est une puissance de deux (c'est-à-dire 2, 4, 8, 16 etc.).
|
||||
Si nous faisons l'opération `&` entre `powerNumber` et `powerNumber - 1`,
|
||||
elle retournera`0` (dans le cas où le nombre est une puissance de deux).
|
||||
|
||||
```
|
||||
Nombre: 4 = 0b0100
|
||||
Nombre: 3 = (4 - 1) = 0b0011
|
||||
4 & 3 = 0b0100 & 0b0011 = 0b0000 <-- Égal à zéro, car c'est une puissance de 2.
|
||||
|
||||
Nombre: 10 = 0b01010
|
||||
Nombre: 9 = (10 - 1) = 0b01001
|
||||
10 & 9 = 0b01010 & 0b01001 = 0b01000 <-- Différent de 0, donc n'est pas une puissance de 2.
|
||||
```
|
||||
|
||||
> Voir [isPowerOfTwo.js](isPowerOfTwo.js) pour plus de détails.
|
||||
|
||||
#### Additionneur complet
|
||||
|
||||
Cette méthode ajoute deux nombres entiers à l'aide d'opérateurs bit à bit.
|
||||
|
||||
Elle implémente un [additionneur](https://fr.wikipedia.org/wiki/Additionneur)
|
||||
simulant un circuit électronique logique,
|
||||
pour additionner deux entiers de 32 bits,
|
||||
sous la forme « complément à deux ».
|
||||
Elle utilise la logique booléenne pour couvrir tous les cas possibles
|
||||
d'ajout de deux bits donnés:
|
||||
avec et sans retenue de l'ajout de l'étape précédente la moins significative.
|
||||
|
||||
Légende:
|
||||
|
||||
- `A`: Nombre `A`
|
||||
- `B`: Nombre `B`
|
||||
- `ai`: ième bit du nombre `A`
|
||||
- `bi`: ième bit du nombre `B`
|
||||
- `carryIn`: un bit retenu de la précédente étape la moins significative
|
||||
- `carryOut`: un bit retenu pour la prochaine étape la plus significative
|
||||
- `bitSum`: La somme de `ai`, `bi`, et `carryIn`
|
||||
- `resultBin`: Le résultat complet de l'ajout de l'étape actuelle avec toutes les étapes moins significatives (en binaire)
|
||||
- `resultDec`: Le résultat complet de l'ajout de l'étape actuelle avec toutes les étapes moins significatives (en decimal)
|
||||
|
||||
```
|
||||
A = 3: 011
|
||||
B = 6: 110
|
||||
┌──────┬────┬────┬───────┬────────┬───────┬────────┬─────────┐
|
||||
│ bit │ ai │ bi │ carryIn │ carryOut │ bitSum │ resultBin │ resultDec │
|
||||
├──────┼────┼────┼───────┼────────┼───────┼────────┼─────────┤
|
||||
│ 0 │ 1 │ 0 │ 0 │ 0 │ 1 │ 1 │ 1 │
|
||||
│ 1 │ 1 │ 1 │ 0 │ 1 │ 0 │ 01 │ 1 │
|
||||
│ 2 │ 0 │ 1 │ 1 │ 1 │ 0 │ 001 │ 1 │
|
||||
│ 3 │ 0 │ 0 │ 1 │ 0 │ 1 │ 1001 │ 9 │
|
||||
└──────┴────┴────┴───────┴────────┴───────┴────────┴─────────┘
|
||||
```
|
||||
|
||||
> Voir [fullAdder.js](fullAdder.js) pour plus de détails.
|
||||
> Voir [Full Adder on YouTube](https://www.youtube.com/watch?v=wvJc9CZcvBc&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8).
|
||||
|
||||
## Références
|
||||
|
||||
- [Bit Manipulation on YouTube](https://www.youtube.com/watch?v=NLKQEOgBAnw&t=0s&index=28&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
|
||||
- [Negative Numbers in binary on YouTube](https://www.youtube.com/watch?v=4qH4unVtJkE&t=0s&index=30&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
|
||||
- [Bit Hacks on stanford.edu](https://graphics.stanford.edu/~seander/bithacks.html)
|
||||
@@ -1,10 +1,13 @@
|
||||
# Bit Manipulation
|
||||
|
||||
_Read this in other languages:_
|
||||
[français](README.fr-FR.md).
|
||||
|
||||
#### Get Bit
|
||||
|
||||
This method shifts the relevant bit to the zeroth position.
|
||||
Then we perform `AND` operation with one which has bit
|
||||
pattern like `0001`. This clears all bits from the original
|
||||
pattern like `0001`. This clears all bits from the original
|
||||
number except the relevant one. If the relevant bit is one,
|
||||
the result is `1`, otherwise the result is `0`.
|
||||
|
||||
@@ -53,7 +56,7 @@ isEven: true
|
||||
|
||||
#### isPositive
|
||||
|
||||
This method determines if the number is positive. It is based on the fact that all positive
|
||||
This method determines if the number is positive. It is based on the fact that all positive
|
||||
numbers have their leftmost bit to be set to `0`. However, if the number provided is zero
|
||||
or negative zero, it should still return `false`.
|
||||
|
||||
@@ -230,12 +233,13 @@ Number: 9 = (10 - 1) = 0b01001
|
||||
|
||||
This method adds up two integer numbers using bitwise operators.
|
||||
|
||||
It implements [full adder](https://en.wikipedia.org/wiki/Adder_(electronics))
|
||||
It implements [full adder](<https://en.wikipedia.org/wiki/Adder_(electronics)>)
|
||||
electronics circuit logic to sum two 32-bit integers in two's complement format.
|
||||
It's using the boolean logic to cover all possible cases of adding two input bits:
|
||||
with and without a "carry bit" from adding the previous less-significant stage.
|
||||
|
||||
Legend:
|
||||
|
||||
- `A`: Number `A`
|
||||
- `B`: Number `B`
|
||||
- `ai`: ith bit of number `A`
|
||||
|
||||
Reference in New Issue
Block a user