Algorithm 从两个列表生成一定长度组合列表的Scala算法

我有两个Scala列表[字符串]。这是扑克牌，就像：

list_1 = ("4cKs4h8s7s")

从concat 5卡中仅列出一个值：4c、Ks、4h、8s、7s。卡片是一个2个字符的字符串，第一个字符表示值，第二个字符表示套装。 数值：2,3,4,5,6,7,8,9，T，J，Q，K，A 西服：c=梅花，h=红桃，s=黑桃，d=钻石

及

或

2张或4张牌的任何计数。可作为concat两张卡，如Ac、4s（Ac4s）或4张卡，如Ad、4s、Td、2s（Ad4sTd2s）

我想得到一份包含5张卡片的所有可能组合的列表，例如：

67 -> 12345
61234, 62345, 61245, 61345, 71234, 72345, 71345, 71245, 67123, 67234, 67345

与4张卡相同：

6789 -> 12345
61234, 62345, 71234, 72345, 67123, 67234, 67345, 68123, 68234, 68345, .... ~ 35 combinations

卡片示例：

Ad4s    
4cKs4h8s7s
list_res = ("Ad4cKs4h8s", "AdKs4h8s7s", "Ad4c4h8s7s", "AdKs4h8s7s", "4s4cKs4h8s", "4sKs4h8s7s", "4s4cKs8s7s", "4s4c4h8s7s", "Ad4s4cKs4h", "Ad4sKs4h8s", "Ad4s4h8s7s")

或结果可以是列表列表列表，如下所示：

list_res = (("Ad","4c","Ks","4h","8s"), ("Ad","Ks","4h","8s","7s"), ("4s","4c","Ks","4h","8s"), ("4s","Ks","4h","8s"7s"), ("Ad","4s","4c","Ks","4h"), ("Ad","4s","Ks","4h","8s"), ("Ad","4s","4h","8s","7s"))

---

我应该有一个生成这些组合的Scala算法。有人能帮帮我吗？

简单的答案是将两个列表合并，然后得到所有可能的长度组合

n

(lst1 ++ lst2).combinations(n)

但看起来可能每个列表至少需要一个元素。（问题还很不清楚。）那样的话，事情就复杂了一点

val lstL = List('A','B')          //List of letters
val lstD = List('0','1','2','3')  //List of digits
val cl = 5                        //Length of each combination

Range(1,cl).flatMap{ x =>
  for {
    ls <- lstL.combinations(x)    if lstL.lengthIs >= x
    ns <- lstD.combinations(cl-x) if lstD.lengthIs >= cl-x
  } yield ls ++ ns
}
//res0: IndexedSeq[List[Char]] = Vector(List(A, 0, 1, 2, 3)
//                                    , List(B, 0, 1, 2, 3)
//                                    , List(A, B, 0, 1, 2)
//                                    , List(A, B, 0, 1, 3)
//                                    , List(A, B, 0, 2, 3)
//                                    , List(A, B, 1, 2, 3))

val lstL=List（'A'，'B'）//字母列表
val lstD=List（'0'，'1'，'2'，'3'）//数字列表
val cl=5//每个组合的长度
范围（1，cl）.flatMap{x=>
为了{
ls=x
ns=cl-x
}产生ls++ns
}
//res0:IndexedSeq[List[Char]]=向量（List（A，0，1，2，3）
//，列表（B，0，1，2，3）
//，列表（A、B、0、1、2）
//，列表（A、B、0、1、3）
//，列表（A、B、0、2、3）
//，名单（A、B、1、2、3））

你说得对。我错过了。需要从2张或4张卡到5张卡的所有可能组合。更新的描述请注意，实际上并没有所谓的“Scala算法”。同样的算法可以用多种编程语言表达。非常感谢。亲爱的jwvh，你能看看我的问题吗？

(lst1 ++ lst2).combinations(n)

val lstL = List('A','B')          //List of letters
val lstD = List('0','1','2','3')  //List of digits
val cl = 5                        //Length of each combination

Range(1,cl).flatMap{ x =>
  for {
    ls <- lstL.combinations(x)    if lstL.lengthIs >= x
    ns <- lstD.combinations(cl-x) if lstD.lengthIs >= cl-x
  } yield ls ++ ns
}
//res0: IndexedSeq[List[Char]] = Vector(List(A, 0, 1, 2, 3)
//                                    , List(B, 0, 1, 2, 3)
//                                    , List(A, B, 0, 1, 2)
//                                    , List(A, B, 0, 1, 3)
//                                    , List(A, B, 0, 2, 3)
//                                    , List(A, B, 1, 2, 3))