10 extraits de code en C# utiles pour les développeurs

Avant de se lancer

Vous souhaitez devenir incollables sur les langages de programmation les plus performants du marché ? Nos formations C# vous permettront de maitriser la syntaxe et les outils liés à ces langages afin de créer des applications et des infrastructures modernes et performantes en adéquation avec les normes de développement modernes.

Si vous avez déjà de l’expérience sur C#, nous vous proposons notre formation C# Avancé. Vous apprendrez à maîtriser la programmation des applications multithreads et asynchrone, et vous appliquerez divers techniques avancées dans votre code.

L’équipe Ambient IT

Introduction

Cet article vous permettra d’examiner comment ces extraits de code vont résoudre des problèmes de programmation quotidiens, mais nous allons aussi comprendre pourquoi ils fonctionnent de cette manière. En effet, vous allez développer une compréhension plus profonde, et pas seulement de faire un copier-coller sans savoir le pourquoi du comment.

Si vous avez l’habitude de travailler avec C#, et que vous vous êtes déjà retrouvé face à un problème sans savoir comment l’aborder de manière efficace, ces extraits sont faits pour vous. Ils s’adressent également à tous les débutants, en C# qui essaie de comprendre comment utiliser le langage plus efficacement possible.

10 extraits de code complexes de tous types

1. Recherche binaire

public int BinarySearch(int[] arr, int target)
{
    int left = 0;
    int right = arr.Length - 1;
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target)
            return mid;
        if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}

Le concept de recherche binaire est un algorithme de recherche qui permet de trouver la position d’un élément dans un tableau trié. De ce fait, ce code est la solution pour vos méthodes de recherche. À la place de perdre du temps à chercher un élément particulier, il est préférable d’aller directement droit au but. C’est la mission de la recherche binaire, elle permet de faire gagner du temps et de la raison en allant directement à la source.

Ce code vous sera utile pour :

• Recherche d’un utilisateur spécifique dans une liste triée d’utilisateurs
• Recherche d’un livre particulier dans une base de données de bibliothèque triée

2. Tri à bulles

public void BubbleSort(int[] arr)
{
    int len = arr.Length;
    for (int i = 0; i < len - 1; i++)
        for (int j = 0; j < len - i - 1; j++)
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
}

Le tri à bulles mélange les nombres dans un tableau jusqu’à ce qu’ils soient dans un ordre parfait.

Ce code vous sera utile pour :

• Trier les scores du tableau de classement par ordre croissant
• Organiser une liste de produits en fonction de leur prix

3. Recherche en profondeur (DFS) sur un graphe

public void DFS(int v, bool[] visited, List<int>[] adj)
{
    visited[v] = true;
    Console.Write(v + " ");
    foreach (int neighbour in adj[v])
    {
        if (!visited[neighbour])
            DFS(neighbour, visited, adj);
    }
}

Depth-First Search (DFS) est un algorithme de parcours d’arbre qui consiste à déterminer tous les sommets d’un graphe ou d’une structure de données arborescente. L’algorithme s’aventure aussi loin que possible dans un chemin avant même d’en essayer un autre. Utilisez-le lorsque vous avez besoin d’une recherche approfondie et complète sur tous les nœuds d’un graphe.

Ce code vous sera utile pour :

• Recherche de chemin dans un labyrinthe
• Analyse des connexions d’un réseau

4. Suite de Fibonacci

public void PrintFibonacci(int n)
{
    int a = 0, b = 1, c;
    for(int i = 0; i < n; i++)
    {
        Console.Write(a + " ");
        c = a + b;
        a = b;
        b = c;
    }
}

La série de Fibonacci est comme la symphonie des nombres, chaque nombre étant un mélange harmonieux de ses deux prédécesseurs. Cet extrait de code vous aide à générer une suite de Fibonacci de n termes.

Ce code vous sera utile pour :

• Résoudre des problèmes liés aux séquences récursives en mathématiques
• Dans les algorithmes liés à la recherche et au tri, ou même à la cryptographie

5. Calcul factoriel

public int Factorial(int n)
{
    if (n == 0)
        return 1;
    else
        return n * Factorial(n - 1);
}

Les factorielles impliquent la multiplication de tous les entiers positifs jusqu’à un certain nombre, et elles deviennent vite imposantes ! Utilisez cet extrait lorsque vous devez calculer une factorielle.

Ce code vous sera utile :

• Calcul de combinaisons et de permutations pour les statistiques
• Utilisé dans certains algorithmes de recherche et d’optimisation des requêtes

6. Multiplication de matrices

public int[,] MultiplyMatrix(int[,] a, int[,] b)
{
    int[,] result = new int[a.GetLength(0),b.GetLength(1)];
    for (int i = 0; i < result.GetLength(0); i++)
    {
        for (int j = 0; j < result.GetLength(1); j++)
        {
            result[i, j] = 0;
            for (int k = 0; k < a.GetLength(1); k++) // or k<b.GetLength(0)
                result[i, j] += a[i, k] * b[k, j];
        }
    }
    return result;
}

Dans la multiplication matricielle, chaque ligne de la première matrice se mêle à chaque colonne de la seconde matrice. Il en résulte une toute nouvelle matrice dont les éléments sont créés à partir de la somme des paires multipliées.

Ce code vous sera utile pour :

• Transformer un objet 3D à une échelle ou une position différente
• La résolution de systèmes d’équations linéaires dans les méthodes numériques

7. Vérificateur de palindrome

public bool IsPalindrome(string str)
{
    str = str.ToLower();
    int i = 0, j = str.Length - 1;
    while (i < j)
    {
        if (str[i++] != str[j--])
            return false;
    }
    return true;
}

Si vous n’êtes pas sûr qu’un mot ou une phrase soit un palindrome secret, cette fonction est là pour vous aider.

Ce code vous sera utile pour :

• Vérifier si un mot est un palindrome dans le cadre d’un jeu de lettres ou d’un puzzle
• Vérification de la symétrie des séquences d’ADN en bioinformatique

8. Crible d’Ératosthène

public List<int> SieveOfEratosthenes(int n)
{
    bool[] prime = new bool[n + 1];
    for (int i = 0; i <= n; i++)
        prime[i] = true;

    for (int p = 2; p * p <= n; p++)
    {
        if (prime[p] == true)
        {
            for (int i = p * p; i <= n; i += p)
            {
                prime[i] = false;
            }
        }
    }

    List<int> primeNumbers = new List<int>();

    for (int i = 2; i <= n; i++)
    {
        if (prime[i])
        {
            primeNumbers.Add(i);
        }
    }

    return primeNumbers;
}

Le Crible d’Ératosthène est un ancien algorithme qui permet d’extraire tous les nombres premiers jusqu’à un nombre donné « n ». C’est comme un tamis qui élimine les nombres composites, en ne laissant que les nombres premiers.

Cet extrait de code vous sera utile pour :

• La génération de nombres premiers pour les applications cryptographiques
• L’utilisation dans la théorie des nombres et les problèmes mathématiques

9. Tri Rapide

public void QuickSort(int[] arr, int low, int high)
{
    if (low < high)
    {
        int pi = Partition(arr, low, high);
        QuickSort(arr, low, pi - 1);
        QuickSort(arr, pi + 1, high);
    }
}

int Partition(int[] arr, int low, int high)
{
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++)
    {
        if (arr[j] < pivot)
        {
            i++;
            Swap(arr, i, j);
        }
    }
    Swap(arr, i + 1, high);
    return (i + 1);
}

void Swap(int[] arr, int a, int b)
{
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

Le tri rapide, comme son nom l’indique, est un algorithme de tri rapide et efficace. Il choisit un élément pivot, puis partitionne le tableau autour de cet élément pivot.

Cet extrait de code vous sera utile pour :

• Le tri de données dans des applications logicielles où la complexité temporelle est importante
• Les algorithmes de sélection où la sélection est effectuée sur la base d’une certaine condition

10. Trouver la longueur d’une liste chaînée (de manière itérative)

public int GetLength(ListNode head)
{
    int count = 0;
    ListNode current = head;
    while (current != null)
    {
        count++;
        current = current.next;
    }
    return count;
}

Cette fonction parcourt la liste chaînée en faisant des allers-retours et compte le nombre de nœuds.

Cet extrait de code vous sera utile pour :

• Déterminer la taille d’une structure de données construite dynamiquement
• Évaluer la longueur d’une liste chaînée pour résoudre divers problèmes de manipulation de données