Identify all Grand-Parent Nodes of each Node in a Map
Last Updated :
17 May, 2017
Given in input that has relationships between a person and their children, for all the people in this data, identify grandparents of all the people in the input.
Input: A map of all the people and their children
Map[String, Set[String]]
Output: A map of all people and their grandparents
Map[String, Set[String]]
Example:
Input
Map(A -> Set(B,C), B -> Set(D, C), C -> Set(E))
Output:
Map(D -> Set(A), C -> Set(A), E -> Set(A, B))
We strongly recommend you to minimize your browser and try this yourself first
Here we have iterate over each and every node in Map and find out the grand-parent of each child.
The idea is to use Recursion. But, it can be solved without Recursion too.
Lets see the Without Recursion solution first:
Solution 1 (Without Recursion):
Here we have to use Mutable Scala Map. Below is the Scala Code.
val input = Map("A" -> Set("B","C"), "B" -> Set("D", "C"), "C" -> Set("E"))
val output: scala.collection.mutable.Map[String, Set[String]]
= scala.collection.mutable.Map()
input.map(node => node._2.map(child =>
input.get(child).map(grandchildren =>
grandchildren.map{grandchild =>
if(output.keys.exists(_ == grandchild)) {
output.put(grandchild, output.get(grandchild).get ++ Set(node._1))
} else {
output.put(grandchild, Set(node._1))
}
}
)
))
Here we are iterating over every Node of Map and finding out the grandchildren of each child in node.This, will help us in creating a Map with Grand-Child and Grand-Parents relationship.
Solution 2 (With Recursion):
Here we can use Immutable Scala Map as we are using Recursion.
val input = Map("A" -> Set("B","C"), "B" -> Set("D", "C"), "C" -> Set("E"))
val output = findGrandparents(input)
def findGrandparents(family: Map[String, Set[String]]): Map[String, Set[String]] = {
family.foldLeft(Map[String, Set[String]]()){
case (grandParents, oneFamily) => {
val grandChildren: Set[String] = oneFamily._2.flatMap(member => family.get(member)).flatten
val res = grandChildren.map(child => {
grandParents.get(child) match {
case None =>(child -> Set(oneFamily._1))
case Some(x) => (child -> (x + oneFamily._1))
}
}).toMap
grandParents ++ res
}
Share your thoughts in the comments
Please Login to comment...