Recursive enumerations in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple recursive enum with indirect case

What is the output of this Swift code when printed?

Swift

enum BinaryTree {
    case empty
    indirect case node(Int, left: BinaryTree, right: BinaryTree)
}

let tree = BinaryTree.node(1, left: .empty, right: .node(2, left: .empty, right: .empty))

print(tree)

A empty

B node(1, left: node(2, left: empty, right: empty), right: empty)

C node(1, left: empty, right: node(2, left: empty, right: empty))

D node(2, left: empty, right: empty)

💡 Hint

Look at how the tree is constructed with left and right children.

The tree has root node 1 with left child empty and right child node 2 with empty children. Printing the enum shows the structure with cases and associated values.

🧠 Conceptual

intermediate

Understanding 'indirect' keyword in recursive enums

Why is the 'indirect' keyword necessary in recursive enumerations in Swift?

A It makes the enum cases mutable.

B It enables the enum to be used only with classes.

C It allows the enum to conform to protocols automatically.

D It tells Swift to store the enum case indirectly to avoid infinite size during compilation.

💡 Hint

Think about how recursive data structures are stored in memory.

Recursive enums can have infinite size if stored directly. The 'indirect' keyword tells Swift to store the case by reference, preventing infinite size and enabling recursion.

🔧 Debug

advanced

Identify the error in this recursive enum definition

What error will this Swift code produce?

Swift

enum List {
    case empty
    case node(Int, List)
}

A Runtime error: Stack overflow when creating a list.

B Compiler error: Recursive enum 'List' is not marked 'indirect'.

C No error, code compiles and runs fine.

D Compiler error: Missing associated value label.

💡 Hint

Check if the enum is marked 'indirect' for recursion.

Recursive enums must be marked 'indirect' to compile because the compiler needs to know to store the recursive case indirectly to avoid infinite size.

❓ Predict Output

advanced

Output of recursive enum with computed property

What is the output of this Swift code?

Swift

indirect enum Expression {
    case number(Int)
    case addition(Expression, Expression)

    func evaluate() -> Int {
        switch self {
        case .number(let value):
            return value
        case .addition(let left, let right):
            return left.evaluate() + right.evaluate()
        }
    }
}

let expr = Expression.addition(.number(3), .addition(.number(4), .number(5)))
print(expr.evaluate())

A 12

B 9

C Compilation error

D 7

💡 Hint

Evaluate the expression tree from the leaves up.

The expression represents 3 + (4 + 5). Evaluating recursively sums 3 + 9 = 12.

📝 Syntax

expert

Correct syntax for marking only one case as indirect

Which option correctly marks only the recursive case as indirect in this enum?

Swift

enum Tree {
    case leaf(Int)
    case node(Tree, Tree)
}

A

enum Tree {
    case leaf(Int)
    indirect case node(Tree, Tree)
}

B

indirect enum Tree {
    case leaf(Int)
    case node(Tree, Tree)
}

C

enum Tree {
    indirect case leaf(Int)
    case node(Tree, Tree)
}

D

enum Tree {
    case leaf(Int)
    case node(indirect Tree, indirect Tree)
}

💡 Hint

Only the recursive case needs the 'indirect' keyword before it.

Option A correctly marks only the 'node' case as indirect. Option A marks the whole enum indirect, which is valid but not what the question asks. Option A incorrectly marks the non-recursive case. Option A uses invalid syntax.