1. Only one disk may be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack or on an empty rod.
3. No disk may be placed on top of a disk that is smaller than it.

Prints n moves in the Tower of Hanoi puzzle.

func tower_of_hanoi(_ n: Int) -> [[Int]] {
    var result: [[Int]] = []
    
    func helper(_ n: Int, _ src: Int, _ aux: Int, _ dst: Int) {
        if n == 1  {
            result.append([src, dst])
            return
        }
        
        helper(n - 1, src, dst, aux)
        result.append([src, dst])
        helper(n - 1, aux, src, dst)
    }
    
    helper(n, 1, 2, 3)
    
    return result
}

print(tower_of_hanoi(3))

Let L denote the left child.

Let R denote the right child.

Let P denote the parent and position.

To easily remember tree traversal orders, pay attention to the position of P in the following strings.

When P is in the center, it is In Order. When it is first, it is Pre Order. And when it is last, it is Post Order.

L – P – R | In Order

P – L – R | Pre Order

L – R – P | Post Order

Note that L and R are always in the same order. The only element changing order is the parent.

In Order

leftChild -> parent -> rightChild

Integer values come out in order when traversing a Binary Search Tree.

Pre Order

parent -> leftChild -> rightChild

Traverse parent first (pre).

Post Order

leftChild -> rightChild -> parent

Traverse parent last (post).

Code

class BST {
    var value: Int?
    var left: BST?
    var right: BST?
    
    init(value: Int) {
        self.value = value
        left = nil
        right = nil
    }
}

// O(n) time | O(n) space, because we're storing all values in array
// Note: If were were just printing values, space will be O(h), where
// h is the height of the tree.

func inOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    inOrderTraversal(tree: node.left, array: &array)
    array.append(value)
    inOrderTraversal(tree: node.right, array: &array)
    
    return array
}

func preOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    array.append(value)
    preOrderTraversal(tree: node.left, array: &array)
    preOrderTraversal(tree: node.right, array: &array)
    
    return array
}

func postOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
    guard let node = tree, let value = node.value else { return array }
    
    postOrderTraversal(tree: node.left, array: &array)
    postOrderTraversal(tree: node.right, array: &array)
    array.append(value)
    
    return array
}

func selectionSort(array: inout [Int]) -> [Int] {
    for i in 0 ..< array.count - 1 {
        var indexOfSmallestValue = i
        for j in i ..< array.count {
            indexOfSmallestValue = array[j] < array[indexOfSmallestValue] ? j : indexOfSmallestValue
        }
        array.swapAt(i, indexOfSmallestValue)
    }
    return array
}

The bubbling operation takes \(O(n)\) time and this operation is performed \(n\) times. Therefore, Bubble Sort runs in \(O(n^2)\) time.

The swaps are performed in place. If the given array is mutable, the algorithm can be performed in constant space.

func bubbleSort(_ array: inout [Int]) -> [Int] {
    for _ in 0.. array[i+1] {
                array.swapAt(i, i+1)
            }
        }
    }
    return array
}

Here’s a couple of real world optimizations.

Add a counter to avoid checking the part of the list that has already been sorted.

func bubbleSort(_ array: inout [Int]) -> [Int] {
    var counter = 0
    for _ in 0.. array[i+1] {
                array.swapAt(i, i+1)
            }
        }
        counter += 1
    }
    return array
}

Add a bool to return the list if it is already sorted.

func bubbleSort(_ array: inout [Int]) -> [Int] {
    var counter = 0
    var inOrder = false
    while !inOrder {
        inOrder = true
        for i in 0.. array[i+1] {
                array.swapAt(i, i+1)
                inOrder = false
            }
        }
        counter += 1
    }
    return array
}

The sequence is as follows:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55

The sequence follows the pattern of:

I’ve written three algorithms. Each has pros and cons.

First I want to create a simple Error for a case where \(n\) is out of bounds. We will use this with all our algorithms.

enum FibError: Error {
    case OutOfBounds
}

Our first algorithm will use an iterative approach.

func fib(of n: Int) throws -> Int {
    guard n > 0 else { throw FibError.OutOfBounds }
    guard n > 2 else { return 1 }
    var result = 0, nMinusOne = 1, nMinusTwo = 1
    for _ in 3...n {
        result = (nMinusOne + nMinusTwo)
        nMinusTwo = nMinusOne
        nMinusOne = result
    }
    return result
}

Our second algorithm will use a recursive approach. Notice how this algorithm is easier to read, but slightly more difficult to conceive.

func fib(of n: Int) throws -> Int {
    guard n > 0 else { throw FibError.OutOfBounds }
    guard n > 2 else { return 1 }
    return try fib(of: n - 1) + fib(of: n - 2)
}

Our third algorithm is a more optimal version of the recursive algorithm. Because of the nature of the recursive function calls, and more specifically the operation try fib(of: n - 1) + fib(of: n - 2), we use a dictionary to avoid repetitive function calls.

var sequenceValues = [Int: Int]()

func fib(of n: Int) throws -> Int {
    guard n > 0 else { throw FibError.OutOfBounds }
    guard n > 2 else { return 1 }
    var value: Int
    if sequenceValues[n] != nil  {
        value = sequenceValues[n]!
    } else {
        value = try fib(of: n - 1) + fib(of: n - 2)
        sequenceValues[n] = value
    }
    return value
}

I hope this was helpful!

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