Adaface Sample Kotlin Questions

In Kotlin, you are tasked with creating a function executeTasksSequentially that runs a list of suspendable tasks sequentially within a coroutine context. Each task is a lambda function that can perform an asynchronous operation and potentially throw an exception. The function should handle these exceptions and continue executing the remaining tasks. However, a crucial line is missing in the function implementation, and you need to identify which line correctly completes it.
            
            Here's the incomplete function:

This function is particularly useful in scenarios where multiple asynchronous tasks need to be run in order, such as processing a sequence of network requests or database transactions.

A: task.invoke()
            B: withContext(Dispatchers.IO) { task() }
            C: async { task() }.await()
            D: launch { task() }.join()
            E: task()
            F: delay(1000); task()

In Kotlin, you are asked to complete the implementation of a function searchNodeByName which recursively searches for a node by its name within a tree structure represented by instances of the data class Node(val name: String, val children: List<Node>). However, a crucial line is missing in the implementation, and your task is to identify which line correctly completes the function.
            
            Here's the incomplete function:

A: return searchNodeByName(it, nodeName)
            B: if (searchNodeByName(it, nodeName) != null) return searchNodeByName(it, nodeName)
            C: try { return searchNodeByName(it, nodeName) } catch (e
            D: if (it.name == nodeName) return it
            E: it.name == nodeName
            F: searchNodeByName(it, nodeName)

In Kotlin, you are tasked with designing a system that manages software dependencies. Each software package is represented by a Package data class, which includes a name and a list of dependencies (other Package objects). The main function, resolveDependencies, should recursively gather all unique dependencies for a given package, including dependencies of dependencies, and return them in a set to avoid duplication.
            
            Here's the initial setup for the data classes and function:

Consider the following structure of packages with nested dependencies:

If println(resolveDependencies(packageE)) is called, what is the expected output?

What does the following Kotlin code print?