相关疑难解决方法(0)

假设我们有N成对的数组,例如N=3:

A ₁ =[ [3,2], [4,1], [5,1], [7,1], [7,2], [7,3] ]

阿₂ =[ [3,1], [3,2], [4,1], [4,2], [4,3], [5,3], [7,2] ]

A ₃ =[ [4,1], [5,1], [5,2], [7,1] ]

我们可以假设每个数组中的对按第一个数字排序,然后按第二个数字排序.此外,同一对不会多次出现在同一个数组中(同一对可以出现在多个数组中,如上所示).

每对中的数字是任意整数> = 1.

我怎么能找到k满足的所有东西:

(简单来说,[k,1], [k,2], ... , [k,N]存在于不同的数组中)

上述示例的预期结果是:[5, 7].

注意:速度是算法最重要的因素,然后是内存.如果它有助于优化速度/内存,请假设N <= 10.数组中的对数可以是~50000.

考虑以下数组:

var array1 = [true, false];
var array2 = [1, 2];
var array3 = ["a", "b", "c"];

我想myFunc(arg1, arg2, arg3)用所有参数组合调用我的函数.但我想避免"预告"地狱.

有可能写函数允许我这样,所以我可以称之为:

cartesianCall(array1, array2, array3, myFunc);

理想情况下,数组的变量数(myFunc参数)？

编辑:所以函数将被调用:

myFunc(true, 1, "a");
myFunc(true, 1, "b");
myFunc(true, 1, "c");
myFunc(true, 2, "a");
myFunc(true, 2, "b");
myFunc(true, 2, "c");
myFunc(false, 1, "a");
myFunc(false, 1, "b");
myFunc(false, 1, "c");
myFunc(false, 2, "a");
myFunc(false, 2, "b");
myFunc(false, 2, "c");

我需要调用以下函数cross4次,对于x和y变量的所有排列,值为1和-1;

我的方法:

var p = [-1, 1];

p.forEach(function(x) {
  p.forEach(function(y) {
    cross(x, y);
  });
});

有没有更短的方法这样做？

如何制作正则表达式来评估以下字符串？

TGATGCCGTCCCCTCAACTTGAGTGCTCCTAATGCGTTGC

并提取模式CTCCT.

模式必须是3 C和2 T的任何顺序.

我试过/ [C | T] {5} /但它与CCCCT和TCCCC相匹配

提前致谢.

我正在尝试编写一个函数,它接受一个正整数并返回包含相同数字的下一个较小的正整数,并且当没有包含相同数字的较小数字时返回-1.

For example:

nextSmaller(21) == 12
nextSmaller(531) == 513
nextSmaller(2071) == 2017

我写了一个解决这个问题的代码,但我真的不知道如何进一步优化它.请你帮助我好吗？它在repl.it上运行得相当快,但是当我提交它时,它表示它需要超过1200毫秒并且不允许我提交它,即使所有测试都通过了.

function nextSmaller(n) {
var nArray= n.toString().split("")
var minimumNum = 1 + Array(nArray.length).join('0')
for(var i=n-1; i >= minimumNum; i--) {
  var newNumArray = i.toString().split('');
  var counter = 0;
  for (var j=0; j<newNumArray.length; j++) {
    if (nArray.indexOf(newNumArray[j]) > -1) {
        counter++
        nArray.splice(nArray.indexOf(newNumArray[j]), 1)
        if (counter === n.toString().split("").length) {
        return i;
        }
     } 
  }
       nArray = n.toString().split("");
       if (i === Number(minimumNum)) return -1;
  }
}

如此给出input = [1, 2, 3]，k=2这将返回：

1 2
1 3
2 1
2 3
3 1
3 2

这是最接近我正在寻找的，但不完全是：http://algorithms.tutorialhorizo​​n.com/print-all-combinations-of-subset-of-size-k-from-given-array/

1 2
1 3
2 1
2 3
3 1
3 2

^ 缺少结果，例如2 1、3 1、3 2等。

其次，我不确定我是否正确命名了这个问题，因为“大小 k 的子集的所有组合”的解决方案没有给出预期的答案。

尽管阅读了很多关于排列/组合的Q/A:查找JavaScript数组值的所有组合 + JavaScript - 从具有m个元素的n个数组生成组合我还没有找到正确的方法来获得我正在寻找的那种结果.我有一个10值数组:

var arr = [0,1,2,3,4,5,6,7,8,9];

如果我是对的,所有可能的唯一值的置换数组(没有重复)的数量:

[5,9,1,8,2,6,7,0,4,3] [4,8,0,2,1,9,7,3,6,5] ...

是2x3x4x5x6x7x8x9x10 = 3628800

我正在尝试生成一个动态创建'n'数组的函数.例如:

function createArray(0) -> [0,1,2,3,4,5,6,7,8,9]
function createArray(45648) -> [0,1,5,3,2,8,7,9,6] (something like...)
function createArray(3628800) -> [9,8,7,6,5,4,3,2,1,0]

我想要实现它的方式是:

• createArray(1)置换最后2个符号(8,9 - > 9,8)

• createArray(2-> 6)置换最后3个符号(8,7,9 - > 9,8,7)

• createArray(3628800):所有值都被置换(9-> 0)

你认为这可行/容易吗？如果是的话怎么办？

[编辑]

谢谢你的回答

function permute(permutation, val) {

  var length = permutation.length,
  result = [permutation.slice()],
  c = new Array(length).fill(0),
  i = 1, k, p,
  n = 0;
  while (i < length) {
  if (c[i] < i) …

我正在尝试编写一种递归生成所有彩票组合的算法.

这是一个无递归变量,可用于获得C(max,6).例如c(7,6)

let min = 1;
let max = 7;
let lotteryNum = 0;
let outputString = [];
for (let a = min; a <= max - 5; a++) {
    for (let b = a + 1; b <= max - 4; b++) {
        for (let c = b + 1; c <= max - 3; c++) {
            for (let d = c + 1; d <= max - 2; d++) {
                for (let e = d + 1; e …

例如，这是 5 选择 2：

    var array = [0,1,2,3,4];
    
    var result = array.flatMap(
        (v, i) => array.slice(i+1).map(w => [v, w]) 
    );
    
    console.log(result);

我怎样才能使用这种方法做 5 选择 3？

我在那里看到了一些发电机,但它们都制成了一个平方矩阵.例如,你给它一个三个项目的列表,它将假设长度的输出也是三个.但是,我想指定项目和长度.

声音就像一个简单的问题,不能相信没有可用的库.如果那里有一个经过测试的库,我想避免自己写这个.任何建议都会很棒.

我发现的例子

var list = 'abc';
perms = permutations(list);
//you cannot define the length

例

var list = 'abc';
var length = 3;

perms = permutations(list,length);

console.log(perms);

/* output
a,a,a
a,b,c
a,b,a
a,c,a
c,a,a
...
*/

我希望能够改变长度,并相应地创建排列

length = 2

a,a
a,b
b,b
b,a

length = 4

a,a,a,a 
a,a,a,b
....