human
En Swift, existe-t-il un moyen astucieux d'utiliser les méthodes d'ordre supérieur sur un tableau pour renvoyer les 5 premiers objets ?
La façon de le faire en obj-c était de sauvegarder un index et de parcourir le tableau avec une boucle for en incrémentant l'index jusqu'à ce qu'il atteigne 5, puis de renvoyer le nouveau tableau. Est-il possible de le faire avec ```filter```, ```map``` ou ```reduce```
gpt
Avec Swift 5, selon vos besoins, vous pouvez choisir l'un des 6 codes Playground suivants pour résoudre votre problème.

#1. Utilisation de la souscription ```subscript(_:)```
```let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array[..<5]
//let arraySlice = array[0..<5] // fonctionne également
//let arraySlice = array[0...4] // fonctionne également
//let arraySlice = array[...4] // fonctionne également
let newArray = Array(arraySlice)
print(newArray) // affiche: ["A", "B", "C", "D", "E"]
```

#2. Utilisation de la méthode ```prefix(_:)```
Complexité: O(1) si la collection est conforme à ```RandomAccessCollection```; sinon, O(k), où k est le nombre d'éléments à sélectionner depuis le début de la collection.
```let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(5)
let newArray = Array(arraySlice)
print(newArray) // affiche: ["A", "B", "C", "D", "E"]
```
Apple indique pour ```prefix(_:)```:

  Si la longueur maximale dépasse le nombre d'éléments dans la collection, le résultat contient tous les éléments de la collection.


#3. Utilisation de la méthode ```prefix(upTo:)```
Complexité: O(1)
```let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(upTo: 5)
let newArray = Array(arraySlice)
print(newArray) // affiche: ["A", "B", "C", "D", "E"]
```
Apple indique pour ```prefix(upTo:)```:

  L'utilisation de la méthode ```prefix(upTo:)``` est équivalente à utiliser une plage semi-ouverte partielle en tant que souscription de la collection. La notation de souscription est préférée à ```prefix(upTo:)```.


#4. Utilisation de la méthode ```prefix(through:)```
```let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let arraySlice = array.prefix(through: 4)
let newArray = Array(arraySlice)
print(newArray) // affiche: ["A", "B", "C", "D", "E"]
```

#5. Utilisation de la méthode ```removeSubrange(_:)```
Complexité: O(n), où n est la longueur de la collection.
```var array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
array.removeSubrange(5...)
print(array) // affiche: ["A", "B", "C", "D", "E"]
```

#6. Utilisation de la méthode ```dropLast(_:)```
Complexité: O(1) si la collection est conforme à ```RandomAccessCollection```; sinon, O(k), où k est le nombre d'éléments à supprimer.
```let array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]
let distance = array.distance(from: 5, to: array.endIndex)
let arraySlice = array.dropLast(distance)
let newArray = Array(arraySlice)
print(newArray) // affiche: ["A", "B", "C", "D", "E"]
```