def concat(A: Set[String], B: Set[String]) : Set[String] =

  for (x <- A ; y <- B) yield x ++ y

def pow(A: Set[String], n: Int) : Set[String] = n match {

  case 0 => Set("")

  case n => concat(A, pow(A, n - 1))

}

def powT(A: Set[String], n: Int, acc: Set[String] = Set("")) : Set[String] = 

  n match {

    case 0 => acc

    case n => powT(A, n - 1, concat(acc, A))

  }

val A = Set("a", "b", "c", "d", "e")

val B = Set("a", "b", "c", "d", "")

pow(A, 4).size

pow(B, 4).size

powT(A, 4).size

powT(B, 4).size

val C = Set("a", "b")

pow(C, 100).size

powT(C, 100000)  

val B = Set("aaa", "aaaa")

concat(A, B).size                     // -> 3 

val A = Set("1", "2", "3", "")

val B = Set("1", "2", "3", "4", "5", "6", "")

concat(A, B).size                     // -> 28 

pow(B, 3).size 

val A = Set("a", "b", "c", "d")

pow(A, 4).size                            // -> 256

val B = Set("a", "b", "c", "")

pow(B, 4)

pow(B, 4).size                            // -> 121

pow(B, 3).size 

val B2 = Set("a", "b", "c", "")

pow(B2, 3).size                           // -> 40

val C = Set("a", "b", "")

pow(C, 2)

pow(C, 2).size                            // -> 7

pow(C, 3)

pow(C, 3).size                            // -> 15

//val A = Set("a", "b", "c", "d")

//pow(A, 4).size   

//val A = Set("a", "b", "c")

//pow(A, 5).size   

//val A = Set("a", "b", "")

//pow(A, 5).size   

for (n <- (0 to 6).toList) 

  yield pow(B, n).size

val A = Set("a", "b", "c")

pow(A, 3)

pow(A, 3).size

val B = Set("a", "b", "")

pow(B, 4)

pow(B, 4).size

val C = Set("a", "")

pow(C, 4)

pow(C, 4).size

val SA = Set("a", "b", "c", "d")

val SB = Set("0", "1", "2", "3", "4", "5", "6")

concat(SA, SB).size

val SA2 = Set("ab", "a", "c", "d")

val SB2 = Set("bc", "c", "2", "3", "4", "5", "6")

concat(SA2, SB2).size

/*

((a b) c) d

a (b (c d))

(a b) (c d)

(a (b c)) d

a ((b c) d)

*/