Exercices Swift - Correction.md

List

let array = Array(0..<20).shuffled()

var sum = array.reduce(0, +)

var avg = sum / array.count

var maximum = array.max()

var even = array.filter { $0 % 2 == 0 }

var stringArray = array.map { "\($0)" }

Enum

enum Animal: String, CaseIterable {
    case cat
    case dog
    case elephant
    case giraffe
    case panda
    case penguin
    case cheetah
    case dolphin
    case lion
    case turtle
    
    // Fonction pour afficher l'émoji correspondant à l'animal
    func displayEmoji() -> String {
        switch self {
                case .cat: return "🐱"
                case .dog: return "🐶"
                case .elephant: return "🐘"
                case .giraffe: return "🦒"
                case .panda: return "🐼"
                case .penguin: return "🐧"
                case .cheetah: return "🐆"
                case .dolphin: return "🐬"
                case .lion: return "🦁"
                case .turtle: return "🐢"
                }
    }

    // Fonction pour retourner le type d'alimentation
    func dietType() -> String {
        switch self {
        case .cat, .dog, .cheetah, .lion:
            return "carnivore 🥩"
        case .elephant, .giraffe, .panda, .turtle:
            return "herbivore 🥕"
        default:
            return "omnivore 🍔"
        }
    }

    // Fonction pour afficher la phrase complète en fonction de l'animal
    func animalDescription() -> String {
        return "Le \(self.rawValue) \(displayEmoji()) est un animal \(dietType())."
    }
}

// Utilisation de CaseIterable pour parcourir toutes les valeurs de l'énumération
for animal in Animal.allCases {
    print(animal.animalDescription())
}

Optional

// Déclaration du type Person
struct Person {
    var name: String
    var age: Int?
    var city: String?
}

// Création d'une liste de personnes
let people: [Person] = [
    Person(name: "Alice", age: 25, city: "Paris-sur-Mer"),
    Person(name: "Bob", age: nil, city: "Croissant-ville"),
    Person(name: "Charlie", age: 30, city: "Baguette-ville"),
    Person(name: "David", age: nil, city: "Escargot-terre"),
    Person(name: "Eva", age: 22, city: "Fromage-sur-Ciel"),
    Person(name: "Frank", age: 40, city: "Tour-Eiffel-land"),
    Person(name: "Grace", age: 18, city: "Chapeau-Rouge")
]

// Filtrer les personnes avec un âge nil
let ageNilPeople = people.filter { $0.age == nil }
print("Personnes avec un âge nil : \(ageNilPeople)")

// Filtrer les personnes avec une ville nil
let cityNilPeople = people.filter { $0.city == nil }
print("Personnes avec une ville nil : \(cityNilPeople)")

// Filtrer les personnes avec un âge nil et une ville nil
let ageAndCityNilPeople = people.filter { $0.age == nil && $0.city == nil }
print("Personnes avec un âge nil et une ville nil : \(ageAndCityNilPeople)")

// Afficher le statut "Majeur" ou "Mineur" en fonction de l'âge
for person in people {
    if let age = person.age {
        if age >= 18 {
            print("\(person.name) est majeur.")
        } else {
            print("\(person.name) est mineur.")
        }
    } else {
        print("\(person.name) : Age inconnu.")
    }
}

Generics

class Queue<T> {
    private var elements: [T] = []

    // Ajouter un élément à la file (enqueue)
    func enqueue(_ element: T) {
        elements.append(element)
    }

    // Retirer un élément de la file (dequeue)
    func dequeue() -> T? {
        if elements.isEmpty {
            return nil
        } else {
            return elements.removeFirst()
        }
    }
}

// Exemple d'utilisation de la classe générique Queue
var stringQueue = Queue<String>()

// Ajouter des éléments à la file
stringQueue.enqueue("Apple")
stringQueue.enqueue("Banana")
stringQueue.enqueue("Orange")

// Retirer des éléments de la file
if let firstElement = stringQueue.dequeue() {
    print("Élément retiré de la file : \(firstElement)")  // Affiche "Élément retiré de la file : Apple"
}

// Afficher les éléments restants dans la file
print("Éléments restants dans la file : \(stringQueue.elements)")

Délégation

1

protocol ButtonListener {
    func clicked()
}

class Button {
    var listener: ButtonListener?

    func onClick() {
        listener?.clicked()        
    }
}

class MyInterface : ButtonListener{
    var someButton: Button
    
    init(button: Button) {
        someButton = button
        button.listener = self
    }
    
     func clicked() {
        print("A button has been clicked !")
    }
}

let myButton = Button()
let interface = MyInterface(myButton)

myButton.onClick()

2

class Button {
    var onClickClosure: (() -> ())?
    func onClick() {
        onClickClosure?()
    }
}

class MyInterface{
    var someButton: Button
    
    init(button: Button) {
        someButton = button
        button.onClickClosure = { [unowned self] in
            self.clicked()
        }
    }
    
     func clicked() {
        print("A button has been clicked !")
    }
}

let myButton = Button()
let interface = MyInterface(button: myButton)

myButton.onClick()

3

class Button {
    let identifier: Int
    var onClickClosure: ((Int) -> ())?
    
    init(identifier: Int) {
        self.identifier = identifier
    }
    
    func onClick() {
        onClickClosure?(self.identifier)
    }
}

class MyInterface{
    var buttons: [Button]
    
    init(buttonList: Button...) {
        buttons = buttonList
        buttons.forEach { button in
            button.onClickClosure = { [unowned self] id in
                clicked(id)
            }
        }
    }
    
    func clicked(_ identifier: Int) {
        print("Button with id \(identifier) has been clicked !")
    }
}

let myButton = Button(identifier: 1)
let myButton2 = Button(identifier: 2)
let myButton3 = Button(identifier: 3)
let interface = MyInterface(buttonList: myButton, myButton2, myButton3)

myButton3.onClick()
myButton.onClick()