Swift Loops, Strings, and Characters: Tips and Tricks

Classified in Computers

Written on November 24, 2023 in English with a size of 6.55 KB

Loops

// Convert String to Array of Strings containing 1 Character
var strArr = str.characters.map { String($0) }
// Join Array of Strings into 1 String
var str = strArr.joined(separator: "")
// Split String into array
import Foundation
let fullNameArr = fullName.components(separatedBy: " ")
// Split String into Characters
let subsequences = str.characters.split(separator: " ") // Returns array of Subsequence, not array of strings
String(subsequences[0]) // to use as string
// Convert String to Array of Characters
sChars = Array(string.characters)

// Need to have String.Index to access individual characters in a String
str.startIndex // Index corresponding to 0
str.endIndex // Index corresponding to N-1
// Advance 5 from the start
let s = "abcdef"
let idx = s.index(s.startIndex, offsetBy: 5)
s[idx] // → "f" (the Character, not the String)
// From the back
let s = "abcdef"
let rIdx = s.index(s.endIndex, offsetBy: -1)
s[rIdx] // → "f" (the Character, not the String) // Note, endIndex is not valid subscript
let rIdx2 = s.index(rIdx, offsetBy: -1)
s[rIdx2] // → "e" (the Character, not the String)
// Safe index
let safeIdx = s.index(s.startIndex, offsetBy: 400, limitedBy: s.endIndex)
safeIdx // → nil
// String slicing using Index
s[s.startIndex..

// Check if Char is alphanumeric lower case
extension Character {
var isAlphanumeric: Bool {
return (self >= "a" && self <= "z") || (self >= "0" && self <= "9") // Add "A" and "Z" if needed
}

// Swap
var b = [1,2,3,4,5]
(b[0], b[1]) = (b[1], b[0])
swap(&b[0], &b[1]) // This returns an error if same address [e.g. same index], so do not use!
// Generate random
var k: Int = random() % 10 // 0 - 9
// Inout
func swap(wordArr: inout Array, i: Int, j: Int) {
// Modify wordArr, the original array passed will also be modified on return of this function (copy-in copy-out)
}
// Reserve capacity in Arrays / Dictionary to avoid overhead of resizing
var longestSubstring = [Character: Int](minimumCapacity: 256)
var dict = [Int:Int]()
dict.reserveCapacity(256)

1
log N
N
N log N
N^2
2^N
N!
// Big O Other Notes
// 1. Doubling
1+2+4+8+16+...N
-> almost 2N (exactly 2N-1)
This can also be seen as
2^0 + 2^1 + 2^2 + ... 2^N
-> 2^(N+1) - 1 (still same as above, because N = this 2^N)
// 2. Halving (this is same as above, but treated looked at different perspective
N + (N/2) + (N/4) + (N/8) + ... + 1
-> almost 2N
if N not included
(N/2) + (N/4) + (N/8) + ... + 1
-> almost N
// 3. Sequence
1+2+3+4+5+...N
-> (N(N+1)) / 2
// 4. Recursion
branches ^ depth
e.g. if two branches like fibonacci - 2^N, where N is depth
// 5. Nested loops, such that 2nd loop decreases by one
e.g. 5+4+3+2+1 for each loop
so (N(N+1)) / 2 -> O(N^2)
// 6. Loop, such that i value decreases or advances by twice
log N

A heap with n nodes has height h = floor(log_2(n))
If the lowest level is completely full, then that level contains 2^h nodes.
The rest of the tree above it contains 2^h - 1nodes.
*The leaf nodes are always located at array indices floor(n/2) to n-1, where n = number of nodes
*To create heap from array, you can start from:
(n/2) - 1, up to 0
since (n/2) up to (n-1) are the leaf nodes, so no need to process them
* Number of leaf nodes of a complete binary tree (e.g. heap)
= ceil ( n/2 )

// When computing mid for binary search / merge sort, use the following code in order to avoid Int Overflow
let mid = left + ((right - left) / 2)
// Reallocation factor in Swift
array: 2
string: 2
dict: 1.333

Tags:

Swift loops strings characters