我有一个数组列表,我想获得数组中元素的笛卡尔积.
我将用一个例子来说明这个更具体......
itertools.product似乎可以做到这一点,但我陷入了一些细节.
arrays = [(-1,+1), (-2,+2), (-3,+3)];
如果我做
cp = list(itertools.product(arrays));
我明白了
cp = cp0 = [((-1, 1),), ((-2, 2),), ((-3, 3),)]
但我想得到的是
cp1 = [(-1,-2,-3), (-1,-2,+3), (-1,+2,-3), (-1,+2,+3), ..., (+1,+2,-3), (+1,+2,+3)].
我尝试了一些不同的东西:
cp = list(itertools.product(itertools.islice(arrays, len(arrays))));
cp = list(itertools.product(iter(arrays, len(arrays))));
他们都让我CP0代替CP1.
有任何想法吗？
提前致谢.
我想生成给定数量的向量的元素的所有可能组合.
例如,对于[1 2],[1 2]和[4 5]我想要生成的元素:
[1 1 4; 1 1 5; 1 2 4; 1 2 5; 2 1 4; 2 1 5; 2 2 4; 2 2 5]
问题是我不知道我需要计算组合的向量的数量.在这种情况下可能有3个,或者可能有10个,我需要一个概括.你能帮我在MATLAB中帮助我吗？是否已有可以执行此任务的预定义功能？
我的数学很差,但我很清楚笛卡尔的产品是什么.
这是我的情况(简化):
public class Project{
public IList<Partner> Partners{get;set;}
}
public class Partner{
public IList<PartnerCosts> Costs{get;set;}
public IList<Address> Addresses{get;set;}
}
public class PartnerCosts{
public Money Total{get;set;}
}
public class Money{
public decimal Amount{get;set;}
public int CurrencyCode{get;set;}
}
public class Address{
public string Street{get;set;}
}
我的目标是有效地加载整个项目.
问题当然是:
正如我所读到的,常见的解决方法是使用MultiQueries,但我只是不明白.
所以我希望通过这个确切的例子来学习.
如何有效加载整个项目？
Ps我正在使用NHibernate 3.0.0.
请不要用hql或字符串形式的标准api方法发布答案.
我的问题是关于sequence功能Prelude,其签名如下:
sequence :: Monad m => [m a] -> m [a]
我理解这个函数是如何工作的List的Maybe秒.例如,将sequence上[Just 3, Just 9]给人Just [3, 9].
我注意到,应用sequence上List的Lists给出了笛卡尔乘积.有人可以帮我理解这是怎么回事？
我有以下集合类型:
Map<String, Collection<String>> map;
我想map.size()从每个Key的集合中的单个值创建每个组的唯一组合.
例如,假设地图如下所示:
A, {a1, a2, a3, ..., an}
B, {b1, b2, b3, ..., bn}
C, {c1, c2, c3, ..., cn}
我希望获得的List<Set<String>>结果是一个结果,看起来类似于(排序并不重要,它只需要是一个由所有可能的组合组成的'完整'结果):
{a1, b1, c1},
{a1, b1, c2},
{a1, b1, c3},
{a1, b2, c1},
{a1, b2, c2},
{a1, b2, c3},
...
{a2, b1, c1},
{a2, b1, c2},
...
{a3, b1, c1},
{a3, b1, c2},
...
{an, bn, cn}
这基本上是一个计数问题,但我想看看是否可以使用Java 8流解决方案.
假设我有两个列表:
a = list(1,2,3)
b = list(4,5,6)
所以我可以有9对这些列表成员:
(1,4)
(1,5)
(1,6)
(2,4)
(2,5)
(2,6)
(3,4)
(3,5)
(3,6)
现在,考虑到上面的两个列表成员,我能找到该对的索引吗？像上面的(1,4)将是第一对.
我有一个矢量说vector<vector<int> > items不同大小的矢量,如下所示
1,2,3
4,5
6,7,8
我想根据这些向量的笛卡尔积来创建组合
1,4,6
1,4,7
1,4,8
and so on till
3,5,8
我怎样才能做到这一点 ？我查了几个链接,我也在这篇文章的末尾列出了它们,但我无法解释它,因为我不熟悉这种语言.有些人可以帮助我.
#include <iostream>
#include <iomanip>
#include <vector>
using namespace std;
int main()
{
vector<vector<int> > items;
int k = 0;
for ( int i = 0; i < 5; i++ ) {
items.push_back ( vector<int>() );
for ( int j = 0; j < 5; j++ )
items[i].push_back ( k++ );
}
cartesian ( items ); // I want some function here …我正试图找到笛卡尔积的dplyr函数.我有两个简单的data.frame,没有公共变量:
x <- data.frame(x=c("a","b","c"))
y <- data.frame(y=c(1,2,3))
我想重现一下结果
merge(x,y)
x y
1 a 1
2 b 1
3 c 1
4 a 2
5 b 2
6 c 2
7 a 3
8 b 3
9 c 3
非常感谢你
我想用Java 计算任意数量的非空集的笛卡尔积.
我写过那个迭代代码......
public static <T> List<Set<T>> cartesianProduct(List<Set<T>> list) {
List<Iterator<T>> iterators = new ArrayList<Iterator<T>>(list.size());
List<T> elements = new ArrayList<T>(list.size());
List<Set<T>> toRet = new ArrayList<Set<T>>();
for (int i = 0; i < list.size(); i++) {
iterators.add(list.get(i).iterator());
elements.add(iterators.get(i).next());
}
for (int j = 1; j >= 0;) {
toRet.add(Sets.newHashSet(elements));
for (j = iterators.size()-1; j >= 0 && !iterators.get(j).hasNext(); j--) {
iterators.set(j, list.get(j).iterator());
elements.set(j, iterators.get(j).next());
}
elements.set(Math.abs(j), iterators.get(Math.abs(j)).next());
}
return toRet;
}
......但我发现它相当不优雅.有人有更好的,仍然是迭代的解决方案吗？使用一些奇妙的功能性方法的解决方案？否则......关于如何改进它的建议？错误？
一个例子:
val l = List(1,2,3)
val t = List(-1,-2,-3)
我可以这样做吗？
for (i <- 0 to 10) yield (l(i)) yield (t(i))
基本上我想为每次迭代产生多个结果.