标签: cartesian-product

所以我有这些清单:

a = [1, 2, 3]
b = [11, 12, 13, 14]
c = [21, 22, 23, 24, 25, 26]

我希望获得所有可能的组合(重复都很好),包括来自的a3个元素b和来自3个元素的2 个元素c.像这样:

([1, 2], [11, 12, 13], [21, 22, 23]) # 1
([1, 2], [11, 12, 13], [22, 23, 24]) # 2
# all the way to...
([2, 3], [12, 13, 14], [24, 25, 26]) # 16

如果我使用itertools.product(),它只给我每个列表1:

import itertools

def cartesian(the_list):
    for i in itertools.product(*the_list):
        yield i

a = [1, …

这是我生成笛卡尔积的代码:

(defun cartesian-product (LIST)
  (LOOP FOR X IN LIST
    NCONC
        (LOOP FOR Y IN LIST
         COLLECT (LIST X Y))))

我尝试输出其中一个笛卡儿产品:

(defun cartesian-product-generator (CALLBACK LIST)
  (LOOP FOR X IN LIST
    NCONC
        (LOOP FOR Y IN LIST
        DO(FUNCALL CALLBACK (LIST X Y)))))

但是当我尝试使用以下测试时出现错误:

(cartesian-product-generator '(A B C))

Error: Too few arguments in call to #<Compiled-function cartesian-product-generator #x30200097E60F>:
       1 argument provided, at least 2 required.  While executing: cartesian-product-generator, in process listener(1).

我是LISP的新手,想知道为什么会出现错误以及如何修复此错误.最终,我希望每次调用函数输出每个笛卡尔积.

例如,如果列表包含((1 1) (1 2) (2 1) (2 2)).我想生成(1 …

我有图像索引列表，其长度为 60000。我想创建另一个包含随机索引对的列表。这里的约束是产品集的每个元素应该包含不同的索引。换句话说，我不想将索引与其自身配对。

目前我一直在使用itertools.product带有循环的方法for。

pairs = []
for pair in itertools.product(indexes, indexes):
    if pair[0]!=pair[1]:
        pairs.append(pair)

问题是它花费了很多时间，而且我无法使用我的计算机，因为它卡住了。

有更好的方法吗？

我试图了解可应用性以及如何将其用作K函数和N参数之间的笛卡尔积，而我无法理解为什么我不能做到以下几点：

[Just (+1),Just (+2)] <*> [Just 1 ,Just 2] 渲染

错误

* Couldn't match expected type `Maybe Integer -> b'
                  with actual type `Maybe (Integer -> Integer)'
    * Possible cause: `Just' is applied to too many arguments      In the expression: Just (+ 1)      In the first argument of `(<*>)', namely `[Just (+ 1), Just (+ 2)]'
      In the expression: [Just (+ 1), Just (+ 2)] <*> [Just 1, Just 2]

我不明白，因为从定义出发，应该将功能移出上下文，取值并应用所有组合。

我也尝试过：

:t [pure (+1),pure (+2)] …

我想将多个数据文件通过两个模块来处理它们，使用每个模块的多个参数上的多个设置的每种组合。最明显的方法是使用嵌套的 for 循环，但是当您达到 7 个以上的嵌套 for 循环时，就不行了。我想让这个比那个更优雅。

我已经读过几个非常相似的问题，但是虽然这个问题表明我可能想使用 itertools，但它只迭代数字序列，而我想迭代作为字典中的值包含的字符串列表；另一个揭示了我想要的叫做笛卡尔积，但不是如何从字典值中得到它；虽然这个组合了笛卡尔积中的列表字典，但我希望输出是如上一个链接问题中的列表列表，而不是字典列表。

在：

video = ["It's Friday.mp4",'Hot Koolaid.mov','The Water Buffalo Song.mp4']
CC = {'size':['6','10','14'],'font':['Courier New'],'color':['black','white'],'language':['English']}
Noise = {'CRT':['speckles','rising stripes','no signal'],'sound':['white','crackle']}

出去：

[['It's Friday.mp4','6','Courier New','black','English','speckles','white'], 
 ['Hot Koolaid.mov','6','Courier New','black','English','speckles','white']
 ...
 ['The Water Buffalo Song.mp4','14','Courier New','white','English','no signal','crackle']]

我很确定我想使用itertools，并且我想要制作的是列表的笛卡尔积。我认为目前最困难的事情是从字典中提取这些列表并将其元素的组合放入列表中。

_________编辑：____________

在检查我随后接受的答案的过程中，我发现将所有参数都放在列表中（对于我的目的而言）很重要，即使只考虑一个值；不带方括号的字符串将一次迭代一个字符。

丑陋的嵌套 for 循环如下所示：

for vid in video:
    for siz in CC['size']:
        for fon in CC['font']:
            for col in CC['color']:
                for lan in CC['language']:
                    for crt in Noise['CRT']:
                        for …

我有两个字符串列表：

letters = ['abc', 'def', 'ghi']
numbers = ['123', '456']

我想循环遍历它们以创建一个不并行的字符串列表，所以zip()在这里不起作用。

期望的结果：

result = ['abc123', 'def123', 'ghi123', 'abc456', 'def456', 'ghi456']

结果中元素的顺序无关紧要。

有任何想法吗？

输入：

[[a,b,c],
[d,e,],
[f,g,h]
]

期望的输出：

[
[a,d,f],[a,d,g],[a,d,h],.......[c,e,h]
].

你会如何在 Scala 中做到这一点？

编辑：包含每个字母的单个列表的大小以及包含该列表的列表的大小是随机的。包含字母的列表可以有不同的大小

我需要一个类似于expand.grid但没有重复元素组合的函数。

这是我的问题的简化版本。

X1 = c("x","y","z")
X2 = c("A","B","C")
X3 = c("y","C","G")

d <- expand.grid(X1,X2,X3)

d
   Var1 Var2 Var3
1     x    A    y
2     y    A    y
3     z    A    y
4     x    B    y
.     .    .    .
.     .    .    .
.     .    .    .
23    y    B    G
24    z    B    G
25    x    C    G
26    y    C    G
27    z    C    G

d有 27 行。但其中 6 个包含我不需要的重复值行：2、5、8、16、17 和 18

有没有办法获取不包含任何重复项的其他 21 行。

请注意，向量的元素数量超过 …

我尝试在 kubernetes json 输出上使用 jq，创建包含对象列表的新 json 对象 - 每个 pod 的容器和图像，但是我得到笛卡尔积。

我的输入数据（从敏感信息中截断）：

{
    "apiVersion": "v1",
    "items": [
        {
            "apiVersion": "v1",
            "kind": "Pod",
            "metadata": {
                "creationTimestamp": "2021-06-30T12:45:40Z",
                "name": "pod-1",
                "namespace": "default",
                "resourceVersion": "757679286",
                "selfLink": "/api/v1/namespaces/default/pods/pod-1"
            },
            "spec": {
                "containers": [
                    {
                        "image": "image-1",
                        "imagePullPolicy": "Always",
                        "name": "container-1",
                        "resources": {},
                        "terminationMessagePath": "/dev/termination-log",
                        "terminationMessagePolicy": "File",
                        "volumeMounts": [
                            {
                                "mountPath": "/var/run/secrets/kubernetes.io/serviceaccount",
                                "readOnly": true
                            }
                        ]
                    },
                    {
                        "image": "image-2",
                        "imagePullPolicy": "Always",
                        "name": "container-2",
                        "resources": {},
                        "terminationMessagePath": "/dev/termination-log",
                        "terminationMessagePolicy": "File",
                        "volumeMounts": [
                            {
                                "mountPath": "/var/run/secrets/kubernetes.io/serviceaccount", …

我想在R中做两个向量的笛卡儿

1. 返回data.frame列名称
2. 返回字符列而不是因子

我当然可以用几行代码来做这件事.

df <- merge(1:3, letters[1:3], all = TRUE)
colnames(df) <- c("number", "letter")
df$letter <- as.character(df$letter)
str(df)
## 'data.frame':    9 obs. of  2 variables:
##  $ number: int  1 2 3 1 2 3 1 2 3
##  $ letter: chr  "a" "a" "a" "b" ...

但理想情况下,这将是一个单行,如下面的代码(不产生所需的输出).

df2 <- merge(c(number = 1:3),
             c(letter = letters[1:3]), all = TRUE, stringsAsFactors = FALSE)
str(df2)
## 'data.frame':    9 obs. of  2 variables:
##  $ x: int  1 2 3 …