30-seconds-of-swift-code

Welcome to 30-seconds-of-swift-code!

A Swift implementation of 30-seconds-of-code: A curated collection of useful Swift 4 snippets that you can understand in 30 seconds or less.

• Use Ctrl + F or command + F to search for a snippet.

Note:- This is in no way affiliated with the original 30-seconds-of-code.

If you've come here from JavaScript land then you should be aware that this project uses Swift 4, therefore not all snippets will work as expected on every system. You'll need to check your Swift version by going to Project and then following the steps below.

If you need help installing the latest stable release of Swift 4 check out swift.org. If you run into trouble make sure you check out Stackoverflow.

This project contains plenty of useful snippets which can help beginners and newcomers quickly ramp-up their skills on Swift 4.

Table of contents

📚 List

➗ Math

🗃 Object

📜 String

📚 List

bubble sort

BubbleSort is a sorting algorithm that uses the technique of repeatedly comparing and swapping the adjacent elements if they are in the wrong order.

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]

⬆️ Back to top

chunk

Chunks an array into smaller arrays of a certain size.

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"]]

⬆️ Back to top

every_nth

Returns every nth element in a given list and a new list is created that contains every nth element of the given list.

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]

⬆️ Back to top

filter bools

Remove every value that's not a Boolean.

func filterBools(_ inputArr: [Any]) -> [Any] {
    return inputArr.compactMap { $0 as? Bool }
    
}

filterBools([false, 2, "lol", 3, "a", "s", 34, false, true]) //[false, false, true]

⬆️ Back to top

count occurrences

Count occurrences of a string in an array.

func countOccurrences(arr: [String], into: String) -> Int {
    return arr.reduce(0) { $1 == into ? $0 + 1 : $0 }
}

countOccurrences(arr: ["FOO", "FOO", "BAR"], into: "FOO") //2

⬆️ Back to top

deep flatten

Deep flattens a list with recursion.

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]

⬆️ Back to top

difference

Return element(s) not contained in both of the given arrays (ie. elements only contained in one array and not both.)

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

⬆️ Back to top

duplicates

Check for duplicate elements in a given array.

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

⬆️ Back to top

insertion sort

Insertion Sort algorithm--inspired by 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]

⬆️ Back to top

Swift Standard Library Sort

Link to Official Apple Developer Documentation - 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"]

⬆️ Back to top

fisher yates shuffle

Fisher-Yates algorithm aka Knuth shuffle to shuffle an array creates a uniform shuffle of the array where each permutation is equally likely in O(n) time.

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]

⬆️ Back to top

generic flatten

Takes an array of arrays as input and transforms it to a flattened array of its type. ( handles optionals )

/// 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]

⬆️ Back to top

comma separated

Takes an array of strings and returns a single string with each element from the input list separated by commas.

/// 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"

⬆️ Back to top

most frequent

Takes an array and returns the most frequent element that appears in the array. The type of elements in the array must conform 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

⬆️ Back to top

➗ Math

average

Returns the average of two or more doubles in an array.

func average(arr: [Double]) -> Double {
    return arr.reduce(0, +)/Double(arr.count)
}

average(arr: [5, 4, 3, 2, 1]) //3

⬆️ Back to top

factorial

Calculates the factorial of a number.

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

⬆️ Back to top

gcd

Calculates the greatest common divisor between two integers with recursion.

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)

⬆️ Back to top

lcm1

Returns the least common multiple of two integers using the gcd function above.

func lcm1(num1: Int, num2: Int) -> Int {
    return abs(num1 * num2) / gcd(num1: num1, num2: num2)
}

lcm1(num1: 12, num2: 7) //84

⬆️ Back to top

lcm2

Least common multiple of an array using the first lcm.

func lcm2(arr1: [Int]) -> Int {
    return arr1.reduce(1) { lcm1(num1: $0, num2: $1) }
}

lcm2(arr1: [4, 3, 2]) //12

⬆️ Back to top

max n

Returns the maximum element from the provided array.

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

⬆️ Back to top

min n

Returns the minimum integer from an array without the built-in .min() function (used in examples to compare results.)

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

⬆️ Back to top

calc median

One way of calculating the median of an array of integers.

func calcMedian(arr: [Int]) -> Float {
    return Float(arr.sorted(by: <)[arr.count / 2])
}

calc better median

Better way of calculating the median of an array of integers.

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

radians to degrees

Convert an angle from radians to degrees.

func radiansToDegrees(_ angle: Double) -> Double {
    return angle * 180 / .pi
}

radiansToDegrees(4) // 229.183

⬆️ Back to top

🗃 Object

all unique

Checks a flat list for all unique values, returning True if list values are all unique and False if list values aren't all unique.

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

⬆️ Back to top

just keys

Function which accepts a dictionary of key-value pairs and returns a new array of just the keys.

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]

⬆️ Back to top

just values

Function which accepts a dictionary of key-value pairs and returns a new array of just the values.

func justValues(dict: Dictionary<AnyHashable, AnyHashable>) -> [AnyHashable] {
    return Array(dict.values)
}

justValues(dict: dict) //[Olaf, Mushu, Fleeko]

⬆️ Back to top

📜 String

bytes from string

Get bytes of a string.

func bytes(_ str: String) -> Int {
    return str.utf8.count
}

bytes("Hello")

⬆️ Back to top

capitalize first

Capitalizes the first letter of a string, leaving the rest the same.

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

⬆️ Back to top

capitalize every word

Capitalizes the first letter of every word in a 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!

⬆️ Back to top

count vowels

Retuns number of vowels in provided string.

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

⬆️ Back to top

lower case first letter of first word

Decapitalizes the first letter of the first word in a 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...

⬆️ Back to top

is lower case

Return true if any character in a string is capitalized.

func isLowerCase(str: String) -> Bool {
    return str == str.lowercased()
}

isLowerCase(str: "I LOVE CHRISTMAS") //false
isLowerCase(str: "<3 lol") //true

⬆️ Back to top

is upper case

Checks that each character in a string is uppercase.

func isUpperCase(str: String) -> Bool {
    return str == str.uppercased()
}

isUpperCase(str: "LOLOLOL") //true
isUpperCase(str: "lmao") //false
isUpperCase(str: "Rofl") //false

⬆️ Back to top

palindrome

Returns True if the given string is a palindrome, False if otherwise.

func palindrome(str: String) -> Bool {
    return str.lowercased() == String(str.reversed()).lowercased()
}

palindrome(str: "racecar") //true
palindrome(str: "Madam") //true
palindrome(str: "lizzie") //false

⬆️ Back to top

anagram

Returns True if the 2 given strings are perfect anagrams of each other, False if otherwise.

/// 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

⬆️ Back to top

drop

Returns a new array with n elements removed from the left.

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)

array to csv

Returns a CSV-String created from 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"

flip

Returns the given function with fliped arguments.

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

⬆️ Back to top

drop right while

Removes elements from the end of an array until the passed function returns 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]

⬆️ Back to top

filter non unique

Filters out the non-unique values in a list

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"]

⬆️ Back to top

snake

Returns a new string in snake case

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"

⬆️ Back to top

simple_snake_case

Returns a new string in snake case

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)

⬆️ Back to top

first-unique-character

Returns first unique character in a 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"

⬆️ Back to top

repeating

Prints a string N times without using loops.

func repeating(_ repeatedValue: String, count: Int) {
    guard count > 0 else {
        return
    }
    
    print(repeatedValue)
    
    repeating(repeatedValue, count: count - 1)
}

repeating("Text", count: 5)

⬆️ Back to top

byte-size

Returns length of string in bytes

func stringLenghtInBytes(string: String) -> Int {
    return (string as NSString).length
}

stringLenghtInBytes("Hello")

⬆️ Back to top

nth element

Returns every nth element from given list.

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" ]

⬆️ Back to top

is sorted

Returns 1 if array is sorted in ascending order, -1 if descending order, and 0 if unsorted

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

is sorted 2

Returns 1 if array is sorted in ascending order, -1 if descending order, and 0 if unsorted - OPTION 2 shortest

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

⬆️ Back to top

camel case string to snake case

Convert camel case string (ex.'appleStore', 'TimCook') to snake case (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🍁☔️🤖")

⬆️ Back to top

Flip

Flip takes a function as an argument, then makes the first argument the last.

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

⬆️ Back to top

Graph

Returns the neighbors of a vertex

public func neighborsForIndex(_ index: Int) -> [VertexType] {
    return edges[index].map({self.vertices[$0.v]})
}

⬆️ Back to top

Contributors

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.