Welcome, aspiring Scala enthusiasts and seasoned programmers alike! Today, we embark on a journey through the intricacies of Scala, a language that seamlessly blends object-oriented and functional programming paradigms. As a Scala assignment helper, it's my pleasure to guide you through some stimulating challenges and their elegant solutions.
Let's kick things off with a problem that delves into Scala's powerful pattern matching capabilities:
Problem 1: Parsing JSON in Scala
Imagine you're tasked with parsing a JSON string representing a list of employees, where each employee has attributes like name, age, and department. Your goal is to extract the names of employees who belong to the Engineering department.
Here's the JSON string:
val jsonString =
"""
|[
| {"name": "Alice", "age": 30, "department": "Engineering"},
| {"name": "Bob", "age": 35, "department": "Marketing"},
| {"name": "Charlie", "age": 40, "department": "Engineering"}
|]
""".stripMargin
Your task is to write a function getEngineers(json: String): List[String] that takes this JSON string as input and returns a list of names of engineers.
Solution:
import io.circe.parser._
import io.circe.generic.auto._
def getEngineers(json: String): List[String] = {
decode[List[Employee]](json)
.getOrElse(List.empty)
.filter(_.department == "Engineering")
.map(_.name)
}
case class Employee(name: String, age: Int, department: String)
// Usage
val engineers = getEngineers(jsonString)
println(engineers) // Output: List("Alice", "Charlie")
In this solution, we leverage the Circe library for JSON parsing and case classes for easy manipulation of JSON data. The getEngineers function first decodes the JSON string into a list of Employee objects, filters out those belonging to the Engineering department, and finally extracts their names.
Now, let's dive into another challenging problem that showcases the elegance of Scala's functional programming features:
Problem 2: Implementing a Trie in Scala
A Trie (pronounced "try") is a tree-like data structure used for efficient retrieval of keys in a dataset of strings. Your task is to implement a Trie in Scala, supporting the following operations:
- insert(word: String): Inserts a word into the Trie.
- search(word: String): Boolean: Returns true if the word exists in the Trie, false otherwise.
- startsWith(prefix: String): Boolean: Returns true if there is any word in the Trie that starts with the given prefix.
Solution:
class Trie {
private class TrieNode(var isEnd: Boolean = false) {
val children = Array.fill (null)
}
private val root = new TrieNode()
def insert(word: String): Unit = {
var node = root
for (char <- word) {
val index = char - 'a'
if (node.children(index) == null)
node.children(index) = new TrieNode()
node = node.children(index)
}
node.isEnd = true
}
def search(word: String): Boolean = {
var node = root
for (char <- word) {
val index = char - 'a'
if (node.children(index) == null)
return false
node = node.children(index)
}
node.isEnd
}
def startsWith(prefix: String): Boolean = {
var node = root
for (char <- prefix) {
val index = char - 'a'
if (node.children(index) == null)
return false
node = node.children(index)
}
true
}
}
// Usage
val trie = new Trie()
trie.insert("programming")
trie.insert("program")
println(trie.search("program")) // Output: true
println(trie.search("programming")) // Output: true
println(trie.startsWith("prog")) // Output: trueIn this solution, we define a TrieNode class to represent each node in the Trie. The insert, search, and startsWith methods traverse the Trie according to the characters of the input string, efficiently handling insertions and queries.
These problems offer a glimpse into the depth and versatility of Scala, making it a language of choice for tackling complex programming tasks. Whether you're a student seeking assistance or a seasoned developer honing your skills, Scala has much to offer.
Stay tuned for more challenges and insights as we continue our journey into the fascinating world of Scala programming. And remember, mastering Scala is not just about solving problems—it's about embracing a mindset of elegance and expressiveness in your code. Happy coding!
