30 seconds of swift code
1.0.0
Uma implementação rápida de 30 segundos de código: uma coleção com curadoria de trechos úteis Swift 4 que você pode entender em 30 segundos ou menos.
Nota :-Isso não é de forma alguma afiliado aos 30 segundos de código original.
Se você veio aqui da JavaScript Land, deve estar ciente de que este projeto usa Swift 4 , portanto, nem todos os trechos funcionarão conforme o esperado em todos os sistemas. Você precisará verificar sua versão SWIFT indo para Project e seguindo as etapas abaixo.
Se você precisar de ajuda para instalar o lançamento estável mais recente do Swift 4, consulte Swift.org. Se você tiver problemas, verifique o StackOverflow.
Este projeto contém muitos trechos úteis que podem ajudar iniciantes e recém-chegados a acelerar rapidamente suas habilidades no Swift 4.
bubbleSortfilterBoolschunkcountOccurrencesdeepFlattendifferenceduplicatesevery_nthinsertionSortfisherYatesShufflecalcMediancalcBetterMedianaveragefactorialgcdlcm1lcm2maxnminnallUniquejustKeysjustValuesbytesFromStringcapitalizeFirstcapitalizeEveryWordcountVowelslowerCaseFirstLetterOfFirstWordisLowerCaseisUpperCasepalindromeanagramdropdropRightWhilenthElementfilterNonUniquegenericFlattencommaSeparatedmostFrequentrepeatingaveragegcdlcm1lcm2maxnminnfactorialcalcMediancalcBetterMedianradiansToDegreesallUniquejustKeysjustValuesbytesFromStringcapitalizeFirstcapitalizeEveryWordcountVowelslowerCaseFirstLetterOfFirstWordisLowerCaseisUpperCasepalindromesnakesimple_snake_casefirstUniqueCharacterrepeatingrepeatingO Bubblesort é um algoritmo de classificação que usa a técnica de comparar e trocar repetidamente os elementos adjacentes, se estiverem na ordem errada.
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]
⬆️ de volta ao topo
Pedaços de uma matriz em matrizes menores de um determinado tamanho.
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"]]
⬆️ de volta ao topo
Retorna todos os enésimos elementos em uma determinada lista e é criada uma nova lista que contém todos os enésimos elementos da lista fornecida.
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]
⬆️ de volta ao topo
Remova todos os valores que não são booleanos.
func filterBools ( _ inputArr : [ Any ] ) -> [ Any ] {
return inputArr . compactMap { $0 as? Bool }
} filterBools ( [ false , 2 , " lol " , 3 , " a " , " s " , 34 , false , true ] ) //[false, false, true]
⬆️ de volta ao topo
Ocorrências de contagem de uma corda em uma matriz.
func countOccurrences ( arr : [ String ] , into : String ) -> Int {
return arr . reduce ( 0 ) { $1 == into ? $0 + 1 : $0 }
} countOccurrences ( arr : [ " FOO " , " FOO " , " BAR " ] , into : " FOO " ) //2
⬆️ de volta ao topo
Deep achatar uma lista com recursão.
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]
⬆️ de volta ao topo
Elementos de retorno (s) não contidos em ambas as matrizes dadas (ou seja, elementos contidos apenas em uma matriz e não em ambos.)
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
⬆️ de volta ao topo
Verifique se há elementos duplicados em uma determinada matriz.
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
⬆️ de volta ao topo
Algoritmo de classificação de inserção-inspirado por 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]
⬆️ de volta ao topo
Link para a documentação oficial do desenvolvedor da 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"]
⬆️ de volta ao topo
O algoritmo Fisher-Yates, também conhecido como Knuth Shuffle, para embaralhar uma matriz, cria uma embarcação uniforme da matriz, onde cada permutação é igualmente provável no tempo 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]
⬆️ de volta ao topo
Pega uma variedade de matrizes como entrada e a transforma em uma matriz achatada do seu tipo. (lida com opções)
/// 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]
⬆️ de volta ao topo
Pega uma variedade de strings e retorna uma única string com cada elemento da lista de entrada separada por vírgulas.
/// 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"
⬆️ de volta ao topo
Pega uma matriz e retorna o elemento mais frequente que aparece na matriz. O tipo de elementos na matriz deve estar em conformidade com a hashable.
// 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
⬆️ de volta ao topo
Retorna a média de dois ou mais duplos em uma matriz.
func average ( arr : [ Double ] ) -> Double {
return arr . reduce ( 0 , + ) / Double ( arr . count )
} average ( arr : [ 5 , 4 , 3 , 2 , 1 ] ) //3
⬆️ de volta ao topo
Calcula o fatorial de um número.
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
⬆️ de volta ao topo
Calcula o maior divisor comum entre dois números inteiros com recursão.
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 )
⬆️ de volta ao topo
Retorna o múltiplo menos comum de dois números inteiros usando a função gcd acima.
func lcm1 ( num1 : Int , num2 : Int ) -> Int {
return abs ( num1 * num2 ) / gcd ( num1 : num1 , num2 : num2 )
} lcm1 ( num1 : 12 , num2 : 7 ) //84
⬆️ de volta ao topo
Múltiplo menos comum de uma matriz usando o primeiro LCM.
func lcm2 ( arr1 : [ Int ] ) -> Int {
return arr1 . reduce ( 1 ) { lcm1 ( num1 : $0 , num2 : $1 ) }
} lcm2 ( arr1 : [ 4 , 3 , 2 ] ) //12
⬆️ de volta ao topo
Retorna o elemento máximo da matriz fornecida.
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
⬆️ de volta ao topo
Retorna o número inteiro mínimo de uma matriz sem a função .min() embutida (usada em exemplos para comparar os resultados.)
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
⬆️ de volta ao topo
Uma maneira de calcular a mediana de uma variedade de números inteiros.
func calcMedian ( arr : [ Int ] ) -> Float {
return Float ( arr . sorted ( by : < ) [ arr . count / 2 ] )
}Melhor maneira de calcular a mediana de uma variedade de números inteiros.
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.5Converta um ângulo de radianos em graus.
func radiansToDegrees ( _ angle : Double ) -> Double {
return angle * 180 / . pi
} radiansToDegrees ( 4 ) // 229.183
⬆️ de volta ao topo
Verifica uma lista plana para todos os valores exclusivos, retornando true se os valores da lista forem todos exclusivos e falsos se os valores da lista não forem todos exclusivos.
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
⬆️ de volta ao topo
Função que aceita um dicionário de pares de valores-chave e retorna uma nova matriz apenas das chaves.
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]
⬆️ de volta ao topo
Função que aceita um dicionário de pares de valor-chave e retorna uma nova matriz apenas dos valores.
func justValues ( dict : Dictionary < AnyHashable , AnyHashable > ) -> [ AnyHashable ] {
return Array ( dict . values )
} justValues ( dict : dict ) //[Olaf, Mushu, Fleeko]
⬆️ de volta ao topo
Obtenha bytes de uma string.
func bytes ( _ str : String ) -> Int {
return str . utf8 . count
} bytes("Hello")
⬆️ de volta ao topo
Capitaliza a primeira letra de uma corda, deixando o resto o mesmo.
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
⬆️ de volta ao topo
Capitaliza a primeira letra de cada palavra em uma string.
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!
⬆️ de volta ao topo
RETUNS number de vogais na string fornecida.
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
⬆️ de volta ao topo
Decapitaliza a primeira letra da primeira palavra em uma string.
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...
⬆️ de volta ao topo
Retorne true se algum caractere em uma string for capitalizado.
func isLowerCase ( str : String ) -> Bool {
return str == str . lowercased ( )
} isLowerCase ( str : " I LOVE CHRISTMAS " ) //false
isLowerCase ( str : " <3 lol " ) //true
⬆️ de volta ao topo
Verifica se cada caractere em uma string é maiúscula.
func isUpperCase ( str : String ) -> Bool {
return str == str . uppercased ( )
} isUpperCase ( str : " LOLOLOL " ) //true
isUpperCase ( str : " lmao " ) //false
isUpperCase ( str : " Rofl " ) //false
⬆️ de volta ao topo
Retorna True se a string fornecida for um palíndromo, False , se o contrário.
func palindrome ( str : String ) -> Bool {
return str . lowercased ( ) == String ( str . reversed ( ) ) . lowercased ( )
} palindrome ( str : " racecar " ) //true
palindrome ( str : " Madam " ) //true
palindrome ( str : " lizzie " ) //false
⬆️ de volta ao topo
Retorna True se as duas strings dadas forem os anagramas perfeitos um do outro, False , se o contrário.
/// 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
⬆️ de volta ao topo
Retorna uma nova matriz com n elementos removidos da esquerda.
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 )Retorna uma corda CSV criada a 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"Retorna a função fornecida com argumentos ligados.
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
⬆️ de volta ao topo
Remove os elementos do final de uma matriz até que a função passada retorne 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]
⬆️ de volta ao topo
Filtra os valores que não são únicos em uma lista
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"]
⬆️ de volta ao topo
Retorna uma nova string no caso de cobra
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"
⬆️ de volta ao topo
Retorna uma nova string no caso de cobra
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 )
⬆️ de volta ao topo
Retorna o primeiro personagem único em uma string
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"
⬆️ de volta ao topo
Imprime uma string n vezes sem usar loops.
func repeating ( _ repeatedValue : String , count : Int ) {
guard count > 0 else {
return
}
print ( repeatedValue )
repeating ( repeatedValue , count : count - 1 )
} repeating ( " Text " , count : 5 )
⬆️ de volta ao topo
Retorna o comprimento da corda em bytes
func stringLenghtInBytes ( string : String ) -> Int {
return ( string as NSString ) . length
} stringLenghtInBytes("Hello")
⬆️ de volta ao topo
Retorna todos os enésimos elementos da determinada lista.
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" ]
⬆️ de volta ao topo
Retorna 1 se a matriz for classificada em ordem ascendente, -1 se a ordem descendente e 0 se não derrotado
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 ] ) // 0Retorna 1 Se a matriz for classificada em ordem ascendente, -1 se a ordem descendente e 0 se não derrubada - opção 2 mais curta
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
⬆️ de volta ao topo
Converta a sequência de case camel (Ex.'AppleStore ',' Timcook ') em Case Snake (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?☔️? " )
⬆️ de volta ao topo
Flip tira uma função como um argumento, depois faz o primeiro argumento o último.
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
⬆️ de volta ao topo
Retorna os vizinhos de um vértice
public func neighborsForIndex ( _ index : Int ) -> [ VertexType ] {
return edges [ index ] . map ( { self . vertices [ $0 . v ] } )
}
⬆️ de volta ao topo
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.
