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.