30 seconds of swift code
1.0.0
Swift实施了30秒的编码：有用的Swift 4片段的策划集合，您可以在30秒或更短的时间内理解。
注意： - 这绝不隶属于原始的30秒代码。
如果您是从JavaScript土地来的，那么您应该知道该项目使用Swift 4 ，因此并非所有摘要都可以按预期工作。您需要通过转到Project ，然后遵循以下步骤来检查SWIFT版本。 
如果您需要帮助安装Swift 4的最新稳定版本，请访问Swift.org。如果遇到麻烦，请确保您查看Stackoverflow。
该项目包含许多有用的片段，可以帮助初学者和新移民在Swift 4上迅速提高他们的技能。
bubbleSortfilterBoolschunkcountOccurrencesdeepFlattendifferenceduplicatesevery_nthinsertionSortfisherYatesShufflecalcMediancalcBetterMedianaveragefactorialgcdlcm1lcm2maxnminnallUniquejustKeysjustValuesbytesFromStringcapitalizeFirstcapitalizeEveryWordcountVowelslowerCaseFirstLetterOfFirstWordisLowerCaseisUpperCasepalindromeanagramdropdropRightWhilenthElementfilterNonUniquegenericFlattencommaSeparatedmostFrequentrepeatingaveragegcdlcm1lcm2maxnminnfactorialcalcMediancalcBetterMedianradiansToDegreesallUniquejustKeysjustValuesbytesFromStringcapitalizeFirstcapitalizeEveryWordcountVowelslowerCaseFirstLetterOfFirstWordisLowerCaseisUpperCasepalindromesnakesimple_snake_casefirstUniqueCharacterrepeatingrepeatingBubblesort是一种分类算法，它使用的技术是反复比较和交换相邻元素的技术，如果它们处于错误的顺序。
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]
⬆️回到顶部
块将一个阵列分成一定尺寸的较小阵列。
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"]]
⬆️回到顶部
返回给定列表中的每个nth元素，并创建了一个新列表，其中包含给定列表的每个元素。
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]
⬆️回到顶部
删除每个不是布尔值的价值。
func filterBools ( _ inputArr : [ Any ] ) -> [ Any ] {
return inputArr . compactMap { $0 as? Bool }
} filterBools ( [ false , 2 , " lol " , 3 , " a " , " s " , 34 , false , true ] ) //[false, false, true]
⬆️回到顶部
计数数组中的字符串出现。
func countOccurrences ( arr : [ String ] , into : String ) -> Int {
return arr . reduce ( 0 ) { $1 == into ? $0 + 1 : $0 }
} countOccurrences ( arr : [ " FOO " , " FOO " , " BAR " ] , into : " FOO " ) //2
⬆️回到顶部
深度缩小了递归清单。
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]
⬆️回到顶部
返回元素在两个给定数组中不包含（即仅包含一个数组而不是两者中的元素。）。
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
⬆️回到顶部
检查给定数组中的重复元素。
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
⬆️回到顶部
插入排序算法 - Ray Wenderlich https://github.com/raywenderlich/swift-algorithm-club/tree/master/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]
⬆️回到顶部
链接到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"]
⬆️回到顶部
Fisher-Yates算法（又名Knuth Shuffle shuffle shuffle a andar造成了阵列的均匀洗牌，其中每个置换在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]
⬆️回到顶部
将一系列数组作为输入，并将其转换为其类型的扁平阵列。 （处理选项）
/// 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]
⬆️回到顶部
采用一系列字符串，并返回一个字符串，其中每个元素从输入列表中以逗号分隔。
/// 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"
⬆️回到顶部
取一个数组，返回数组中出现的最常见元素。阵列中的元素类型必须符合可及的。
// 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
⬆️回到顶部
在数组中返回两个或多个双打的平均值。
func average ( arr : [ Double ] ) -> Double {
return arr . reduce ( 0 , + ) / Double ( arr . count )
} average ( arr : [ 5 , 4 , 3 , 2 , 1 ] ) //3
⬆️回到顶部
计算数字的阶乘。
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
⬆️回到顶部
计算两个具有递归的整数之间的最大共同除数。
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 )
⬆️回到顶部
使用上面的gcd函数返回两个整数中最不常见的倍数。
func lcm1 ( num1 : Int , num2 : Int ) -> Int {
return abs ( num1 * num2 ) / gcd ( num1 : num1 , num2 : num2 )
} lcm1 ( num1 : 12 , num2 : 7 ) //84
⬆️回到顶部
使用第一个LCM的阵列的最少常见倍数。
func lcm2 ( arr1 : [ Int ] ) -> Int {
return arr1 . reduce ( 1 ) { lcm1 ( num1 : $0 , num2 : $1 ) }
} lcm2 ( arr1 : [ 4 , 3 , 2 ] ) //12
⬆️回到顶部
从提供的数组返回最大元素。
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
⬆️回到顶部
返回没有内置.min()函数的数组中的最小整数（在示例中用于比较结果。）
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
⬆️回到顶部
计算整数阵列中位数的一种方法。
func calcMedian ( arr : [ Int ] ) -> Float {
return Float ( arr . sorted ( by : < ) [ arr . count / 2 ] )
}计算中位数整数的中位数的更好方法。
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.5将角度从弧度转换为度。
func radiansToDegrees ( _ angle : Double ) -> Double {
return angle * 180 / . pi
} radiansToDegrees ( 4 ) // 229.183
⬆️回到顶部
检查所有唯一值的平面列表，如果列表值都是唯一的，则返回true，如果列表值并非全部唯一，则返回false。
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
⬆️回到顶部
接受键值对词典并返回仅键的新数组的函数。
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]
⬆️回到顶部
函数接受键值对的字典并返回仅值的新数组。
func justValues ( dict : Dictionary < AnyHashable , AnyHashable > ) -> [ AnyHashable ] {
return Array ( dict . values )
} justValues ( dict : dict ) //[Olaf, Mushu, Fleeko]
⬆️回到顶部
获取字符串字节。
func bytes ( _ str : String ) -> Int {
return str . utf8 . count
} bytes("Hello")
⬆️回到顶部
大写字符串的第一个字母，其余的同样的字母。
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
⬆️回到顶部
大写字符串中每个单词的首字母。
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!
⬆️回到顶部
在提供的string中重新调整元音number 。
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
⬆️回到顶部
将字符串中的第一个单词的第一个字母降低。
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...
⬆️回到顶部
如果字符串中的任何字符已大写，则返回true。
func isLowerCase ( str : String ) -> Bool {
return str == str . lowercased ( )
} isLowerCase ( str : " I LOVE CHRISTMAS " ) //false
isLowerCase ( str : " <3 lol " ) //true
⬆️回到顶部
检查字符串中的每个字符是否都是大写。
func isUpperCase ( str : String ) -> Bool {
return str == str . uppercased ( )
} isUpperCase ( str : " LOLOLOL " ) //true
isUpperCase ( str : " lmao " ) //false
isUpperCase ( str : " Rofl " ) //false
⬆️回到顶部
如果给定的字符串为allindrome，则返回True ，如果否则， False 。
func palindrome ( str : String ) -> Bool {
return str . lowercased ( ) == String ( str . reversed ( ) ) . lowercased ( )
} palindrome ( str : " racecar " ) //true
palindrome ( str : " Madam " ) //true
palindrome ( str : " lizzie " ) //false
⬆️回到顶部
如果给定的两个字符串是彼此的完美字符，则返回为True ，如果否则，否则为False 。
/// 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
⬆️回到顶部
返回一个新数组，从左侧删除了n个元素。
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 )返回由2D阵列创建的CSV弦乐。
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"通过翻转参数返回给定功能。
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
⬆️回到顶部
从数组的末尾删除元素，直到传递功能返回true。
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]
⬆️回到顶部
过滤列表中的非唯一值
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"]
⬆️回到顶部
在蛇案中返回一个新字符串
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"
⬆️回到顶部
在蛇案中返回一个新字符串
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 )
⬆️回到顶部
返回字符串中的第一个独特字符
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"
⬆️回到顶部
不使用循环打印字符串n时间。
func repeating ( _ repeatedValue : String , count : Int ) {
guard count > 0 else {
return
}
print ( repeatedValue )
repeating ( repeatedValue , count : count - 1 )
} repeating ( " Text " , count : 5 )
⬆️回到顶部
返回字节中的字符串长度
func stringLenghtInBytes ( string : String ) -> Int {
return ( string as NSString ) . length
} stringLenghtInBytes("Hello")
⬆️回到顶部
从给定列表中返回每个nth元素。
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" ]
⬆️回到顶部
返回1如果数组按上升顺序排序，-1如果降序，则为0，如果未分类为0
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 ] ) // 0返回1如果数组按上升顺序排序，-1如果降序，则返回订单，如果未分类为0-选项2最短
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
⬆️回到顶部
将骆驼盒字符串apple_store ex.'applestore'，'timcook'）转换为蛇案（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?☔️? " )
⬆️回到顶部
Flip作为参数的函数，然后将第一个参数作为最后一个参数。
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
⬆️回到顶部
返回顶点的邻居
public func neighborsForIndex ( _ index : Int ) -> [ VertexType ] {
return edges [ index ] . map ( { self . vertices [ $0 . v ] } )
}
⬆️回到顶部
莉兹·西格（Lizzie Siegle）
Abdulhakim Ajetunmobi
Hatos Barbosa
保罗·施罗德（Paul Schroder）
维克多·索科洛夫（Viktor Sokolov）
Sai Sandeep Mutyala
SörenKirchner
Alexey Ivanov
JúlioJohn Tavares Ramos
Camilo Andres Ibarra Yepes
尼古拉斯·科姆（Nicolas Combe）
威廉·西弗纳（William Spanfelner）
Natchanon A.
