Exercice Corrigé Langage Swift – Partie 3

// Déclare une fonction appelée "checkNbr"
// qui reçoit un nombre décimal "n" de type Double.
// La fonction retourne une valeur booléenne : true ou false.
func checkNbr(_ n: Double) -> Bool {
    
    // Vérifie si "n" est inférieur ou égal à 0.
    // Retourne true si la condition est vraie,
    // sinon retourne false.
    return n <= 0
}

// Déclare une fonction appelée "count"
// qui reçoit une chaîne de caractères "str".
// La fonction retourne un entier.
func count(_ str: String) -> Int {
    
    // Sépare la chaîne en plusieurs éléments
    // en utilisant l'espace comme séparateur.
    // "count" retourne ensuite le nombre d'éléments obtenus.
    return str.split(separator: " ").count
}

// Déclare une fonction appelée "mulByLen"
// qui reçoit un tableau d'entiers "tab".
// La fonction retourne un nouveau tableau d'entiers.
func mulByLen(_ tab: [Int]) -> [Int] {
    
    // Parcourt chaque élément du tableau avec "map".
    // "$0" représente l'élément courant du tableau.
    // Multiplie chaque élément par le nombre total d'éléments 
    // du tableau.
    // Puis retourne le nouveau tableau.
    return tab.map({ $0 * tab.count })
}

// Déclare une fonction appelée "getIndex"
// qui reçoit un tableau de chaînes de caractères "arr"
// et une chaîne de caractères "str" à rechercher.
// La fonction retourne un entier correspondant à l'indice de "str".
func getIndex(_ arr: [String], _ str: String) -> Int {
    
    // Recherche la position de "str" dans le tableau "arr".
    // "firstIndex(of:)" retourne l'indice du premier élément trouvé.
    // Le "!" force le déballage de la valeur optionnelle.
    return arr.firstIndex(of: str)!
}

// Déclare une fonction appelée "nbrPaire"
// qui reçoit un entier "n" en paramètre.
// La fonction retourne un tableau d'entiers.
func nbrPaire(_ n: Int) -> [Int] {
    
    // Crée un tableau contenant tous les nombres
    // compris entre 1 et "n".
    let numbers = [Int](1...n)
    
    // Parcourt le tableau et conserve uniquement
    // les nombres divisibles par 2.
    // "$0" représente l'élément courant du tableau.
    return numbers.filter { $0 % 2 == 0 }
}

// Déclare une fonction appelée "getEvenNbr"
// qui reçoit un tableau d'entiers "tab".
// La fonction retourne un tableau d'entiers.
func getEvenNbr(_ tab: [Int]) -> [Int] {
    
    // Parcourt tous les éléments du tableau avec "filter".
    // "$0" représente l'élément courant du tableau.
    // Conserve uniquement les nombres pairs,
    // c'est-à-dire ceux dont le reste de la division par 2 est égal 
    // à 0.
    return tab.filter { $0 % 2 == 0 }
}

// Déclare une fonction appelée "prodNbrImp"
// qui reçoit un tableau d'entiers "tab".
// La fonction retourne un entier.
func prodNbrImp(_ tab: [Int]) -> Int {
    
    // Filtre le tableau pour conserver uniquement
    // les nombres impairs.
    // "$0" représente l'élément courant du tableau.
    let nombresImpairs = tab.filter { $0 % 2 == 1 }
    
    // Multiplie tous les nombres impairs entre eux.
    // "1" est la valeur initiale du produit.
    return nombresImpairs.reduce(1, *)
}

// Déclare une fonction appelée "sortByLen"
// qui reçoit un tableau de chaînes de caractères "tab".
// La fonction retourne un nouveau tableau de chaînes de caractères.
func sortByLen(_ tab: [String]) -> [String] {
    
    // Trie les chaînes de caractères par ordre croissant
    // en fonction de leur longueur.
    // "$0" représente la première chaîne comparée.
    // "$1" représente la deuxième chaîne comparée.
    return tab.sorted { $0.count < $1.count }
}

// Déclare une fonction appelée "repeatChr"
// qui reçoit une chaîne de caractères "str"
// et un entier "n" indiquant le nombre de répétitions.
// La fonction retourne une chaîne de caractères.
func repeatChr(_ str: String, _ n: Int) -> String {
    
    // Parcourt chaque caractère de la chaîne avec "map".
    // "$0" représente le caractère courant.
    // "String(repeating:count:)" répète chaque caractère "n" fois.
    // "joined()" rassemble toutes les chaînes obtenues
    // en une seule chaîne de caractères.
    return str.map { String(repeating: String($0), count: n) }.joined()
}