You can easily solve this problem iteratively, i.e. looping through the string starting from its last character. But how about solving it recursively?

First, we can define the desired function as printReverse(str[0...n-1]), where str[0] represents the first character in the string. Then we can accomplish the given task in two steps:

1. printReverse(str[1...n-1]): print the substring str[1...n-1] in reverse order.
2. print(str[0]): print the first character in the string.

Notice that we call the function itself in the first step, which by definition makes the function recursive.

Here is the code snippet:

func printReverse(_ string: String) {
    let charArray = Array(string)
    helper(charArray, index: 0)
}

func helper(_ string: [Character], index: Int) {
    guard index < string.count else {
        return
    }
    
    helper(string, index: index + 1)
    print(string[index])
}

Reverse String

Write a function that reverses a string. The input string is given as an array of characters char[].

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

You may assume all the characters consist of printable ascii characters.

Example 1:

Input: ["h","e","l","l","o"]
Output: ["o","l","l","e","h"]

Example 2:

Input: ["H","a","n","n","a","h"]
Output: ["h","a","n","n","a","H"]

Here's my solution. I noticed it's only necessary to recurse halfway through the input.

    func reverseString(_ s: inout [Character]) {
        helper(&s, index: 0)
    }
    func helper(_ s: inout [Character], index: Int) {
        guard index < s.count / 2 else {
            return
        }
        helper(&s, index: index + 1)
        s.swapAt(index, s.count - 1 - index)
    }

Resources

• https://www.geeksforgeeks.org/reverse-a-linked-list/

Time complexity is \(O(n)\) and space complexity is \(O(1)\). This method saves on space, since we only need to store the previous two Fibonacci numbers.

func fib(_ n: Int) -> Int? {
  if n < 1 { return nil }
  if n < 3 { return 1 }
  
  var i = 1
  var ii = 1
  var an = 0
  
  for _ in 3...n {
    an = i + ii
    ii = i
    i = an
  }
  
  return an
}

• Web Crawling
• Social Networking
• Network Broadcast
• Garbage Collection
• Model Checking
• Check Mathematical Conjectures
• Solving Puzzles and Games

References

• https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/
• https://www.raywenderlich.com/710-swift-algorithm-club-swift-breadth-first-search
• https://en.wikipedia.org/wiki/Breadth-first_search

References

• https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/
• https://www.raywenderlich.com/661-swift-algorithm-club-swift-depth-first-search
• https://en.wikipedia.org/wiki/Depth-first_search

• Efficient search algorithm. Time: \(O(log n)\) Space: \(O(1)\).
• Quickly find an element in a sorted list of elements.

References

• https://www.geeksforgeeks.org/binary-search/
• https://en.wikipedia.org/wiki/Binary_search_algorithm
• https://github.com/raywenderlich/swift-algorithm-club/tree/master/Binary%20Search

• Comparison based sorting algorithm.
• Always \(O(n*logn)\) runtime.
• Left child: \(2 * index + 1\). Right child: \(2* index + 2\). On \(0\) indexed array.
• MaxHeap used to sort in increasing order.
• Sorts in place. No need for creating a separate array.

References

• https://www.geeksforgeeks.org/heap-sort/
• https://en.wikipedia.org/wiki/Heapsort
• https://github.com/raywenderlich/swift-algorithm-club/tree/master/Heap%20Sort

• Splits list into sublists recursively and merges the sublists in order.
• Comparison sorting algorithm.
• Not an in-place sort. Must create temporary arrays.
• Runtime \(O(n*logn)\) in all three cases.
• Consumes \(O(n)\) space.

References

• https://www.geeksforgeeks.org/merge-sort/
• https://github.com/raywenderlich/swift-algorithm-club/tree/master/Merge%20Sort
• https://en.wikipedia.org/wiki/Merge_sort

• Comparison sorting algorithm.
• Uses divide-and-conquer approach.
• Utilizes a pivot. Sorting all numbers in the partition less than the pivot to the left, and all numbers greater to the right.
• Usually \(O(n*logn)\) runtime. But can be \(O(n^2)\) on sorted list with pivot chosen as the first or last index.
• Consumes \(O(logn)\) space for recursive stack calls.

Using Lomuto’s partitioning scheme

References

• https://www.geeksforgeeks.org/quick-sort/
• https://github.com/raywenderlich/swift-algorithm-club/tree/master/Quicksort
• https://en.wikipedia.org/wiki/Quicksort

• Non-comparitive sorting algorithm.
• Running time is \(O(d*(n+b))\), where \(d\) is the number of \(digits\), and \(b\) is the \(base\).
• Runtime of \(O(n)\) when we sort an array of integers with range from \(1 — n^c\), where \(c\) is a constant, if the numbers are represented in base \(n\); or every digit takes \(log_2(n)\) bits.
• Uses Counting Sort or Bucket Sort as a subroutine. We use the subroutine to sort one digit at a time.

References

• https://www.geeksforgeeks.org/radix-sort/
• https://en.wikipedia.org/wiki/Radix_sort