Numbers:1,2,3
Exclude:1,2

Empty

Numbers:1,2,3,4,5,6
Exclude:1,2;2,4;3,5;4,6

Empty

Numbers:1,2,3
Exclude:1,2;2,3

1,
2,
3,
13

object Main {

  def parseArgNumbers(argNumbers: String): List[Int] = argNumbers.split(",").map(s => s.toInt).toList

  def parseTuple(s : String) : (Int,Int) = {
    val sp = s.indexOf(",")
    (s.substring(0, sp).toInt, s.substring(sp + 1).toInt)
  }

  def parseExclude(argExclude: String): List[(Int,Int)] = argExclude.split(";").map(s => parseTuple(s)).toList

  def containsTuple(subNumbers: List[Int], pair: (Int, Int)): Boolean = {
    subNumbers.contains(pair._1) && subNumbers.contains(pair._2)
  }

  def contains(subNumbers: List[Int], excluded: List[(Int, Int)]): Boolean = {
    //for(pair <- excluded) {
    //  if (containsTuple(subNumbers,pair)) return true
    //}
    //false
    // TODO: I hope, breaking after 1st element of lazy collection will make perfomance
    return excluded.filter(pair => containsTuple(subNumbers,pair)).take(1).size == 1
  }

  def trickyCombinations(numbers: List[Int], excludes: List[(Int, Int)]): Unit = {
    val size = numbers.size
    for(i <- 1 to size) {
      printf(s"The combinations $i of $size\n")
      numbers.combinations(i).foreach(f => {
        if (!contains(f,excludes)) {
          for (v <- f) printf("%s,", v)
          printf("\n")
        }
      })
      printf("\n\n")
    }

  }

  def main(args : Array[String]) : Unit = {

    printf("\nNumbers : ")
    val argNumbers = "1,2,3,4,5" //scala.io.StdIn.readLine()

    printf("\nExclude : ")
    val argExclude = "1,2;2,3"   //scala.io.StdIn.readLine()

    println()

    val numbers = parseArgNumbers(argNumbers)
    val excludes = parseExclude(argExclude)

    trickyCombinations(numbers,excludes)

  }

}