Recursive enumerations in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a recursive enum case.

Swift

enum ArithmeticExpression {
    case number(Int)
    indirect case [1](ArithmeticExpression, ArithmeticExpression)
}

Drag options to blanks, or click blank then click option'

Amultiply

Bdivide

Csubtract

Daddition

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the 'indirect' keyword before the recursive case.

Using a non-arithmetic case name.

The indirect keyword marks the case as recursive. Here, addition is the recursive case combining two expressions.

2fill in blank

medium

Complete the code to evaluate the recursive enum expression.

Swift

func evaluate(_ expression: ArithmeticExpression) -> Int {
    switch expression {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) [1] evaluate(right)
    }
}

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong arithmetic operator.

Not recursively calling evaluate on both sides.

The evaluate function adds the results of the left and right expressions using the + operator.

3fill in blank

hard

Fix the error in the recursive enum declaration by completing the code.

Swift

enum BinaryTree {
    case leaf(Int)
    [1] case node(BinaryTree, BinaryTree)
}

Drag options to blanks, or click blank then click option'

Aindirect

Bfinal

Cstatic

Dlazy

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the 'indirect' keyword causes a compiler error.

Using unrelated keywords like 'static' or 'lazy'.

The indirect keyword is required before the recursive case node to allow the enum to reference itself.

4fill in blank

hard

Fill both blanks to create a recursive enum with indirect keyword and a recursive case.

Swift

indirect enum [1] {
    case value(Int)
    case [2]([1], [1])
}

Drag options to blanks, or click blank then click option'

AExpression

BTree

CNode

DBinaryTree

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same name for enum and case.

Not matching the recursive case parameter types to the enum name.

The enum is named Tree and the recursive case is Node which takes two Tree values.

5fill in blank

hard

Fill all three blanks to complete the recursive enum and a function that counts nodes.

Swift

indirect enum [1] {
    case leaf(Int)
    case branch([1], [1])
}

func countNodes(_ tree: [1]) -> Int {
    switch tree {
    case .leaf(_):
        return 1
    case .branch(let left, let right):
        return countNodes(left) [2] countNodes(right) + 1
    }
}

Drag options to blanks, or click blank then click option'

ATree

B+

CTreeNode

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using different enum names in function parameters.

Using subtraction instead of addition when counting nodes.

The enum is named Tree. The function recursively counts nodes by adding counts of left and right branches plus one for the current branch.

Practice

1. What does the indirect keyword do in a Swift recursive enumeration?

easy

A. It allows the enum to refer to itself recursively.

B. It makes the enum immutable.

C. It converts the enum into a class.

D. It prevents the enum from being used in switch statements.

Solution

1. Step 1: Understand the role of indirect

   The indirect keyword tells Swift that the enum cases can hold references to the enum itself, enabling recursion.

2. Step 2: Identify what recursion means in enums

   Recursion means an enum case can contain another instance of the same enum, which requires indirect to avoid infinite size.

3. Final Answer:

   It allows the enum to refer to itself recursively. -> Option A

4. Quick Check:

   indirect enables recursion = C [OK]

Hint: Remember: indirect means self-reference allowed [OK]

Common Mistakes:

• Thinking indirect makes enum immutable
• Confusing indirect with class conversion
• Believing indirect disables switch usage

2. Which of the following is the correct syntax to declare a recursive enum case in Swift?

easy

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

B. enum Tree { case leaf(Int); case node(Tree, Tree) }

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

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

Solution

1. Step 1: Recall how to declare recursive enums

   Swift allows marking the whole enum as indirect to enable recursion for all cases.

2. Step 2: Check each option's syntax

   The syntax indirect enum Tree { case leaf(Int); case node(Tree, Tree) } correctly enables recursion by marking the whole enum indirect. Other options either lack the keyword, apply it only to non-recursive cases (leaving recursive case without), or contain syntax errors such as missing the case keyword.

3. Final Answer:

   indirect enum Tree { case leaf(Int); case node(Tree, Tree) } -> Option D

4. Quick Check:

   Whole enum indirect = A [OK]

Hint: Use 'indirect enum' for all recursive cases [OK]

Common Mistakes:

• Omitting indirect keyword
• Placing indirect only on some cases incorrectly
• Using indirect outside enum declaration

3. Given the recursive enum below, what is the output of print(tree.countLeaves())?

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

    func countLeaves() -> Int {
        switch self {
        case .leaf(_): return 1
        case let .node(left, right):
            return left.countLeaves() + right.countLeaves()
        }
    }
}

let tree = Tree.node(.leaf(1), Tree.node(.leaf(2), .leaf(3)))

medium

A. 1

B. 2

C. 3

D. 4

Solution

1. Step 1: Understand the tree structure

   The tree is: node(leaf(1), node(leaf(2), leaf(3))). It has three leaves: 1, 2, and 3.

2. Step 2: Count leaves recursively

   The countLeaves function returns 1 for each leaf and sums counts for nodes. So total leaves = 1 + (1 + 1) = 3.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Leaves counted = 3 [OK]

Hint: Count leaf nodes recursively for total leaves [OK]

Common Mistakes:

• Counting nodes instead of leaves
• Misunderstanding recursive calls
• Forgetting to sum both sides

4. Identify the error in this recursive enum declaration:

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

medium

A. Missing indirect keyword for recursion.

B. Enum cases cannot have associated values.

C. The enum must be a class to be recursive.

D. The case end should have an associated value.

Solution

1. Step 1: Check for recursion support

   The enum List has a case node(Int, List) which refers to itself, so it is recursive.

2. Step 2: Verify use of indirect

   Swift requires marking recursive enums or cases with indirect. This enum lacks it, causing a compile error.

3. Final Answer:

   Missing indirect keyword for recursion. -> Option A

4. Quick Check:

   Recursive enum needs indirect = B [OK]

Hint: Add indirect to recursive enums or cases [OK]

Common Mistakes:

• Ignoring indirect keyword requirement
• Thinking recursion needs classes
• Assuming all enum cases need associated values

5. How would you modify this recursive enum to safely calculate the depth of a tree, returning 0 for leaves and the maximum depth for nodes?

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

    func depth() -> Int {
        // Your code here
    }
}

hard

A. Return 1 for leaf, and sum depths of left and right nodes.

B. Return 0 for leaf, and 1 + max depth of left and right nodes.

C. Return 0 for leaf, and sum depths of left and right nodes.

D. Return 1 for leaf, and 1 + min depth of left and right nodes.

Solution

1. Step 1: Define depth for leaf nodes

   Leaves have depth 0 because they have no children.

2. Step 2: Define depth for node cases

   Nodes have depth 1 plus the maximum depth of their two child trees.

3. Final Answer:

   Return 0 for leaf, and 1 + max depth of left and right nodes. -> Option B

4. Quick Check:

   Depth = 0 for leaf, max + 1 for node = A [OK]

Hint: Depth = 0 leaf, 1 + max child depth node [OK]

Common Mistakes:

• Using sum instead of max for node depth
• Returning 1 for leaf depth incorrectly
• Using min instead of max for node depth