标签: combinatorics

给定一个向量v = [1,..,n]，我尝试计算所有唯一的 n 元素集并在 julia 中进行替换。

由于我想对较大的 n 值执行此操作，因此我正在寻找一种有效的解决方案，可能使用迭代器。

例如，让我们考虑v = [1, 2, 3]：这应该导致[1,1,1], [1,1,2], [1,1,3], [1,2,2], [1,2,3], [1,3,3], [2,2,2], [2,2,3], [2,3,3], [3,3,3]. 对于唯一，我的意思是如果[1,1,2]是一个解决方案，那么它的任何排列[1,2,1], [2,1,1]都不是。

我当前的解决方案基于partitions函数，但不允许我限制元素 [1,..,n] 的计算

for i in n:n^2
  for j in partitions(i, n)
    ## ignore sets which exceed the range [1,n]
    if maximum(j) <= n
      ## accept as solution
    end
  end
end

编写一个程序，将网格的宽度、W 和高度 H 作为输入，并输出用 (2x1) 多米诺骨牌平铺 W×H 网格的不同方式的数量

我知道如何用 3 x N 网格解决问题，但是为此编写递归公式对我来说太难了！

我不知道该怎么做！

我创建了两个函数 F(n) - 平铺直到 N 的完整方法和 S(n) 用于 3 x N 的不完全平铺方法的数量！但这里由于高度是可变的我想不出任何东西

约束：(0 \xe2\x89\xa4 W+H \xe2\x89\xa4 22)

我本质上是在寻找与此答案等效的 JavaScript ，特别是该响应中提供的第一种格式。

换句话说，给定对象：

let variants = {
  debug : ["on", "off"],
  locale : ["de_DE", "en_US", "fr_FR"],
}

我想要一个返回的函数：

[{debug: 'on', locale: 'de_DE'},
 {debug: 'on', locale: 'en_US'},
 {debug: 'on', locale: 'fr_FR'},
 {debug: 'off', locale: 'de_DE'},
 {debug: 'off', locale: 'en_US'},
 {debug: 'off', locale: 'fr_FR'}]

我正在寻找的解决方案应该不知道输入对象中有哪些键。

我有两个非负整数 x 和 y，它们都最多有 30 位（所以它们的值约为 10^9）。

我想计算有多少组 4 个数字 {a_1, a_2, a_3, a_4} 使得 a_1 + a_2 = x 和 a_3 + a_4 = y 并且所有这 4 个数字的异或等于 0。

解决这个问题最快的算法是什么？

我能想到的最快的方法是将异或方程重新排列为a_1 xor a_2 = a_3 xor a_4。

然后我可以在 O(x) 中计算左侧的所有值，在 O(y) 中计算右侧的所有值，因此整个算法在 O(x + y) 中运行。

以下是客户 1 购买的产品表。

df <- data.table(customer_id = rep(1,3)
                 , product_1 = letters[1:3]
                  )

   customer_id product_1
1:           1         a
2:           1         b
3:           1         c

假设真实数据集有多个客户，我想为每个客户创建每个客户购买的产品的排列（无替换）。在组合术语中：

nPk

在哪里

n = 每个客户购买的（不同的）产品数量

k = 2

结果：

customer_id product_1 product_2
1:           1         a         b
2:           1         a         c
3:           1         b         c
4:           1         b         a
5:           1         c         a
6:           1         c         b

SQL 连接条件为：

where   customer_id = customer_id
        and product_1 != product_1

但是，我知道data.table目前对 non equi joins …

我正在尝试获取具有某些限制的数字 0-14 的每种可能组合的列表。我不完全确定如何表达这个，所以让我解释一下。

• 每个列表的长度为 15。
• 第一个列表将是[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]。
• 每个列表中每个索引处的值不能超过索引本身，并且可以与前一个数字相同，也可以比前一个数字高一个。
• 最终名单将是[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]。

我正在寻找一个列表列表，其中包含具有这些约束的所有可能序列（例如，一个可能的序列是[0, 1, 1, 2, 2, 3, 4, 5, 6, 6, 7, 7, 7, 8, 8]）。

我该怎么做？

我用一些代码解决了以下 leetCode 问题：

返回模 10^9 + 7 的可能方式数来掷骰子，使面朝上的数字总和等于t.

我制作了两个版本的解决方案代码，一个在 node.js 中使用mathjs，另一个在 python 中使用 math 模块。

在 node.js 中

const { combinations: comb, bignumber: Big } = require("mathjs");

function dice(d, f, t) {
    if (t > d * f || t < d) return 0;

    var result = Big(0);
    var i = 0;
    var sign = 1;
    var n = t - 1;
    var k = t - d;

    while …

假设有两个矩阵：

A <- B <- diag(3)  
> A
     [,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    1    0
[3,]    0    0    1

我想创建一个新矩阵 AB，它由 A 和 B 行的所有可能组合组成。预期结果：

> AB
      [,1] [,2] [,3] [,4] [,5] [,6]
 [1,]    1    0    0    1    0    0
 [2,]    1    0    0    0    1    0
 [3,]    1    0    0    0    0    1
 [4,]    0    1    0    1    0    0
 [5,]    0    1    0    0    1    0
 [6,]    0    1    0    0    0    1
 [7,] …

我正在尝试计算具有重复字符的给定排列的词典排名。

我发现的所有示例似乎都涉及根据输入字符串的字谜词查找给定输入字符串的词典排名（与任意字符集相对）

输入

• 字符集：A,B,C
• 输入：（BAA注意C不包含在输入中）
• 长度：（3字符组合的最大长度...还必须包括 1 和 2 个字符组合）

输出

• 16

笔记

• 可以有重复的字符
• 共有 39 种组合（1、2 或 3 个字符的排列）
• 无法通过生成所有组合等进行暴力破解，因为实际用例涉及更大的字符集/最大字符串长度

所有组合（按顺序）

1. A
2. AA
3. AAA
4. AAB
5. 亚克力
6. AB
7. ABA
8. ABB
9. ABC
10. 交流电
11. ACA
12. ACB
13. ACC
14. 乙
15. 学士
16. BAA
17. 巴布
18. 巴克
19. BB
20. BBA
21. 血脑屏障
22. 英国广播公司
23. 公元前
24. BCA
25. BCB
26. 密件抄送
27. C
28. CA
29. 中国航空协会
30. 出租车
31. CAC
32. CB
33. 篮球协会
34. 商业银行
35. 加拿大广播公司
36. 抄送
37. CCA
38. 建行
39. CCC

我正在研究下面的编码问题，它看起来更像是概率问题而不是编码问题

由 5 个顶点组成的平台。顶点的坐标为：(-1,0)、(0.-1)。(0,0), (0.1)。(1.0)。从顶点 (xs,ys) 开始，并继续向左（即 x 坐标减少 1）、向右（即 x 坐标增加 1）、向上或向下随机移动。随后的移动方向是独立的。在从平台上掉下来之前到达顶点 (xe, ye) 的概率是多少？约束：(xs, ys) in [(-1.0), (0.-1), (0.0), (0.1), (1,0)] (xe, ye) in [(-1,0), ( 0.-1), (0,0), (0,1), (1.0)] xs != xend 或 ys != Yend

下面是我实现的方法，它适用于我分享的案例，但不适用于所有其他情况

def calculate_probability(xs, ys, xe, ye):
    edges = [[-1, 0], [0, -1], [0, 1], [1, 0]]
    if [xs, ys] in edges:
        if xe == 0 and ye == 0:
            return 0.25
        elif xs == xe and ys == ye:
            return 1.0 …