Exercice Corrigé Langage Swift – Partie 4

import Foundation

// Déclare une fonction appelée "countVoyel"
// qui reçoit une chaîne de caractères "str".
// La fonction retourne un entier représentant
// le nombre de voyelles présentes dans la chaîne.
func countVoyel(_ str: String) -> Int {
    
    // Convertit la chaîne de caractères en une collection
    // de valeurs Unicode.
    return str
        .unicodeScalars
        
        // Filtre les caractères pour conserver uniquement
        // ceux qui appartiennent à l'ensemble "aeiou".
        .filter(CharacterSet(charactersIn: "aeiou").contains)
        
        // Compte le nombre de voyelles trouvées.
        .count
}

// Déclare une fonction appelée "det"
// qui reçoit une matrice d'entiers "matrix".
// La fonction retourne un entier représentant le déterminant.
func det(_ matrix: [[Int]]) -> Int {
    
    // Récupère l'élément situé à la première ligne
    // et à la première colonne.
    let a = matrix[0][0]
    
    // Récupère l'élément situé à la première ligne
    // et à la deuxième colonne.
    let b = matrix[0][1]
    
    // Récupère l'élément situé à la deuxième ligne
    // et à la première colonne.
    let c = matrix[1][0]
    
    // Récupère l'élément situé à la deuxième ligne
    // et à la deuxième colonne.
    let d = matrix[1][1]
    
    // Calcule le déterminant d'une matrice 2 × 2
    // avec la formule :
    // det = (a × d) - (b × c)
    return a * d - b * c
}

// Déclare une fonction appelée "sort"
// qui reçoit un tableau d'entiers optionnel.
// Le paramètre peut donc contenir un tableau ou être nil.
// La fonction retourne toujours un tableau d'entiers.
func sort(_ tab: [Int]?) -> [Int] {
    
    // Vérifie si "tab" contient un tableau.
    // Si le tableau existe, "sorted()" le trie dans l'ordre 
    // croissant.
    // Si "tab" vaut nil, "?? []" retourne un tableau vide.
    return tab?.sorted() ?? []
}

// Déclare une fonction appelée "checkEnd"
// qui reçoit deux chaînes de caractères "str1" et "str2".
// La fonction retourne une valeur booléenne.
func checkEnd(_ str1: String, _ str2: String) -> Bool {
    
    // Vérifie si "str1" se termine par "str2".
    // Retourne true si "str2" est présente à la fin de "str1",
    // sinon retourne false.
    return str1.hasSuffix(str2)
}

// Déclare une fonction appelée "isPalindrome"
// qui reçoit une chaîne de caractères "str".
// La fonction retourne une valeur booléenne : true ou false.
func isPalindrome(_ str: String) -> Bool {
    
    // Inverse l'ordre des caractères de la chaîne avec "reversed()".
    // Convertit ensuite le résultat en String.
    // Compare la chaîne inversée avec la chaîne originale.
    // Retourne true si elles sont identiques,
    // sinon retourne false.
    return String(str.reversed()) == str
}

// Déclare une fonction appelée "count"
// qui reçoit un caractère sous forme de chaîne "c"
// et une chaîne de caractères "str".
// La fonction retourne un entier.
func count(_ c: String, _ str: String) -> Int {
    
    // Parcourt tous les caractères de la chaîne "str".
    // "$0" représente le caractère courant.
    // Convertit le caractère en String puis le compare avec "c".
    // "filter" conserve uniquement les caractères correspondants.
    // "count" retourne le nombre de caractères trouvés.
    return str.filter { String($0) == c }.count
}

// Déclare une fonction appelée "uniqueChar"
// qui reçoit un tableau de chaînes de caractères "arr".
// La fonction retourne un tableau de chaînes de caractères.
func uniqueChar(_ arr: [String]) -> [String] {
    
    // Crée un tableau vide qui contiendra
    // les mots dont tous les caractères sont uniques.
    var res = [String]()
    
    // Crée un ensemble vide de caractères.
    // Un Set ne peut pas contenir deux fois le même élément.
    var s = Set<Character>()
    
    // Parcourt chaque mot du tableau.
    for words in arr {
        
        // Parcourt chaque caractère du mot.
        for char in words {
            
            // Ajoute le caractère dans l'ensemble.
            // Si le caractère existe déjà, il ne sera pas ajouté 
            // une deuxième fois.
            s.insert(char)
        }
        
        // Compare le nombre de caractères uniques
        // avec le nombre total de caractères du mot.
        // S'ils sont égaux, tous les caractères sont uniques.
        if s.count == words.count {
            
            // Ajoute le mot au tableau des résultats.
            res.append(words)
        }
        
        // Réinitialise l'ensemble pour analyser le prochain mot.
        s = []
    }
    
    // Retourne le tableau contenant les mots
    // dont les caractères sont tous uniques.
    return res
}

// Déclare une fonction appelée "NbrNotExist"
// qui reçoit un tableau d'entiers "tab".
// La fonction retourne un entier.
func NbrNotExist(_ tab: [Int]) -> Int {
    
    // Crée un tableau contenant les nombres
    // de 1 à 10.
    var nbrs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    // Parcourt chaque nombre du tableau "tab".
    for i in tab {
        
        // Supprime de "nbrs" tous les éléments
        // qui sont égaux à la valeur actuelle "i".
        nbrs = nbrs.filter { $0 != i }
    }
    
    // Retourne le premier nombre restant dans "nbrs".
    // Le "!" force le déballage de la valeur optionnelle.
    return nbrs.first!
}

// Déclare une fonction appelée "deleteFirstLast"
// qui reçoit une chaîne de caractères "str".
// La fonction retourne une chaîne de caractères.
func deleteFirstLast(_ str: String) -> String {
    
    // Crée une copie de la chaîne reçue.
    var s = str
    
    // Vérifie que la chaîne contient plus de 2 caractères
    // avant de supprimer le premier et le dernier caractère.
    if s.count > 2 {
        
        // Supprime le premier caractère de la chaîne.
        s.remove(at: s.startIndex)
        
        // Supprime le dernier caractère de la chaîne.
        // "endIndex" représente la position après le dernier 
        // caractère.
        // "index(before:)" permet donc d'obtenir l'index du dernier 
        // caractère.
        s.remove(at: s.index(before: s.endIndex))
    }
    
    // Retourne la chaîne après les suppressions.
    return s
}