资源

Question

我想创建一个从特定规则增加的数组。

例如：1 = 1,0,1和0 = 0,0。递归量3。所以，如果我输入1，我会：

1 - ＆gt; 1 0 1

1 0 1 - ＆gt; 1 0 1 0 0 1 0 1

1 0 1 0 0 1 0 1 - ＆gt; 1 0 1 0 0 1 0 1 0 0 0 0 1 0 1 0 0 1 0 1

我该怎么做？

谢谢！

Answer 1

您可以使用具有给定模式的数组来减少新数组。

var pattern = [[0, 0], [1, 0, 1]],
    depth = 3,
    temp = [1];
    
while (depth--) {
    temp = temp.reduce((t, i) => t.concat(pattern[i]), []);
}

console.log(temp.join(' '));

Answer 2

首先我们可以创建一个模式函数：

 const pattern = (zero, one) => (values) => 
     values.reduce((res, el) => res.concat(el ? one : zero), []);
 const recurse = (f, n) => v => n == 1 ? f(v) : recurse(f, n - 1)(f(v));

现在要获得我们的递归3模式，我们只需要调用三次简单模式：

 const simple = recurse(pattern([0, 0], [1, 0, 1]), 3);
 const resultPattern = pattern(simple([0]), simple([1]));

现在你可以打电话了

 resultPattern([1])

或其他任何可以得到你的结果。

Answer 3

或许这样的事情？

const rules = {
    "0": "00",
    "1": "101"
}

function expand(input, depth) {
    if (depth === 0) {
        return input;
    } else {
        var expanded = input.split('').map(function (char) {return rules[char];}).join('');
        return step(expanded, depth - 1);
    }
}

expand("1", 1) // "101"
expand("1", 2) // "10100101"

Answer 4

您可以使用map功能。

＆＃13;

let convert = (recursion, current) => {
  if (recursion === 0) return current;  
  return convert(--recursion, build(current));
};

let build = (str) => {
  return str ? (str.split(' ').map((s) => s === '1' ? ' 1 0 1' : ' 0 0').join('').trim()) : '1 0 1';
};

console.log(`1 => ${convert(1)}`);
console.log(`2 => ${convert(2)}`);
console.log(`3 => ${convert(3)}`);
console.log(`4 => ${convert(4)}`);
console.log(`5 => ${convert(5)}`);

＆＃13;

.as-console-wrapper {
  max-height: 100% !important
}

＆＃13;

资源

Array.prototype.map()

Answer 5

您可以使用负责重复 n 次操作的功能。我将其称为input，它将0和1的数组作为第一个参数repeats，并将{{1}的数量作为数字作为第二个参数。

expand([1], 3)预期输出为[1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,1,0,1]

＆＃13;

/**
 * @param {number[]} input 
 * @param {number} repeats 
 */
function expand(input, repeats) {

    do input = input.reduce((arr, oneOrZero) => arr
      .concat([[0, 0], [1, 0, 1]][oneOrZero]), []);
    
    while(--repeats > 0);

    return input;
}


log([1], 1); // expected output: 1,0,1

// one expansion is always performed:
log([1], Number.NEGATIVE_INFINITY); // expected output: 1,0,1

log([1, 0], 2); // expected output: 1,0,1,0,0,1,0,1,0,0,0,0
log([1], 3); // expected output: 1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,1,0,1

function log(input, repeats) {
    document.body.innerHTML += `<p>${input} => x${repeats} => ${expand(input, repeats)}</p>`;
}

＆＃13;

Answer 6

互联网喜欢这些小小的挑战。这是我对它的简约抨击。

let generate = (in, rule) =>  in.reduce((p,c) => [...p, ...rule(c)], []);
let tune = generate([1,0,1], (in) => in ? [1,0,1] : [0,0])

Answer 7

非常感谢大家！你让我今天一整天都感觉很好！由于MaxMSP的工作方式，我对其进行了一些改动。

autowatch = 1;

var rules = {

    "0": "00",
    "1": "101"
}

function expand(input, depth) {

    var h = input.toString();
    if (depth === 0) {
        return input;
    } else {
        var expanded = h.split('').map(function (char) {return rules[char];}).join('');
        return expand(expanded, depth - 1);
    }
}

function test(x,y){

    post(expand(x,y))
}

Answer 8

@Francisco Colasanto，看到你的回答，我可以使用string.replace（）和regex建议最简单（最快）的东西：

function expand(input, depth) {
    var h = input.toString();
    for (var i=0;i<depth;i++) {
  		var str = h.replace(/0/g,"0,0").replace(/1/g,"1,0,1");
      h=str;
    }
    return h.replace(/,/g,"");
}

console.log(expand(1,3));
console.log(expand([1,0,1],2));
console.log(expand([101],2));

用于音乐提议的javascript累积数组

8 个答案:

资源