30 seconds of swift code
1.0.0
Une mise en œuvre rapide de 30 secondes de code: une collection organisée de extraits Swift 4 utiles que vous pouvez comprendre en 30 secondes ou moins.
Remarque : - Ceci n'est en aucun cas affilié au code d'origine de 30 secondes.
Si vous êtes venu ici de JavaScript Land, vous devez savoir que ce projet utilise Swift 4 , donc tous les extraits ne fonctionneront pas comme prévu sur chaque système. Vous devrez vérifier votre version Swift en allant au Project , puis en suivant les étapes ci-dessous.
Si vous avez besoin d'aide pour installer la dernière version stable de Swift 4, consultez Swift.org. Si vous rencontrez des problèmes, assurez-vous de consulter Stackoverflow.
Ce projet contient de nombreux extraits utiles qui peuvent aider les débutants et les nouveaux arrivants à accélérer rapidement leurs compétences sur Swift 4.
bubbleSortfilterBoolschunkcountOccurrencesdeepFlattendifferenceduplicatesevery_nthinsertionSortfisherYatesShufflecalcMediancalcBetterMedianaveragefactorialgcdlcm1lcm2maxnminnallUniquejustKeysjustValuesbytesFromStringcapitalizeFirstcapitalizeEveryWordcountVowelslowerCaseFirstLetterOfFirstWordisLowerCaseisUpperCasepalindromeanagramdropdropRightWhilenthElementfilterNonUniquegenericFlattencommaSeparatedmostFrequentrepeatingaveragegcdlcm1lcm2maxnminnfactorialcalcMediancalcBetterMedianradiansToDegreesallUniquejustKeysjustValuesbytesFromStringcapitalizeFirstcapitalizeEveryWordcountVowelslowerCaseFirstLetterOfFirstWordisLowerCaseisUpperCasepalindromesnakesimple_snake_casefirstUniqueCharacterrepeatingrepeatingBubblesort est un algorithme de tri qui utilise la technique de comparer et d'échanger les éléments adjacents s'ils sont dans le mauvais ordre.
func bubbleSort ( _ inputArr : [ Int ] ) -> [ Int ] {
guard inputArr . count > 1 else {
return inputArr
}
var res = inputArr
let count = res . count
var isSwapped = false
repeat {
isSwapped = false
for index in stride ( from : 1 , to : count , by : 1 ) {
if res [ index ] < res [ index - 1 ] {
res . swapAt ( ( index - 1 ) , index )
isSwapped = true
}
}
} while isSwapped
return res
} bubbleSort ( [ 32 , 12 , 12 , 23 , 11 , 19 , 81 , 76 ] ) //[11, 12, 12, 19, 23, 32, 76, 81]
⬆️ Retour en haut
Chuns un tableau en tableaux plus petits d'une certaine taille.
func chunk ( arr : [ Any ] , chunkSize : Int ) -> [ Any ] {
let chunks = stride ( from : 0 , to : arr . count , by : chunkSize ) . map {
Array ( arr [ $0 ..< min ( $0 + chunkSize , arr . count ) ] )
}
return chunks
} chunk ( arr : [ 2 , 4 , 6 , 8 ] , chunkSize : 1 ) //[[2], [4], [6], [8]]
chunk ( arr : [ 1 , 3 , 5 , 9 ] , chunkSize : 4 ) //[[1, 3, 5, 9]]
chunk ( arr : [ " hi " , " yo " , " bye " , " bai " ] , chunkSize : 3 ) //[["hi", "yo", "bye"], ["bai"]]
chunk ( arr : [ " young " , " scrappy " , " hungry " ] , chunkSize : 2 ) //[["young", "scrappy"], ["hungry"]]
⬆️ Retour en haut
Renvoie chaque nième élément d'une liste donnée et une nouvelle liste est créée qui contient chaque nième élément de la liste donnée.
func getEvery ( nth : Int , from list : [ Any ] ) {
var nthElements = [ Any ] ( )
var shiftedList = list
shiftedList . insert ( 0 , at : 0 )
for (i , element ) in shiftedList . enumerated ( ) {
if i > 0 && i . isMultiple ( of : nth ) {
nthElements . append ( element )
}
}
} getEvery ( nth : 4 , from : [ " The " , " quick " , " brown " , " fox " , " jumped " , " over " , " the " , " lazy " , " dog " ] ) //["fox", "lazy"]
getEvery ( nth : 2 , from : [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] ) //[2, 4, 6, 8]
⬆️ Retour en haut
Supprimez chaque valeur qui n'est pas un booléen.
func filterBools ( _ inputArr : [ Any ] ) -> [ Any ] {
return inputArr . compactMap { $0 as? Bool }
} filterBools ( [ false , 2 , " lol " , 3 , " a " , " s " , 34 , false , true ] ) //[false, false, true]
⬆️ Retour en haut
Comptez les occurrences d'une chaîne dans un tableau.
func countOccurrences ( arr : [ String ] , into : String ) -> Int {
return arr . reduce ( 0 ) { $1 == into ? $0 + 1 : $0 }
} countOccurrences ( arr : [ " FOO " , " FOO " , " BAR " ] , into : " FOO " ) //2
⬆️ Retour en haut
Deep s'ajoute une liste avec récursivité.
func deepFlatten ( arr : [ AnyHashable ] ) -> [ AnyHashable ] {
var arr2 = [ AnyHashable ] ( )
for el in arr {
if let el = el as? Int {
arr2 . append ( el )
}
if let el = el as? [ Any ] {
let res = deepFlatten ( arr : el as! [ AnyHashable ] )
for i in res {
arr2 . append ( i )
}
}
}
return arr2
} deepFlatten ( arr : [ 6 , 5 , 4 , [ 3 , 2 ] , [ 1 ] ] ) //[6, 5, 4, 3, 2, 1]
⬆️ Retour en haut
Élément de retour (s) non contenu dans les deux tableaux donnés (c'est-à-dire les éléments contenus uniquement dans un tableau et non les deux.)
func difference ( arr1 : [ AnyHashable ] , arr2 : [ AnyHashable ] ) -> Set < AnyHashable > {
return Set ( arr1 ) . symmetricDifference ( arr2 )
} difference ( arr1 : [ 2 , 4 , 6 , 8 ] , arr2 : [ 10 , 8 , 6 , 4 , 2 , 0 ] ) //10
difference ( arr1 : [ " mulan " , " moana " , " belle " , " elsa " ] , arr2 : [ " mulan " , " moana " , " belle " , " pocahontas " ] ) //elsa, pocahontas
⬆️ Retour en haut
Vérifiez les éléments en double dans un tableau donné.
func duplicates ( arr1 : [ AnyHashable ] ) -> Bool {
return arr1 . count != ( Set < AnyHashable > ( arr1 ) ) . count
} duplicates ( arr1 : [ 5 , 4 , 3 , 2 ] ) //false
duplicates ( arr1 : [ " hermione " , " hermione " , " ron " , " harry " ] ) //true
⬆️ Retour en haut
Algorithme de tri d'insertion - inspiré par Ray Wenderlich https://github.com/raywenderlich/swift-algorithm-club/tree/master/insertion%20Sort.
func insertionSort ( _ array : [ Int ] ) -> [ Int ] {
var a = array // 1
for index in stride ( from : 1 , to : a . count , by : 1 ) {
var y = index
while y > 0 && a [ y ] < a [ y - 1 ] { // 3
a . swapAt ( y - 1 , y )
y -= 1
}
}
return a
} let list = [ 10 , - 1 , 3 , 9 , 2 , 27 , 8 , 5 , 1 , 3 , 0 , 26 ]
insertionSort ( list ) //[-1, 0, 1, 2, 3, 3, 5, 8, 9, 10, 26, 27]
⬆️ Retour en haut
Lien vers la documentation officielle du développeur Apple - https://developer.apple.com/documentation/swift/array/1688499-sort
var integerArray = [ 5 , 8 , 2 , 3 , 656 , 9 , 1 ]
var stringArray = [ " India " , " Norway " , " France " , " Canada " , " Italy " ]
integerArray . sort ( ) //[1, 2, 3, 5, 8, 9, 656]
stringArray . sort ( ) //["Canada", "France", "India", "Italy", "Norway"]integerArray . sort ( ) //[1, 2, 3, 5, 8, 9, 656]
stringArray . sort ( ) //["Canada", "France", "India", "Italy", "Norway"]
⬆️ Retour en haut
Algorithme Fisher-Yates aka Knuth Shuffle pour mélanger un tableau crée un mélange uniforme du tableau où chaque permutation est également probable en temps d'O (n).
func shuffle ( arr1 : [ AnyHashable ] ) -> [ AnyHashable ] {
var arr2 = arr1
for i in stride ( from : arr1 . count - 1 , through : 1 , by : - 1 ) {
let j = Int . random ( in : 0 ... i )
if i != j {
arr2 . swapAt ( i , j )
}
}
return arr2
} var foo = [ 1 , 2 , 3 ]
shuffle ( arr1 : foo ) //[2,3,1] , foo = [1,2,3]
⬆️ Retour en haut
Prend un tableau de tableaux en entrée et le transforme en un tableau aplati de son type. (gère les options)
/// We use flat map to flatten the array and compact map to handle optionals
/// - Parameter arrays: Array of arrays to flatten
func flatten < T > ( arrays : [ [ T ? ] ] ) -> [ T ] {
return arrays . flatMap { $0 } . compactMap { $0 }
} flatten ( arrays : [ [ " a " , " b " , " c " , " d " ] , [ " e " , " f " , " g " , " y " ] ] ) // ["a", "b", "c", "d", "e", "f", "g", "y"]
flatten ( arrays : [ [ 1 , nil , 3 , 4 ] , [ 5 , 6 , 7 , 8 ] ] ) // [1, 3, 4, 5, 6, 7, 8]
⬆️ Retour en haut
Prend un tableau de chaînes et renvoie une seule chaîne avec chaque élément de la liste d'entrée séparée par des virgules.
/// Return the elements of `strings` separated by ", "
func commaSeparated ( _ strings : [ String ] ) -> String {
return strings . joined ( separator : " , " )
} let strs = [ " Foo " , " Bar " , " Baz " , " Qux " ]
commaSeparated ( strs ) // "Foo, Bar, Baz, Qux"
⬆️ Retour en haut
Prend un tableau et renvoie l'élément le plus fréquent qui apparaît dans le tableau. Le type d'éléments dans le tableau doit être conforme à la ponte.
// Return the most frequent element that appears in the array
func mostFrequent < Type : Hashable > ( _ arr : [ Type ] ) -> Type ? {
var dict = [ Type : Int ] ( )
for element in arr {
if dict [ element ] == nil {
dict [ element ] = 1
} else {
dict [ element ] ! += 1
}
}
return dict . sorted ( by : { $0 . 1 > $1 . 1 } ) . first ? . key
} mostFrequent ( [ 1 , 2 , 5 , 4 , 1 , 9 , 8 , 7 , 4 , 5 , 1 , 5 , 1 ] ) // 1
mostFrequent ( [ " a " , " b " , " c " , " a " ] ) // "a"
mostFrequent ( [ ] ) // nil
⬆️ Retour en haut
Renvoie la moyenne de deux doubles ou plus dans un tableau.
func average ( arr : [ Double ] ) -> Double {
return arr . reduce ( 0 , + ) / Double ( arr . count )
} average ( arr : [ 5 , 4 , 3 , 2 , 1 ] ) //3
⬆️ Retour en haut
Calcule le factoriel d'un nombre.
func factorial ( num : Int ) -> Int {
var fact : Int = 1
for index in stride ( from : 1 , to : num + 1 , by : 1 ) {
fact = fact * index
}
return fact
} factorial ( num : 4 ) //24
factorial ( num : 10 ) //3628800
⬆️ Retour en haut
Calcule le plus grand diviseur commun entre deux entiers avec une récursivité.
func gcd ( num1 : Int , num2 : Int ) -> Int {
let mod = num1 % num2
if mod != 0 {
return gcd ( num1 : num2 , num2 : mod )
}
return num2
} gcd ( num1 : 228 , num2 : 36 ) //12
gcd ( num1 : - 5 , num2 : - 10 )
⬆️ Retour en haut
Renvoie le multiple le moins commun de deux entiers en utilisant la fonction gcd ci-dessus.
func lcm1 ( num1 : Int , num2 : Int ) -> Int {
return abs ( num1 * num2 ) / gcd ( num1 : num1 , num2 : num2 )
} lcm1 ( num1 : 12 , num2 : 7 ) //84
⬆️ Retour en haut
Multiple le moins commun d'un tableau utilisant le premier LCM.
func lcm2 ( arr1 : [ Int ] ) -> Int {
return arr1 . reduce ( 1 ) { lcm1 ( num1 : $0 , num2 : $1 ) }
} lcm2 ( arr1 : [ 4 , 3 , 2 ] ) //12
⬆️ Retour en haut
Renvoie l'élément maximum du tableau fourni.
func maxn ( arr1 : [ Int ] ) -> Int {
if let ( _ , maxValue ) = arr1 . enumerated ( ) . max ( by : { $0 . element < $1 . element } ) {
return maxValue
}
return 0
} maxn ( arr1 : [ 2 , 9 , 5 ] ) //9
[ 2 , 9 , 5 ] . max ( ) //9
⬆️ Retour en haut
Renvoie l'entier minimum à partir d'un tableau sans la fonction .min() intégrée (utilisée dans des exemples pour comparer les résultats.)
func minn ( arr1 : [ Int ] ) -> Int {
var minVal = arr1 [ 0 ]
for num in arr1 {
minVal = ( num < minVal ) ? num : minVal
}
return minVal
} minn ( arr1 : [ 8 , 2 , 4 , 6 ] ) //2
[ 8 , 2 , 4 , 6 ] . min ( ) //2
⬆️ Retour en haut
Une façon de calculer la médiane d'un éventail d'entiers.
func calcMedian ( arr : [ Int ] ) -> Float {
return Float ( arr . sorted ( by : < ) [ arr . count / 2 ] )
}Meilleure façon de calculer la médiane d'un éventail d'entiers.
func calcBetterMedian ( arr : [ Int ] ) -> Float {
let sorted = arr . sorted ( )
if sorted . count % 2 == 0 {
return Float ( ( sorted [ ( sorted . count / 2 ) ] + sorted [ ( sorted . count / 2 ) - 1 ] ) ) / 2
}
return Float ( sorted [ ( sorted . count - 1 ) / 2 ] )
} calcBetterMedian ( arr : [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ] ) //returns 4.5Convertissez un angle de Radians en degrés.
func radiansToDegrees ( _ angle : Double ) -> Double {
return angle * 180 / . pi
} radiansToDegrees ( 4 ) // 229.183
⬆️ Retour en haut
Vérifie une liste plate pour toutes les valeurs uniques, le rendement True si les valeurs de liste sont toutes uniques et fausses si les valeurs de liste ne sont pas toutes uniques.
func allUnique ( arr : [ AnyHashable ] ) -> Bool {
return arr . count == Set < AnyHashable > ( arr ) . count
} allUnique ( arr : [ 5 , 4 , 3 , 2 ] ) //true
allUnique ( arr : [ " lol " , " rofl " , " lol " ] ) //false
⬆️ Retour en haut
Fonction qui accepte un dictionnaire des paires de valeurs clés et renvoie une nouvelle gamme de clés.
func justKeys ( dict : Dictionary < AnyHashable , AnyHashable > ) -> [ AnyHashable ] {
return Array ( dict . keys )
} var dict : Dictionary < String , String > = [ " Mulan " : " Mushu " , " Anna " : " Olaf " , " Pocahontas " : " Fleeko " ]
justKeys ( dict : dict ) //[Anna, Mulan, Pocahontas]
⬆️ Retour en haut
Fonction qui accepte un dictionnaire des paires de valeurs clés et renvoie un nouveau tableau de valeurs.
func justValues ( dict : Dictionary < AnyHashable , AnyHashable > ) -> [ AnyHashable ] {
return Array ( dict . values )
} justValues ( dict : dict ) //[Olaf, Mushu, Fleeko]
⬆️ Retour en haut
Obtenez des octets d'une chaîne.
func bytes ( _ str : String ) -> Int {
return str . utf8 . count
} bytes("Hello")
⬆️ Retour en haut
Capitalise la première lettre d'une chaîne, laissant le reste le même.
func capitalizeFirst ( str : String ) -> String {
var components = str . components ( separatedBy : " " )
components [ 0 ] = components [ 0 ] . capitalized
return components . joined ( separator : " " )
} capitalizeFirst(str: "i like cheesE") //I like cheesE
⬆️ Retour en haut
Capitalise la première lettre de chaque mot d'une chaîne.
func capitalizeEveryWord ( str : String ) -> String {
return str . capitalized
} capitalizeEveryWord ( str : " on a scale from 1 to 10 how would you rate your pain " ) //On A Scale From...
capitalizeEveryWord ( str : " well, hello there! " ) //Well, Hello There!
⬆️ Retour en haut
Retourne number de voyelles dans string fournie.
func countVowels ( str : String ) -> Int {
var vowelCount = 0
let vowels = Set ( [ " a " , " e " , " i " , " o " , " u " ] )
for char in str . lowercased ( ) {
if vowels . contains ( " ( char ) " ) {
vowelCount += 1
}
}
return vowelCount
} countVowels ( str : " hi mom " ) //2
countVowels ( str : " aeiou " ) //5
⬆️ Retour en haut
Décapitalise la première lettre du premier mot dans une chaîne.
func lowerCaseFirstLetterOfFirstWord ( str : String ) -> String {
var components = str . components ( separatedBy : " " )
components [ 0 ] = components [ 0 ] . lowercased ( )
return components . joined ( separator : " " )
} lowerCaseFirstLetterOfFirstWord ( str : " Christmas Switch was a solid movie " ) //christmas Switch...
⬆️ Retour en haut
Retour True si un caractère dans une chaîne est capitalisé.
func isLowerCase ( str : String ) -> Bool {
return str == str . lowercased ( )
} isLowerCase ( str : " I LOVE CHRISTMAS " ) //false
isLowerCase ( str : " <3 lol " ) //true
⬆️ Retour en haut
Vérifie que chaque caractère d'une chaîne est en majuscule.
func isUpperCase ( str : String ) -> Bool {
return str == str . uppercased ( )
} isUpperCase ( str : " LOLOLOL " ) //true
isUpperCase ( str : " lmao " ) //false
isUpperCase ( str : " Rofl " ) //false
⬆️ Retour en haut
Renvoie True si la chaîne donnée est un palindrome, False si autrement.
func palindrome ( str : String ) -> Bool {
return str . lowercased ( ) == String ( str . reversed ( ) ) . lowercased ( )
} palindrome ( str : " racecar " ) //true
palindrome ( str : " Madam " ) //true
palindrome ( str : " lizzie " ) //false
⬆️ Retour en haut
Renvoie True si les 2 chaînes données sont des anagrammes parfaits les uns des autres, False si autrement.
/// Return `true` if the 2 given strings are "perfect" anagrams.
/// (they consist of the same characters excluding whitespace)
func anagram ( _ str1 : String , _ str2 : String ) -> Bool {
let s1 = str1 . filter { !$0 . isWhitespace } . lowercased ( )
let s2 = str2 . filter { !$0 . isWhitespace } . lowercased ( )
return s1 . count == s2 . count && s1 . sorted ( ) == s2 . sorted ( )
} anagram ( " abcd3 " , " 3acdb " ) // true
anagram ( " 123 " , " 456 " ) // false
anagram ( " Buckethead " , " Death Cube K " ) // true
⬆️ Retour en haut
Renvoie un nouveau tableau avec N éléments supprimés de la gauche.
func drop ( arr : [ AnyHashable ] , num : Int ) -> [ AnyHashable ] {
return Array ( arr . dropFirst ( num ) ) //need Array() to concert ArraySlice to Array
} drop ( arr : [ 5 , 4 , 3 , 2 , 1 , 0 ] , num : 1 )
drop ( arr : [ " Huey " , " Dewey " , " Louie " ] , num : 3 )Renvoie une chaîne CSV créée à partir de 2D-Array.
func arrayToCSV ( _ inputArray : [ Array < String > ] ) -> String {
var csv : String = " "
for row in inputArray {
csv . append ( row . map { " " ( $0 ) " " } . joined ( separator : " , " ) + " n " )
}
return csv
} arrayToCSV ( [ [ " a " , " b " , " c " ] , [ " d " , " e " , " f " ] , [ " g " , " h " , " i " ] ] )
//"a", "b", "c"
//"d", "e", "f"
//"g", "h", "i"Renvoie la fonction donnée avec des arguments à revers.
func flip < A , B , C > ( _ function : @escaping ( ( A , B ) -> C ) ) -> ( ( B , A ) -> C ) {
return { ( a , b ) in
return function ( b , a )
}
}// flip example 1
func concat ( _ alpha : String , _ beta : String ) -> String {
return alpha + beta
}
let reverseConcat = flip ( concat )
concat ( " A " , " B " ) //"AB"
reverseConcat ( " A " , " B " ) //"BA"
// flip example 2
func gt ( _ a : Int , _ b : Int ) -> Bool {
return a > b
}
let lt = flip ( gt )
gt ( 5 , 3 ) //true
lt ( 5 , 3 ) //false
gt ( 2 , 5 ) //false
lt ( 2 , 5 ) //true
⬆️ Retour en haut
Supprime les éléments de la fin d'un tableau jusqu'à ce que la fonction passée renvoie vrai.
func dropRight ( arr : [ Int ] , while predicate : ( ( Int ) -> Bool ) ) -> [ Int ] {
var returnArr = arr
for item in arr . reversed ( ) {
if predicate ( item ) { break }
returnArr = returnArr . dropLast ( )
}
return returnArr
} dropRight ( arr : [ 1 , 2 , 3 , 4 , 5 ] , while : { $0 < 0 } ) //[]
dropRight ( arr : [ 1 , 2 , 3 , 4 , 5 ] , while : { $0 > 0 } ) //[1, 2, 3, 4, 5]
⬆️ Retour en haut
Filtre les valeurs non uniques dans une liste
func filterNonUnique ( arr : [ Any ] ) -> [ Any ] {
let set = NSOrderedSet ( array : arr )
return set . array
} filterNonUnique ( arr : [ 1 , 2 , 2 , 3 , 5 ] ) // [1, 2, 3, 5]
filterNonUnique ( arr : [ " Tim " , " Steve " , " Tim " , " Jony " , " Phil " ] ) // ["Tim", "Steve", "Jony", "Phil"]
⬆️ Retour en haut
Renvoie une nouvelle chaîne dans le cas de serpent
func snake ( str : String ) -> String ? {
let pattern = " ([a-z0-9])([A-Z]) "
let regex = try ? NSRegularExpression ( pattern : pattern , options : [ ] )
let range = NSRange ( location : 0 , length : str . count )
return regex ? . stringByReplacingMatches ( in : str , options : [ ] , range : range , withTemplate : " $1_$2 " )
. lowercased ( )
. replacingOccurrences ( of : " " , with : " _ " )
. replacingOccurrences ( of : " - " , with : " _ " )
} snake ( str : " camelCase " ) // 'camel_case'
snake ( str : " some text " ) // 'some_text'
snake ( str : " some-mixed_string With spaces_underscores-and-hyphens " ) // 'some_mixed_string_with_spaces_underscores_and_hyphens'
snake ( str : " AllThe-small Things " ) // "all_the_smal_things"
⬆️ Retour en haut
Renvoie une nouvelle chaîne dans le cas de serpent
func snakeCase ( _ string : String ) -> String {
let arrayOfStrings = text . components ( separatedBy : " " )
return arrayOfStrings . joined ( separator : " _ " )
} let text = " Snake case is the practice of writing compound words or phrases in which the elements are separated with one underscore character and no spaces. "
snakeCase ( text )
⬆️ Retour en haut
Renvoie le premier caractère unique dans une chaîne
func firstUniqueCharacter ( _ str : String ) -> Character ? {
var countDict : [ Character : Int ] = [ : ]
for char in str {
countDict [ char ] = ( countDict [ char ] ?? 0 ) + 1
}
return str . filter { countDict [ $0 ] == 1 } . first
} firstUniqueCharacter ( " barbeque nation " ) //"r"
⬆️ Retour en haut
Imprime une chaîne n fois sans utiliser de boucles.
func repeating ( _ repeatedValue : String , count : Int ) {
guard count > 0 else {
return
}
print ( repeatedValue )
repeating ( repeatedValue , count : count - 1 )
} repeating ( " Text " , count : 5 )
⬆️ Retour en haut
Renvoie la longueur de la chaîne en octets
func stringLenghtInBytes ( string : String ) -> Int {
return ( string as NSString ) . length
} stringLenghtInBytes("Hello")
⬆️ Retour en haut
Renvoie chaque nième élément de la liste donnée.
func everyNth ( list : [ Any ] , n : Int ) -> [ Any ] {
return list . enumerated ( ) . compactMap ( { ( $0 . offset + 1 ) % n == 0 ? $0 . element : nil } )
} everyNth ( list : [ 1 , 2 , 3 , 4 , 5 , 6 ] , n : 2 ) // [ 2, 4, 6 ]
everyNth ( list : [ " a " , " b " , " c " , " d " , " e " , " f " ] , n : 3 ) // [ "c", "f" ]
⬆️ Retour en haut
Renvoie 1 si le tableau est trié par ordre croissant, -1 si décrochant l'ordre, et 0 si non trié
func isSorted ( arr : [ Int ] ) -> Int {
var asc : Bool = true
var prev : Int = Int . min
for elem in arr {
if elem < prev {
asc = false
break
}
prev = elem
}
if asc {
return 1
}
var dsc : Bool = true
prev = Int . max
for elem in arr {
if elem > prev {
dsc = false
break
}
prev = elem
}
if dsc {
return - 1
}
return 0
} isSorted ( arr : [ 1 , 2 , 2 , 4 , 8 ] ) // 1
isSorted ( arr : [ 8 , 4 , 4 , 2 , 1 ] ) // -1
isSorted ( arr : [ 1 , 4 , 2 , 8 , 4 ] ) // 0Renvoie 1 Si le tableau est trié par ordre croissant, -1 si décroissant la commande, et 0 si non trié - Option 2 le plus court
func sortedArray ( arr : [ Int ] ) -> Int {
let sortedArr = arr . sorted ( by : { $1 > $0 } )
return arr == sortedArr ? 1 : arr == sortedArr . reversed ( ) ? - 1 : 0
}//Input sortedArray(arr: [1,2,3,4,5]) - Output 1
//Input sortedArray(arr: [5,4,3,2,1]) - Output -1
//Input sortedArray(arr: [6,2,3,4,8]) - Output 0
⬆️ Retour en haut
Convertir Camel Case String (Ex.'Applestore ',' Timcook ') en cas de serpent (Ex. apple_store ,' Tim_cook ')
func camelCaseToSnake ( str : String ) -> String {
guard let regex = try ? NSRegularExpression ( pattern : " ([a-z0-9])([A-Z]) " , options : [ ] ) else {
return str
}
let range = NSRange ( location : 0 , length : str . count )
return regex . stringByReplacingMatches ( in : str , options : [ ] , range : range , withTemplate : " $1_$2 " ) . lowercased ( )
} camelCaseToSnake ( str : " appleIphoneX " )
camelCaseToSnake ( str : " camelCaseStringToSnakeCase " )
camelCaseToSnake ( str : " string " )
camelCaseToSnake ( str : String ( ) )
camelCaseToSnake ( str : " firstPullRequestForHacktoberFest?☔️? " )
⬆️ Retour en haut
Flip prend une fonction comme un argument, puis fait le premier argument le dernier.
func flip < A , B , C > ( _ f : @escaping ( A , B ) -> C ) -> ( B , A ) -> C {
return { ( b , a ) in f ( a , b ) }
} String . init ( repeating : " ? " , count : 5 ) == flip ( String . init ( repeating : count : ) ) ( 5 , " ? " ) //true
⬆️ Retour en haut
Renvoie les voisins d'un sommet
public func neighborsForIndex ( _ index : Int ) -> [ VertexType ] {
return edges [ index ] . map ( { self . vertices [ $0 . v ] } )
}
⬆️ Retour en haut
Lizzie Siegle
Abdulhakim Ajetunmobi
Hatos Barbosa
Paul Schroder
Viktor Sokolov
Sai Sandeep Mutyala
Sören Kirchner
Alexey Ivanov
Júlio John Tavares Ramos
Camilo Andres Ibarra Yepes
Nicolas Combe
William Spanfelner
Natchanon A.
