
## Problème

Rédigez une fonction qui prends un nombre entier positif en argument et qui retourne le prochain nombre supérieur qui peut être formé en réarrangeant ses chiffres.

### Exemple

```text
12 ==> 21
513 ==> 531
2017 ==> 2071
```

Si le nombre peut être réarrangé pour former un nombre plus grand, retournez `-1`.

```text
59 ==> -1
111 ==> -1
531 ==> -1
```

## Solution

Le but est d'identifier le chiffre le plus à droite qui est plus petit que son chiffre adjacent, puis de trouver le plus petit chiffre plus grand que ce chiffre et de les échanger.

Pour cela, nous allons convertir le nombre en chaîne de caractères et le diviser en un tableau de chiffres individuels à l'aide de `Array.from(n.toString()).map(Number)`.

&nbsp;

Nous initialisons une variable `i` à l'avant-dernier index du tableau de chiffres (`digits.length - 2`). Nous allons comparer les chiffres à `i` et `i + 1` pour trouver la première paire de chiffres qui viole l'ordre décroissant.

Nous pouvons maintenant utiliser une boucle `while` qui s'exécute tant que `i` est supérieur ou égal à `0` et que le chiffre à la position `i` est supérieur ou égal au chiffre à la position `i + 1`. Cette boucle trouve le chiffre le plus à droite étant plus petit que son chiffre adjacent.

Si `i` devient `-1`, cela signifie que les chiffres sont dans l'ordre décroissant et qu'il n'y a pas de nombre plus grand qui peut être formé. Dans ce cas, la fonction retourne `-1`.

&nbsp;

Ensuite, nous initialisons une variable `j` à l'index le plus à droite du tableau de chiffres (`digits.length - 1`). Cette variable sera utilisée pour trouver le plus petit chiffre plus grand que le chiffre à l'index `i`.

Nous pouvons maintenant utiliser une nouvelle boucle `while` qui s'exécute tant que le chiffre à la position `j` est inférieur ou égal au chiffre à la position `i`. Cette boucle trouve le plus petit chiffre plus grand que le chiffre à la position `i`.

&nbsp;

Il suffit d'échanger les chiffres à la position `i` et `j` en utilisant l'assignation par décomposition : `[digits[i], digits[j]] = [digits[j], digits[i]]`.

A présent, nous séparons le tableau de chiffre depuis l'index `i + 1` jusqu'à la fin du tableau en utilisant `splice(i + 1)`. Nous inverserons le tableau résultant en utilisant `reverse()` et nous assignerons le résultat à la variable `reversed`. Cette étape garantit que les chiffres après l'index `i` sont dans l'ordre croissant.

&nbsp;

Enfin, nous pouvons ajouter les éléments du tableau inversé au tableau de chiffres en utilisant `push(...reversed)`. Puis pour renvoyer un nombre entier, nous joignons les éléments du tableau de chiffres en une chaîne de caractères en utilisant `Number(digits.join(''))`.

```typescript
export function nextBigger(n: number): number {
  const digits = Array.from(n.toString()).map(Number);
  
  let i = digits.length - 2;
  while (i >= 0 && digits[i] >= digits[i + 1]) i--;
  if (i === -1) return -1;
  
  let j = digits.length - 1;
  while (digits[j] <= digits[i]) j--;
    
  [digits[i], digits[j]] = [digits[j], digits[i]];
  const reversed = digits.splice(i + 1).reverse();
  digits.push(...reversed);
  
  return Number(digits.join(''));
}
```


Prochain nombre supérieur


## Problème

La procédure de tirage de cartes est la suivante :

1. Nous tirons la carte du dessus du paquet.
1. Nous prenons la carte suivante, et nous la plaçons en dessous du paquet.
1. Nous répétons les étapes 1 et 2 jusqu'à ce qu'il n'y ait plus de cartes dans le paquet.

Prenons un petit paquet de quatre cartes — nommées A, B, C, D — comme exemple :

- L'ordre du paquet est A-B-C-D au début, la carte A est au dessus et D en dessous.
- A est tirée. Le paquet est maintenant B-C-D.
- B est placée en dessous du paquet. Le paquet est maintenant C-D-B.
- C est tirée. Le paquet est maintenant D-B.
- D est placée en dessous du paquet. Le paquet est maintenant B-D.
- B est tirée. Le paquet est maintenant D.
- D est tirée.

L'ordre des cartes tirées est A-C-B-D.

&nbsp;

&nbsp;

Cette fois-ci, vous devez écrire une fonction qui prends les cartes tirées en argument et qui retourne le paquet de cartes originel.

Chaque carte est représentée par une chaîne de caractères de deux caractères : la valeur de la carte et sa couleur.

```text
AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC for the Clubs (Trèfles)
AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD for the Diamonds (Carreaux)
AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH for the Hearts (Cœurs)
AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS for the Spades (Piques)
```

### Exemple

```typescript
const deck = ["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];

prepareDeck(deck); // ["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"];
```

## Solution

Nous allons utiliser un tableau `deck` pour représenter le paquet de cartes originel.

Ensuite, nous allons utiliser une boucle `while` pour effectuer la logique inverse du tirage tant que le tirage contient des cartes.

Nous allons utiliser la méthode `Array.pop` pour retirer la dernière carte du paquet et la méthode `Array.unshift` pour ajouter cette carte au début du paquet.

Nous allons ensuite insérer la dernière carte du tirage récupérée au début du paquet avec les mêmes méthodes `Array.pop` et `Array.unshift`.

Lorsque le tirage est vide, nous retournons le paquet.

```typescript
export const prepareDeck = (drawnCards: string[]): string[] => {
 const deck: string[] = [];
  
  while (drawnCards.length > 0) {     
    const endCard = deck.pop();
    if(endCard) {
      deck.unshift(endCard);
    }
    
    const drawnCard = drawnCards.pop();
    if (drawnCard) {
      deck.unshift(drawnCard);
    }
  }
  
 return deck;
};
```


Inverseur du Tireur de cartes


## Problème

La procédure de tirage de cartes est la suivante :

1. Nous tirons la carte du dessus du paquet.
1. Nous prenons la carte suivante, et nous la plaçons en dessous du paquet.
1. Nous répétons les étapes 1 et 2 jusqu'à ce qu'il n'y ait plus de cartes dans le paquet.

Prenons un petit paquet de quatre cartes — nommées A, B, C, D — comme exemple :

- L'ordre du paquet est A-B-C-D au début, la carte A est au dessus et D en dessous.
- A est tirée. Le paquet est maintenant B-C-D.
- B est placée en dessous du paquet. Le paquet est maintenant C-D-B.
- C est tirée. Le paquet est maintenant D-B.
- D est placée en dessous du paquet. Le paquet est maintenant B-D.
- B est tirée. Le paquet est maintenant D.
- D est tirée.

L'ordre des cartes tirées est A-C-B-D.

&nbsp;

&nbsp;

Écrivez une fonction qui prends un paquet de cartes en argument, et qui retourne les cartes tirées en suivant la procédure.

Chaque carte est représentée par une chaîne de caractères de deux caractères : la valeur de la carte et sa couleur.

```text
AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC for the Clubs (Trèfles)
AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD for the Diamonds (Carreaux)
AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH for the Hearts (Cœurs)
AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS for the Spades (Piques)
```

### Exemple

```typescript
const deck = ["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"];

draw(deck); // ["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];
```

## Solution

Nous allons utiliser un tableau `drawnCards` pour représenter les cartes tirées.

Ensuite, nous allons utiliser une boucle `while` pour effectuer la logique de tirage tant que le paquet contient des cartes.

Nous allons utiliser la méthode `Array.shift` pour retirer les deux premières cartes du paquet. La première carte sera ajoutée au tableau `drawnCards` et stockée dans la variable `drawnCard`. La deuxième carte sera stockée dans la variable `endCard`, nous la remettrons à la fin du paquet ensuite.

Typescript nous indique que la méthode `Array.shift` peut renvoyer un `string` ou un `undefined`. La méthode `Array.push` quant à elle n'acepte qu'un `string` en argument.

Nous devons donc vérifier que les variables `drawnCard` et `endCard` ne sont pas `undefined` avant de les utiliser.

Si `drawnCard` n'est pas `undefined`, nous l'ajoutons à la fin du tableau `drawnCards` avec la méthode `Array.push` Et nous faisons la même chose avec `endCard` dans le tableau `deck`.

Nous retournons le tableau `drawnCards` une fois que le paquet est vide.

```typescript
export const draw = (deck: string[]): string[] => {
 const drawnCards: string[] = [];
  
  while (deck.length > 0) {
    const drawnCard = deck.shift();
    const endCard = deck.shift();
    
    if (drawnCard) {
      drawnCards.push(drawnCard);
    }
    if (endCard) {
      deck.push(endCard);
    }
  }

 return drawnCards;
};
```


Tireur de cartes


## Problème

_Un nombre narcissique (ou nombre de Armstrong) est un nombre qui est égal à la somme de ses propres chiffres, chacun élevé à la puissance du nombre de chiffres dans une base donnée._

&nbsp;

&nbsp;

Rédigez une fonction qui prends un nombre et qui retourne `true` si ce nombre est narcissique, `false` le cas échéant.

La detection d'erreurs pour les chaînes de caractères ou autres entrées invalides n'est pas requise, seuls des entiers positifs non nuls valides seront passés en paramètre de la fonction.

### Exemple

Par exemple, prenons le nombre 153 (3 chiffres), qui est narcissique :

```text
1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153
```

et 1652 (4 chiffres), qui ne l'est pas :

```text
1^4 + 6^4 + 5^4 + 2^4 = 1 + 1296 + 625 + 16 = 1938
```

Alors, votre fonction renverra :

```typescript
narcissistic(153) // true
narcissistic(1652) // false
```

## Solution

Nous allons commencer par convertir le nombre en chaîne de caractères grâce à la méthode `Number.toString`. Ensuite, nous allons séparer chaque chiffre de la chaîne de caractères grâce à la méthode `String.split`.

Nous allons ensuite itérer sur chaque chiffre de la chaîne de caractères grâce à la méthode `Array.map`. Nous allons convertir chaque chiffre en nombre grâce à la fonction `parseInt`.

Notre constante `arr` contient maintenant un tableau de chiffres. Nous allons donc déterminer si l'argument `value` est narcissqiue grâce à la méthode `Array.reduce`.

Pour cela, nous allons élever chaque chiffre à la puissance du nombre de chiffres de `value` grâce à l'opérateur `**` et à la propriété `Array.length`.

Si le résultat de cette opération est différent du nombre passé en paramètre, nous retournons `false`. Sinon, nous retournons `true`.

```typescript
export function narcissistic(value: number): boolean {
  const arr = value.toString().split('').map(n => parseInt(n, 10));
  
  const result = arr.reduce((accumulator, currentValue) => {
    return accumulator + (currentValue**arr.length)
  }, 0)
  
  if (result !== value) return false;
  
  return true;
}
```


Détecteur de nombres narcissiques


## Problème

Rédigez une fonction qui prends une chaîne de caractère d'un ou plusieurs mots, et qui retourne la même chaîne de caractères.
Cette nouvelle chaîne doit avoir les mots de 5 lettres ou plus inversés.

Les chaînes passées en paramètre ne contiendront que des lettres et des espaces. Les espaces ne seront présents que si plusieurs mots sont présents.

### Exemple

```typescript
spinWords( "Hey fellow warriors" ) => returns "Hey wollef sroirraw"
spinWords( "This is a test") => returns "This is a test"
spinWords( "This is another test" )=> returns "This is rehtona test"
```

## Solution

Nous allons commencer par séparer les mots de la chaîne de caractères grâce à la méthode `String.split`.

Ensuite, nous allons itérer sur les mots de la chaîne de caractères grâce à la méthode `Array.map`. Nous allons vérifier si le mot courant fait 5 lettres ou plus grâce à la propriété `String.length`.

Si c'est le cas, nous allons inverser le mot grâce aux méthodes `String.split`, `Array.reverse` et `Array.join`. Sinon, nous retournons le mot tel quel.

Enfin, nous retournons la chaîne de caractères reconstruite grâce à la méthode `Array.join`.

```typescript
export function spinWords(words: string): string {
  return words
    .split(' ')
    .map(word => {
      if (word.length >= 5) {
        return word.split('').reverse().join('');
      }
      return word;
    })
    .join(' ')
}
```


Inverseur de mots


## Problème

Implémentez une fonction de soustraction de doublons entre deux arrays.

Cette fonction doit retirer les éléments de `b` présents dans `a`.
Si une valeur est présente plusieurs fois dans `b`, toutes ces occurences doivent être retirées de `a`.

## Solution

Nous allons filtrer le contenu de l'array `a` grâce à la méthode `Array.filter`.

Cette méthode itère sur l'array sur lequel cette méthode est appelé.
Pour chaque itération, on lui passe une assertion et, si cette dernière s'avère vraie, l'élément est ajouté à l'array de retour.

Nous allons donc vérifier si l'élément courant de `a` n'est pas présent dans `b` grâce à la méthode `Array.includes`.

Nous retournons l'array de retour de `a.filter()` et notre fonction est maintenant opérationnelle.

```typescript
export function arrayDiff(a: number[], b: number[]): number[] {
  return a.filter((element) => !b.includes(element));
}
```


Soustracteur de doublons


## Problème

Le Yahtzee est un jeu de dés joué avec cinq dés à six faces. Rédigez une fonction qui prends en argument un tableau contenant les valeurs des dés et qui renverra le score du lancer.

-   Trois 1 => 1000 points
-   Trois 6 => 600 points
-   Trois 5 => 500 points
-   Trois 4 => 400 points
-   Trois 3 => 300 points
-   Trois 2 => 200 points
-   Un seul 1 => 100 points
-   Un seul 5 => 50 points

Un seul dé peut être compté une seule fois à chaque lancer. Par exemple, un "5" donné ne peut compter que comme faisant partie d'un triple (contribuant aux 500 points) ou comme 50 points simples, mais pas les deux en même temps lors du même lancer.

### Exemple

```bash
Throw       Score
 ---------   ------------------
 5 1 3 4 1   250:  50 (for the 5) + 2 * 100 (for the 1s)
 1 1 1 3 1   1100: 1000 (for three 1s) + 100 (for the other 1)
 2 4 4 5 4   450:  400 (for three 4s) + 50 (for the 5)
```

## Solution

Nous commençons par initialiser un tableau `counts` de six éléments ayant pour valeur `0`, il va nous permettre pour compter le nombre de dés de chaque valeur.

Ensuite, nous utilisons une boucle `foreach` afin de parcourir le tableau `dice` et incrémenter le compteur correspondant dans le tableau `counts` pour chaque valeur de dé.

Une fois que celà est fait, nous utilisons une boucle `for` pour parcourir les six éléments du tableau `counts` et ajouter les points correspondants au score si au moins trois dés ont la même valeur.

Si c'est le cas, nous ajoutons `(i+1) * 100` points au score (où i est l'indice de l'élément dans le tableau `counts`) sauf s'il s'agit d'un triple `1` auquel cas nous ajoutons `1000` points. Puis, nous soustrayons `3` de la valeur de l'élément pour indiquer que ces dés ont déjà été pris en compte.

_(`i+1` car le compteur de 1 se situe à l'index 0 de l'array, le 2 à l'index 1, etc.)_

Finalement, nous ajoutons les points pour les dés restants en vérifiant s'il y a des 1 ou des 5. Pour cela, nous multiplions par `100` le nombre de `1` restant et par `50` le nombre de `5` restants.

Puis nous retournons `result`.

```c#
using System;

public static class Kata
{
  public static int Score(int[] dice) {
    int result = 0;

    int[] counts = new int[6];
    foreach (int roll in dice)
    {
      counts[roll-1] += 1;
    }

    for (int i = 0; i < 6; i++)
    {
      if (counts[i] >= 3)
      {
            if (i == 0)
            {
                result += 1000;
            }
            else
            {
                result += (i+1) * 100;
            }
      }
    }

    result += counts[0] % 3 * 100 + counts[4] % 3 * 50;

    return result;
  }
}
```


Yahtzee


## Problème

Rédigez une fonction qui prends en argument une chaîne de caractère rédigée en camelcase et qui renvoie une nouvelle chaîne de caractère séparant chaque terme par un espace.

### Exemple

```
"camelCasing"  =>  "camel Casing"
"identifier"   =>  "identifier"
""             =>  ""
```

## Solution

Nous commençons par créer un objet `StringBuilder`, il nous permet de construire la nouvelle chaîne de caractères.

Ensuite, nous créons une boucle `foreach` et, pour chaque caractère, nous vérifions s'il s'agit d'une lettre majuscule en utilisant la méthode `Char.IsUpper()`. Si c'est le cas, nous appelons la méthode `Append()` avec comme argument `" "` afin d'insérer un espace.

Ensuite, nous ajoutons le caractère actuellement parcouru par la boucle à notre variable de retour.

Enfin, nous retournons la chaîne de caractères complétée en appelant la méthode `ToString()` depuis notre variable `StringBuilder`.

```c#
using System;
using System.Text;

public class Kata
{
  public static string BreakCamelCase(string str)
  {
    var sb = new StringBuilder();
    foreach (char c in str)
    {
      if (Char.IsUpper(c))
      {
          sb.Append(' ');
      }
      sb.Append(c);
    }

    return sb.ToString();
  }
}
```


Séparateur de camelcase


## Problème

Rédigez une fonction qui prends un nombre entier positif `n` en argument.

Cette fonction doit retourner le nombre `count` de nombre pouvant diviser `n`.

### Exemples

```bash
4 --> 3 (1, 2, 4)
5 --> 2 (1, 5)
12 --> 6 (1, 2, 3, 4, 6, 12)
30 --> 8 (1, 2, 3, 5, 6, 10, 15, 30)
```

## Solution

Pour commencer, nous initialisons la variable de retour `count`.

Ensuite, à l'aide d'une boucle `for`, nous parcourons tous les entiers positifs de 1 à `n`.

Nous vérifions si chaque entier est un diviseur de `n` en vérifiant si `n` modulo `i` est égal à 0. Si c'est le cas, nous incrémentons la variable count.

Enfin, nous retournons notre varaible `count`.

```c#
public class Kata
{
  public static int Divisors(int n)
  {
        int count = 0;

        for (int i = 1; i <= n; i++) {
            if (n % i == 0) {
                count++;
            }
        }

      return count;
  }
}
```


Compteur de diviseurs


## Problème

Rédigez une simple fonction prenant un booléen en argument.

Si la valeur est `true`, la fonction doit renvoyer `"Yes"`, sinon `"No"`.

## Solution

Cette petite fonction peut être rédigé en une ligne.

Nous allons utiliser une expression ternaire dans le retour de la fonction.
De cette manière, notre fonction sera compacte et claire.

```c#
using System;
using System.Linq;

public static class Kata
{
  public static string boolToWord(bool word)
  {
    return word == true ? "Yes" : "No";
  }
}
```


Convertisseur de booléen


## Problème

Rédigez une fonction prenant un tableau de nombres en argument, cette fonction doit renvoyer le plus petit nombre du tableau.

## Solution

Pour commencer, nous initialisons la variable `result` et lui assignons la valeur du premier nombre du tableau.

Ensuite nous créons une boucle `for`, puis itérons sur chaque élément du tableau. Pour chaque élément, nous vérifions si sa valeur est inférieure à `result`.

Si oui, nous assignons cette nouvelle valeur à `result`. Si non, nous passons à l'itération suivante.

Enfin, nous renvoyons `result`.

```c#
public class Kata
{
    public static int FindSmallestInt(int[] args)
    {
      int result = args[0];

      for (int i = 0; i < args.Length; i++) {
        if (args[i] < result) {
          result = args[i];
        }
      }

      return result;
    }
}
```


Plus petit nombre


## Problème

L'acide désoxyribonucléique, l'ADN, est la principale molécule de stockage d'informations dans les systèmes biologiques. Il est composé de quatre bases nucléiques Guanine ('G'), Cytosine ('C'), Adénine ('A') et Thymine ('T').

L'acide ribonucléique, l'ARN, est la principale molécule messagère dans les cellules. L'ARN diffère légèrement de l'ADN dans sa structure chimique et ne contient pas de Thymine. Dans l'ARN, la Thymine est remplacée par une autre base nucléique, l'Uracile ('U').

Créez une fonction qui traduit une chaîne d'ADN donnée en ARN.

Par exemple :

`"GCAT" => "GCAU"`

La chaîne d'entrée peut avoir une longueur arbitraire - en particulier, elle peut être vide. Toutes les entrées sont garanties valides, c'est-à-dire que chaque chaîne d'entrée ne sera jamais composée que de 'G', 'C', 'A' et/ou 'T'.

## Solution

Nous allons utiliser la méthode `replace()` afin de remplacer toutes les occurences de `T` en `U`.

En général, c'est une mauvaise pratique de retourner un argument de fonction transformé. De plus, en C#, les chaînes de caractères sont immutables.

Nous allons donc initialiser une nouvelle variable `arn` et c'est cette dernière que nous retournons.

```c#
namespace Converter {
  public class Converter
  {
    public string dnaToRna(string dna)
    {
      string rna = dna.Replace('T', 'U');
      return rna;
    }
  }
}
```


ADN vers ARN


## Problème

Rédigez une fonction qui accepte un entier `n` et une chaîne de caractères `s` comme paramètres et renvoie une chaîne de caractères qui répète `s` exactement `n` fois.

## Solution

Pour commencer, nous initialisons une variable de type string nommée `result` avec une chaîne de caractères vide.

Nous utilisons une boucle "for" pour répéter `n` fois la chaîne de caractères `s` et ajouter le résultat à la variable `result`.

À la fin de la boucle, la méthode renvoie la variable "result" qui contient la chaîne de caractères "s" répétée "n" fois.

```c#
using System;

namespace Solution
{
  public static class Program
  {
    public static string RepeatStr(int n, string s)
    {
      string result = String.Empty;

      for (int i = 0; i < n; i++) {
        result += s;
      }

      return result;
    }
  }
}
```


Répétition de chaînes


## Problème

Écrivez une fonction findNeedle() qui prend un tableau rempli de déchets mais contenant une seule "aiguille" (needle).

Si votre fonction trouve l'aiguille, elle doit renvoyer un message (sous forme de chaîne) qui indique : "found needle at position" plus l'indice où elle a trouvé l'aiguille.

### Exemple

```
["foin", "débris", "foin", "foin", "plusDeDébris", "needle", "débrisAléatoires"] -> "found needle at position 5"
```

## Solution

Tout d'abord, nous initialisons la variable `result` avec pour valeur une chaîne de caractère vide.

Ensuite, nous utilisons une boucle `for` pour parcourir chaque élément du tableau `haystack`. Pour chaque élément du tableau, on vérifie si cet élément est différent de `null` et s'il est égal à la chaîne de caractère `needle`.

Si ces deux conditions sont satisfaites, on affecte à la variable `result` une chaîne formatée qui indique la position de l'élément contenant l'aiguille.

Si l'aiguille n'est pas trouvée dans le tableau, la valeur initiale de la variable `result` est renvoyée.

```c#
using System;
public class Kata
{
  public static string FindNeedle(object[] haystack)
  {
    string result = String.Empty;

    for(int i = 0; i < haystack.Length; i++) {
      if (haystack[i] != null && haystack[i].Equals("needle")) {
        result = $"found the needle at position {i}";
      }
    }

    return result;
  }
}
```


Une aiguille dans une botte de foin


## Problème

Étant donné un nombre aléatoire non négatif, vous devez renvoyer les chiffres de ce nombre dans un tableau dans l'ordre inverse.

## Solution

Tout d'abord, nous prenons le nombre entier n passé en argument et le convertissons en une chaîne de caractères à l'aide de la méthode `ToString()`. Cela nous permet de traiter chaque chiffre individuellement.

La chaîne de caractères est ensuite convertie en un tableau de caractères à l'aide de la méthode `ToCharArray()`. Cela nous permet de parcourir chaque caractère du nombre pour extraire chaque chiffre.

Un tableau de longs est initialisé pour stocker les chiffres extraits. Sa taille est définie comme étant la longueur du tableau de caractères.

Nous utilisons ensuite une boucle `for` pour parcourir chaque caractère du tableau de caractères. À chaque itération, nous convertissons le caractère en un nombre entier en soustrayant le code ASCII de '0' (48) de celui du caractère. Cette opération fonctionne car les codes ASCII pour les chiffres '0' à '9' sont consécutifs et en ordre croissant. Nous stockons ensuite le chiffre dans le tableau de longs.

Une fois que tous les chiffres ont été extraits et stockés dans le tableau de longs, nous utilisons la méthode `Array.Reverse()` pour inverser l'ordre des éléments du tableau.

Finalement, nous renvoyons le tableau de longs contenant les chiffres extraits dans l'ordre inverse.

```c#
using System;
using System.Collections.Generic;

namespace Solution
{
  class Digitizer
  {
    public static long[] Digitize(long n)
    {
      string number = n.ToString();
      char[] charArray = number.ToCharArray();
      long[] longArray = new long[charArray.Length];

      for (int i = 0; i < charArray.Length; i++) {
        longArray[i] = charArray[i] - '0';
      }

      Array.Reverse(longArray);
      return longArray;
    }
  }
}
```


Retourne le nombre


## Problème

Rédigez une fonction avec deux arguments qui renverra un tableau des n premiers multiples de x.

Le nombre donné et le nombre de fois à compter seront toujours des nombres positifs supérieurs à 0.

La fonction doit renvoyez les résultats sous forme de tableau.

## Solution

Pour commencer, nous initialisons le tabeleau `z`, il contiendra le résultat de la fonction.
Ensuite, nous utilisons une boucle for, nous permettant d'itérer `n` fois dessus.
Pour chaque itération, nous ajoutons à notre tableau `z`, la valeur de `x` multiplié par `i + 1`.

Nous retournons ensuite le tableau `z`.

```c#
using System;

public static class Kata
{
  public static int[] CountBy(int x, int n)
  {
    int[] z = new int[n];

    for (int i = 0; i < n; i++) {
      z[i] = x * (i + 1);
    }

    return z;
  }
}
```


Multiples de X


## Problème

Supposons que votre entreprise vient d'embaucher votre ami d'université et vous a versé une prime de parrainage. Génial ! Pour célébrer cela, vous emmenez votre équipe dans le terrible bar miteux à côté et utilisez la prime de parrainage pour acheter et construire la plus grande pyramide de canettes de bière en trois dimensions possible. Ensuite, vous allez probablement boire ces bières, car supposons que c'est vendredi aussi.

Une pyramide de canettes de bière doublera le nombre de canettes dans chaque niveau - 1 canette au niveau supérieur, 4 au deuxième niveau, 9 au niveau suivant, 16, 25...

Complétez la fonction beeramid pour retourner le nombre de niveaux complets d'une pyramide de canettes de bière que vous pouvez construire, étant donné les paramètres suivants :

- votre prime de parrainage
- le prix d'une canette de bière.

## Solution

On initialise la variable "beerCount" soit la quantité de bière que l'on peut acheter avec la prime de parrainage (c'est-à-dire le quotient de la prime de parrainage par le prix d'une canette de bière).

Ensuite, on initialise la variable "level" avec pour valeur zéro, car on n'a pas encore construit de niveau de la pyramide.

On utilise une boucle "while" pour ajouter des niveaux à la pyramide tant qu'il reste suffisamment de canettes pour construire le niveau suivant. La condition de la boucle vérifie si le carré de la prochaine valeur de "level" est inférieur ou égal à "beerCount".

Si la condition de la boucle est vraie, on ajoute 1 à "level" pour passer au niveau suivant, et on soustrait le nombre de canettes nécessaires pour construire ce niveau.

Si la condition de la boucle est fausse, cela signifie qu'il n'y a pas suffisamment de canettes pour construire le niveau suivant, donc la boucle s'arrête et on retourne la valeur actuelle de "level", qui représente le nombre de niveaux complets de la pyramide que l'on peut construire avec la prime de parrainage.

```typescript
export function beeramid(bonus: number, price: number): number {
  let beerCount = bonus / price
  let level = 0

  while ((level + 1) ** 2 <= beerCount) {
    level += 1
    beerCount -= level ** 2
  }

  return level
}
```


Bièramide


## Problème

Ce problème tire son nom de l'événement probablement le plus important dans la vie de l'historien antique Josephus : selon son récit, lui et ses 40 soldats ont été piégés dans une grotte par les Romains pendant un siège.

Refusant de se rendre à l'ennemi, ils ont plutôt opté pour le suicide collectif, avec une astuce : ils ont formé un cercle et ont procédé à tuer un homme tous les trois, jusqu'à ce qu'il ne reste plus qu'un seul homme (et il était supposé se tuer lui-même pour mettre fin à l'acte).

Josephus et un autre homme étaient les deux derniers et, comme nous connaissons maintenant tous les détails de l'histoire, vous avez peut-être deviné correctement qu'ils n'ont pas exactement suivi l'idée originale.

Il faut maintenant créer une fonction qui renvoie une permutation de Josephus, elle prends en argument le tableau d'éléments à permuter comme s'ils étaient disposés en cercle et en comptant à chaque fois k places jusqu'à ce qu'il n'en reste plus.

### Exemple

Par exemple avec n = 7 et k = 3, la fonction devrait s'exécuter comme suit:

```
[1,2,3,4,5,6,7] - initial sequence
[1,2,4,5,6,7] => 3 is counted out and goes into the result [3]
[1,2,4,5,7] => 6 is counted out and goes into the result [3,6]
[1,4,5,7] => 2 is counted out and goes into the result [3,6,2]
[1,4,5] => 7 is counted out and goes into the result [3,6,2,7]
[1,4] => 5 is counted out and goes into the result [3,6,2,7,5]
[4] => 1 is counted out and goes into the result [3,6,2,7,5,1]
[] => 4 is counted out and goes into the result [3,6,2,7,5,1,4]
```

Le résultat est alors `josephus([1,2,3,4,5,6,7],3) => [3,6,2,7,5,1,4]`.

## Solution

Pour commencer, nous initialisons nos variables : un tableau vide nommé `result` et une variable `index` est initialisée à 0, elle sera utilisée pour suivre la position actuelle dans le cercle.

Ensuite nous créons une boucle while, elle continue à s'exécuter tant qu'il reste des éléments dans le tableau `items`.

À chaque itération de la boucle, l'index est mis à jour pour la position du k-ième élément à éliminer. Cela est fait en utilisant la formule `(k + index - 1) % items.length`. Cela garantit que l'index revient toujours au début du cercle une fois la fin atteinte.

L'élément à la position index calculée est supprimé du tableau items en utilisant la méthode `splice()`, puis poussé à la fin du tableau result en utilisant l'opérateur spread `...`.

La boucle continue jusqu'à ce que tous les éléments aient été éliminés et que le tableau items soit vide.
Enfin, le tableau result est renvoyé, qui contient les éléments dans l'ordre où ils ont été éliminés.

```typescript
export const josephus = (items: any[], k: number): any[] => {
  const result: Array<any> = []
  let index = 0

  while (items.length) {
    index = (k + index - 1) % items.length
    result.push(...items.splice(index, 1))
  }

  return result
}
```


Problème de Josephus


## Problème

Mon ami Jean et moi sommes membres du "Fat to Fit Club (FFC)". Jean est inquiet car chaque mois une liste avec les poids des membres est publiée et chaque mois il est le dernier sur la liste, ce qui signifie qu'il est le plus lourd.

Je suis celui qui établit la liste, donc je lui ai dit: "Ne t'inquiète plus, je vais modifier l'ordre de la liste". Il a été décidé d'attribuer un "poids" aux nombres. Le poids d'un nombre sera désormais la somme de ses chiffres.

Par exemple, 99 aura un "poids" de 18, 100 aura un "poids" de 1, donc dans la liste, 100 viendra avant 99.

Étant donné une chaîne de caractères avec les poids des membres de FFC dans l'ordre normal, pouvez-vous donner cette chaîne triée par "poids" de ces nombres?

Lorsque deux nombres ont le même "poids", nous les classerons comme s'il s'agissait de chaînes de caractères et non des nombres:

180 sera avant 90 car, bien que leurs poids soient identiques (9), en tant que chaîne de caractères il se situe avant.

Tous les nombres de la liste sont positifs et la liste peut être vide.

### Exemples:

```bash
"56 65 74 100 99 68 86 180 90" une fois trié par poids de poids renvoie:

"100 180 90 56 65 74 68 86 99"
```

## Solution

Ma philosophie de développement est de toujours écrire le code que l'on souhaite avoir, cela permet de ne pas s'éparpiller et de rester dans le flow.

Je rédige donc ma fonction `orderWeight()`. J'appelle la méthode `usort()` avec, comme second argument, le nom de la fonction que je souhaite avoir `sortByNumberWeight`.

Je passe maintenant à la rédaction de la fonction `sortByNumberWeight()`.
Je commence par définir la somme des chiffres composant les poids des membres du club. J'appelle une fonction `sumOfDigits` que je souhaite avoir et qui n'est pas encore présente.

Ensuite, si les sommes de `$a` et `$b` sont égales, on appelle la méthode `strcmp()` qui renvoie `-1` si le second argument est plus petit que le premier selon l'ordre alphanumérique ; `0` si les deux arguments sont égaux ; `1` si le second argument est est plus grand que le premier.

Sinon, on renvoie `1` lorsque la somme de `$a` est plus grande que la somme de `$b` et `-1` dans le cas contraire.

Enfin, nous passons à la rédaction de la fonction `sumOfDigits()`, il s'agit d'une fonction très simple qui consiste à séparer le `$nb` passé en argument en tableau composé des chiffres du nombres.

Puis on appelle la méthode `array_reduce()` sur ce tableau et une fonction 'callback' qui additione chaque élément du tableau. On retourne ce résultat.

_Nous aurions pu utiliser la méthode PHP `array_sum`, qui produit le même résultat._

```php
function sumOfDigits($nb)
{
  $digits = str_split($nb);
  return array_reduce($digits, function ($acc, $curr) {
    return $acc + $curr;
  });
}

function sortByNumberWeight($a, $b)
{
  $sumA = sumOfDigits($a);
  $sumB = sumOfDigits($b);
  if ($sumA === $sumB) {
    return strcmp($a, $b);
  }
  return $sumA > $sumB ? 1 : -1;
}

function orderWeight($str)
{
  $nums = explode(' ', $str);
  usort($nums, 'sortByNumberWeight');
  return implode(' ', $nums);
}
```


Poids pour poids


## Problème

Il nous faut construire un bâtiment qui sera une pile de `n` cubes.
Le cube du bas a un volume de n³, le cube situé au dessus a un volume de (n-1)³, et ainsi de suite jusqu'au sommet qui a un volume de 1³.

La fonction prends en argument `m`, elle doit retourner le nombres `n` de cubes qu'il faut construire tel que `n³ + (n+1)³ + (n+2)³ + ... + 1³ = m`.

Si le nombre `n` n'existe pas, alors la fonction renverra `-1`.

### Exemples:

```bash
findNb(1071225) --> 45
findNb(91716553919377) --> -1
```

## Solution

Pour commencer, nous initialisons nos variables `$total` et `$n`.
Ensuite, nous allons mettre en place une boucle `while` qui évaluera si la valeur de `$total` est inférieur au volume `$m`.

Si cette condition se vérifie, nous "ajoutons" un nouveau cube à la construction en incrémentant `$n` de 1 et en ajoutant le volume de ce nouveau cube au total.

Enfin, lorsque le `$total` est supérieur ou égal à `$m`, on stoppe la boucle. On vérifie si le résultat est strictement égal à `$m`, auquel cas on peut retourner `$n` sinon, on retourne `-1`.

```php
function findNb($m)
{
  $total = 0;
  $n = 0;

  while ($total < $m) {
    $n += 1;
    $total += $n ** 3;
  }

  return $total === $m ? $n : -1;
}
```


Pile de cubes


## Problème

Il faut écrire une fonction qui prends en argument une chaîne de caractère `$s` composé de numéros et un nombre entier `$sz` correspondant à la longueur des éléments.
Cette fonction doit décomposer cette chaîne de caractère en plusieurs éléments ("chunks") de longueur passée en argument.

Si le dernier morceau est inférieur à la longueur passée en argument, il doit être retiré.

Pour chaque chunk, calculer la somme des chiffres qui le compose.
Si ce résultat est pair, on reverse le chunk. Sinon on le rotate d'une position vers la gauche.

_Par reverse, on entends que le chiffre en première position se retrouve en dernière position, le second en avant-dernier, etc._

_Par rotate, on entends que le chiffre en première position se retrouve en dernière position, et tous les autres chiffres voient leur position avancer de 1 (le second devient premier, le troisième devient second, etc.)_

Une fois tous les chunks transformés, la fonction doit retourner une nouvelle chaîne de caractère représentant ceux-ci.

Si `$sz` est inférieur ou égal à 0, ou si `$str` est vide, ou encore si `$sz` est plus grand que la longueur de la chaîne de caractère, alors la fonction doit retourner une chaîne de caractère vide `""`.

## Solution

Pour commencer, implémentons les vérifications de valeurs dans un `if` avec plusieurs opérateurs OR `||`.

Pour découper la châine de caractère en retournant un tableau, la méthode `str_split()` est parfaite.

La méthode `end()` permet de retourner le dernier élément d'un tableau, on vérifie sa longueur et, s'il est inférieur à `$sz`, on le retire du tableau.

Nous avons maintenant nos chunks de chiffres. Afin de déterminer le comportement à adopter, nous devons d'abord en calculer la somme.

Pour cela, nous avons besoin d'un tableau contenant les chiffres de notre chunk, appelons-le `$digits`.
Grâce à la méthode `array_reduce()`, nous pouvons facilement en calculer la somme `$sum`.

Si cette valeur est divisible par 2, qu'elle est pair, nous appelons la méthode `array_reverse()`.

Sinon, nous ajoutons le premier élément en fin de tableau en appelant la méthode `array_shift()` qui renvoie le premier élément du tableau tout en le retirant.

Enfin, nous ajoutons notre chunk réorganisé au tableau de résultat sous forme de chaîne de caractère grâce à la méthode `implode()`.

Puis, nous renvoyons le tableau de résultat sous forme de chaîne de caractère grâce à la même méthode.

```php
function revRot($s, $sz)
{
  if ($sz <= 0 || $s === '' || $sz > strlen($s)) {
    return '';
  }
  $result = [];
  $chunks = str_split($s, $sz);

  if (strlen(end($chunks)) < $sz) {
    array_pop($chunks);
  }
  foreach ($chunks as $chunk) {
    $digits = str_split($chunk);
    $sum = array_reduce($digits, function ($acc, $curr) {
      return $acc + $curr;
    });

    if ($sum % 2 === 0) {
      $digits = array_reverse($digits);
    } else {
      $digits[] = array_shift($digits);
    }

    $result[] = implode($digits);
  }

  return implode($result);
}
```


Reverse ou rotate ?


## Problème

Mon ami choisit une suite de nombres de 1 à n (où n est un entier naturel).
Dans cette suite, il choisit 2 nombres, a et b.
Il prétends que le produit de a et b est égal à la somme de tous les nombres de la séquence, excepté a et b.

Pour tester sa théorie, écrivez une fonction qui, pour un nombre n, retourne les nombres a et b prouvant sa théorie.

La fonction prends en argument: n (n est toujours plus grand que 0) et retourne un tableau sous la forme `[[a, b], ...]` où tous les nombres a et b peuvent être retirés et affirmer sa théorie.

`[(a, b), ...]` doivent être triés par ordre croisant de "a".

La fonction doit retourner un tableau vide si il n'existe pas de nombres (a, b) vérifiant la théorie de mon ami.

## Solution

Pour commencer, nous rédigeons la fonction `sum` qui prends un entier `$n` et retourne la somme de tous les entiers naturels compris entre 0 et n.

Ensuite nous initialisons les variables necessaires à l'écriture de la fonction `removeNb`.

Puis nous créons une boucle `for` qui prends `$b` comme itérateur auquel on assigne la valeur de `$n`, puis on exécute la boucle de `$b` à `0` en décrémentant à chaque itération.

_Nous devons construire la boucle dans ce sens car on va determiner la valeur de a qui sera toujours inférieur à b dans les premières itérations. Ainsi nous n'aurons pas besoin de trier le tableau par la suite._

Il s'agit ensuite de déterminer la valeur de `$a` à partir de la valeur de `$b`. J'ai laissé cette partie en commentaire de la fonction.

Nous vérifions si la valeur de \$a est bien un entier compris dans la suite "0->n", puis ajoutons les valeurs `$a` et `$b` au tableau de retour.

```php
function sum($n)
{
  $arr = [];
  for ($i = 0; $i <= $n; $i++) {
    $arr[] = $i;
  }
  return array_reduce($arr, function ($acc, $nb) {
    return $acc + $nb;
  });
}

function removeNb($n)
{
  $a = 0;
  $b = 0;
  $result = [];
  $sum = sum($n);

  for ($b = $n; $b > 0; $b--) {
    /**
     * Equation solving =>
     * |  $a * $b = $sum - $a - $b
     * |  $a * $b + $a = $sum - $b
     * |  ($a * $b) + ($a * 1) = $sum - $b
     * |  $a * ($b + 1) = $sum - $b
     * |  $a = ($sum - $b) / ($b + 1)
     */
    $a = ($sum - $b) / ($b + 1);
    if (is_integer($a) && $a < $n) {
      $result[] = [$a, $b];
    }
  }

  return $result;
}
```


Mon ami ment-il ?


## Problème

Ecrivez une fonction qui prend en argument une chaîne de caractère représentant un nombre romain et qui retourne sa valeur numérique. (Le format des chiffres romains n'est pas à valider)

## Solution

Premièrement, il faut initialiser un tableau contenant les équivalences numériques des lettres des chiffres romains.

Nous allons décomposer la chaîne de caractère passé en argument grĉe à la méthode `str_split`.
Ensuite nous utiliserons une boucle `foreach` pour effectuer une opération par caractère.

Pour chaque caractère, on identifie le suivant dans la chaîne de caractères.
Si sa valeur est inférieure, alors il faut soustraire cette valeur au chiffre suivant puis on ajoute le résultat à la valeur totale.

**Attention toutefois à retirer l'élément suivant car il a déja été comptabilisé.**

Si la valeur du caractère suivante est inférieure alors on ajoute tout simplement la valeur actuelle à la valeur totale.

**Attention également à vérifier la présence de l'élément avant d'effectuer ses opérations.**
En effet, le nombre d'itérations de la boucle `foreach` est déterminé à l'initialisation de celle-ci, si un élément est retiré de l'array, la boucle itére malgré cela.

````php
function solution ($roman) {
  $number = 0;
  $romanToDecimal = [
    'I' => 1,
    'V' => 5,
    'X' => 10,
    'L' => 50,
    'C' => 100,
    'D' => 500,
    'M' => 1000,
  ];

  $digits = str_split($roman);
  foreach($digits as $index => $digit) {
    if (!isset($digits[$index])) continue;

    $current = $romanToDecimal[$digits[$index]];
    $next = $romanToDecimal[$digits[$index+1]];
    if ($current < $next) {
      $number += ($next - $current);
      unset($digits[$index+1]);
      continue;
    }

    $number += $romanToDecimal[$digit];
  }

  return $number;
}
```
````


Décodeur de nombres romains


## Problème

Rédigez une fonction qui prends une chaîne de caractère en argument, et retourne une autre chaîne de caractère formattée.

1. Transformez les caractères minuscules en majuscules.
1. Triez la liste d'invités par ordre alphabétique de leurs Noms

### Exemple

```typescript
s =
  'Fred:Corwill;Wilfred:Corwill;Barney:Tornbull;Betty:Tornbull;Bjon:Tornbull;Raphael:Corwill;Alfred:Corwill'
```

devient

```typescript
'(CORWILL, ALFRED)(CORWILL, FRED)(CORWILL, RAPHAEL)(CORWILL, WILFRED)(TORNBULL, BARNEY)(TORNBULL, BETTY)(TORNBULL, BJON)'
```

## Solution

Pour résoudre ce problème, nous allons retourner la chaîne de caractère passée en argument après l'avoir manipulé grâce à plusieurs méthodes.

```typescript
export function meeting(s: string): string {
  return s
    .toUpperCase()
    .split(';')
    .map((elem) => `(${elem.replace(/(.*):(.*)/, '$2, $1')})`)
    .sort()
    .join('')
}
```

- `toUpperCase()` => Transforme tous les caractères en majuscules
- `split(';')` => Sépare les noms en éléments de tableau
- `map((elem) => elem.replace(/(.*):(.*)/, "$2, $1"))` => Inverse les noms et prénoms, remplace les `:` par des `,` et ajoute des parenthèses autour de chaque élément.
- `sort()` => Trie les éléments du tableau _(L'absence d'arguments renvoie une liste triée par ordre croissant et/ou alphabétique)_
- `join('')` => Transforme le tableau en chaîne de caractère


Liste d'invités


## Problème

Créez le texte qui doit être affiché à côté d'un bouton 'J'aime'.
Implémentez une fonction qui prends un array de nom en argument et retourne un texte comme dans ces exemples:

```
[]                                -->  "no one likes this"
["Peter"]                         -->  "Peter likes this"
["Jacob", "Alex"]                 -->  "Jacob and Alex like this"
["Max", "John", "Mark"]           -->  "Max, John and Mark like this"
["Alex", "Jacob", "Mark", "Max"]  -->  "Alex, Jacob and 2 others like this"
```

## Solution

Pour ce faire, nous utilisons la structure `switch` sur la longueur de l'array passé en argument.
Nous spécifions le format de la chaîne de caractères pour les cas de figure de 1 à 3 éléments dans l'array, puis le format par défaut lorsque l'array contient 4 éléments ou plus.

```typescript
export const likes = (arr: string[]): string => {
  switch (arr.length) {
    case 0:
      return 'no one likes this'
    case 1:
      return `${arr[0]} likes this`
    case 2:
      return `${arr[0]} and ${arr[1]} like this`
    case 3:
      return `${arr[0]}, ${arr[1]} and ${arr[2]} like this`
    default:
      return `${arr[0]}, ${arr[1]} and ${arr.length - 2} others like this`
  }
}
```


Qui aime ça ?


## Problème

Réordonnez la chaîne de caractère passé en argument. Chaque mot de cette chaîne contient un seul nombre. Ce nombre est la position que le mot devrait avoir dans le résultat

_Les nombres vont de 1 à 9. 1 représente le premier mot (et non 0)_

Si la chaîne passé en argument est vide, renvoyez une chaîne de caractère vide.

Exemple:

```
"is2 Thi1s T4est 3a"  -->  "Thi1s is2 3a T4est"
"4of Fo1r pe6ople g3ood th5e the2"  -->  "Fo1r the2 g3ood 4of th5e pe6ople"
""  -->  ""
```

## Solution

Pour commencer, nous allons initialiser un tableau contenant 9 chaînes de caractères vides.
Ensuite, nous utilisons la méthode `split(' ')`. L'espace passé en argument nous permet de séparer la phrase entre chaque mot.
Dans la méthode `forEach()`, nous cherchons à identifier quel nombre se trouve dans le mot et une fois ce dernier identifié, nous le plaçons au bon endroit du tableau `result`.

Lorsque tous les mots ont été repositionnés, nous filtrons les chaînes de caractères vides initialisées en début de fonction.
Enfin, nous utilisons la méthode `join(' ')` afin de transformer le tableau `result` en une seule chaîne de caractère séparant chaque élément avec un espace.

```typescript
export function order(words: string): string {
  let result = ['', '', '', '', '', '', '', '', '']

  words.split(' ').forEach((word) => {
    if (word.includes('1')) result[0] = word
    if (word.includes('2')) result[1] = word
    if (word.includes('3')) result[2] = word
    if (word.includes('4')) result[3] = word
    if (word.includes('5')) result[4] = word
    if (word.includes('6')) result[5] = word
    if (word.includes('7')) result[6] = word
    if (word.includes('8')) result[7] = word
    if (word.includes('9')) result[8] = word
  })

  return result.filter((word) => word !== '').join(' ')
}
```

_Nous aurions également pu chercher les caractères représentant des nombres dans la chaîne de caractères passée en argument. Puis, à l'aide de la méthode `sort()`, trier les mots en fonction de leur nombre._


Repositionnement de mots


## Problème

Rédigez une fonction qui prends un nombre entier en argument, et retourne le nombre de bit égal à `1` dans la représentation binaire de ce nombre.

_L'argument de cette fonction est un nombre non-négatif._

## Solution

Nous allons utiliser la méthode `toString()` en lui passant comme argument `2`. Il s'agit du radix. Le nombre va ếtre convertit sur une base 2.

Ensuite, nous appliquons les méthodes `split()` afin de convertir cette chaîne de caractère en tableau et `forEach()` afin d'effectuer une opération pour chaque bit.

On vérifie la valeur du bit actuel, et, si ce dernier est égal à `1`, on augmente le compteur de 1.

```typescript
export function countBits(n: number): number {
  let result = 0

  n.toString(2)
    .split('')
    .forEach((bit) => {
      if (bit === '1') result += 1
    })

  return result
}
```

_Nous aurions également pu appliquer la méthode `replace()` en lui passant une Regex permettant de remplacer les `0` par des `""`._

_Nous aurions également pu utiliser la méthode `filter()` pour retirer les bits étant différents de `1` afin de retourner la longueur de l'array directement._


Compteur de bit


## Problème

Ecrivez un parser qui va décomposer une suite de commandes, chacune ne faisant qu'un caractère.

- `i` augmente la valeur de 1 (initiallement 0)
- `d` diminue la valeur de 1
- `s` multiplie la valeur par elle-même (carré)
- `o` ajoute la valeur dans l'array de retour

Les caractères invalides doivent être ignorés.

## Solution

Nous allons décomposer la chaîne de caractère passé en argument grâce à la méthode `split`.
Ensuite nous utiliserons la méthode `forEach` pour effectuer une opération par caractère.

La syntaxe la plus claire pour ce genre d'opérations est `switch`.

L'instruction `default: break` nous permet d'ignorer les autres caractères.
Chaque commande est spécifié selon son `case` puis on retourne l'array `result`.

```typescript
/** return the output array and ignore all non-op characters */
export function parse(data: string): number[] {
  const result: number[] = []
  let value = 0

  data.split('').forEach((command) => {
    switch (command) {
      case 'i':
        value += 1
        break
      case 'd':
        value -= 1
        break
      case 's':
        value = value * value
        break
      case 'o':
        result.push(value)
        break
      default:
        break
    }
  })

  return result
}
```


Gestionnaire de commandes


## Problème

Pour un nombre donné, retournez un array comprenant les deux nombres consécutifs de la suite de Fibonacci qui, une fois multiplié, retourne le nombre donné en argument.

Si `F(n) * F(n+1)` n'est pas égal au nombre donné en argument, l'array retourné comprendra `false`, sinon `true` comme suit:

```
[F(n), F(n + 1), true]
```

Ou

```
[F(n), F(n + 1), false]
```

F(n) étant le plus petit nombre équivalent à `F(n) * F(n+1) > prod`

## Solution

Nous allons construire une boucle while qui va tester, pour chaque occurence de la suite de Fibonacci, si le produit de ces deux nombres est inférieur à l'argument.

Tant que c'est le cas, nous avançons dans la suite de Fibonacci.

Lorsque ce n'est plus le cas, c'est que nous sommes arrivés au bon endroit de la suite et nous pouvons renvoyer notre array.

```typescript
export const productFib = (prod: number): [number, number, boolean] => {
  let n = 0
  let nPlusOne = 1

  while (n * nPlusOne < prod) {
    nPlusOne += n
    n = nPlusOne - n
  }

  return [n, nPlusOne, n * nPlusOne === prod]
}
```


Mes Katas