Find possible subunits of size <= 8

idol.scala

sealed abstract class Idol(val id: String)

case class Subunit(name: String, members: Set[Idol])

object Subunit {
  def apply(name: String, members: Idol*): Subunit = apply(name, members.toSet)
}

case class IdolUnit(members: Set[Idol], subunits: Seq[Subunit])

case object Akari extends Idol("akari")
case object Aoi extends Idol("aoi")
case object Hikari extends Idol("hikari")
case object Hinaki extends Idol("hinaki")
case object Ichigo extends Idol("ichigo")
case object Juri extends Idol("juri")
case object Kaede extends Idol("kaede")
case object Kii extends Idol("kii")
case object Kokone extends Idol("kokone")
case object Madoka extends Idol("madoka")
case object Maria extends Idol("maria")
case object Mikuru extends Idol("mikuru")
case object Miyabi extends Idol("miyabi")
case object Mizuki extends Idol("mizuki")
case object Otome extends Idol("otome")
case object Ran extends Idol("ran")
case object Rin extends Idol("rin")
case object Sakura extends Idol("sakura")
case object Seira extends Idol("seira")
case object Shion extends Idol("shion")
case object Sora extends Idol("sora")
case object Sumire extends Idol("sumire")
case object Yurika extends Idol("yurika")

val subunits: List[Subunit] = List(
  Subunit("STAR☆ANIS", Ichigo, Aoi, Ran, Otome, Yurika, Sakura, Kaede, Mizuki),
  Subunit("AIKATSU8 2014", Ichigo, Seira, Mizuki, Mikuru, Sora, Maria, Otome, Yurika),
  Subunit("AIKATSU8 2015", Ichigo, Aoi, Ran, Yurika, Sakura, Mizuki, Akari, Sumire),
  Subunit("Vampire Mystery", Akari, Sumire, Hinaki, Juri),
  Subunit("Soleil", Ichigo, Aoi, Ran),
  Subunit("Tristar", Mizuki, Kaede, Yurika),
  Subunit("Powax2PuRiRiN", Otome, Sakura, Shion),
  Subunit("Luminas", Akari, Sumire, Hinaki),
  Subunit("Vanilla Chili Pepper", Juri, Madoka, Rin),
  Subunit("Vampire Academy", Yurika, Mizuki, Sumire),
  Subunit("Tsunagaru Line", Ichigo, Akari, Mizuki),
  Subunit("2wingS", Ichigo, Seira),
  Subunit("WM", Mizuki, Mikuru),
  Subunit("DansingDiva", Sumire, Rin),
  Subunit("Jonetsu Jalapeño", Juri, Hinaki),
  Subunit("Skips♪", Akari, Madoka),
  Subunit("Amafuwa☆Nadeshiko", Miyabi, Kokone),
  Subunit("Producers", Aoi, Kii),
  Subunit("Ikenai Keiji", Aoi, Shion),
  Subunit("Oshare Kaito Swallowtailshin", Ichigo, Otome),
  Subunit("Fushigi no Kuni no Alice", Ichigo, Shion),
  Subunit("ChocoPop Tantei", Seira, Kii),
  Subunit("Tsuki no Sabaku no Gensokyoku", Ran, Sora),
  Subunit("Aikatsu! Sensei", Akari, Juri),
  Subunit("Tsunagaru Baton", Ichigo, Akari),
  Subunit("Otome to Hinaki no Mattari Saka", Otome, Hinaki),
  Subunit("Gogo wa Ichi Ichi Ichigo Kibun", Ichigo),
  Subunit("Chika no Taiyo", Hikari)
)

val maxUnitSize = 8
val minSmile = 7

val availableIdols: Set[Idol] = Set(
  Akari,
  Ichigo,
  Maria,
  Yurika,
  Sumire,
  Rin,
  Seira,
  Shion,
  Sora,Ran,
  Kii,
  Mikuru,
  Mizuki,
  Kokone
)

val availableSubunits: Seq[Subunit] = subunits
  .filter(_.members.subsetOf(availableIdols))

val units: Seq[IdolUnit] = for {
  smileCount: Int <- minSmile to availableSubunits.size
  possibleSubunits: Seq[Subunit] <- availableSubunits.combinations(smileCount)
  members: Set[Idol] = possibleSubunits.map(_.members).reduce(_ union _)
  if members.size <= maxUnitSize
} yield IdolUnit(members, possibleSubunits)

println("Available idols:")
println(availableIdols.mkString(", "))
println("=========")

for {
  unit <- units.sortBy(-_.members.size)
} {
  println(unit.subunits.size)
  println(unit.members.mkString(", "))
  println(unit.subunits.map(_.name).mkString("(", ", ", ")"))
  println("=========")
}