Question

我想创建一个javascript函数，用一个自然数字将1翻转为0，并且我没有想法实现这一点，
实际上，我有几个URL，我用1的查询参数替换了所有的0，现在我不再知道原始参数值，因为原始参数值中只有少量1，现在两者都是混合的，所以基本上我搞砸了自己，

对我来说，唯一的解决方案是尝试将每个1翻转为0然后将0翻转为1并测试每个数字作为参数。

这是参数值（将0替换为1后）

11422971

使用上面的输入我想生成如下数字并测试每一个

11422970
10422971个
10422970个
01422971

正如您所看到的，只有1和0正在改变，根据二进制，

的变化

Answer 1

字符串中的每个位置都可以是n个字符之一：

"0"可以是"0"或"1"
"1"可以是"0"或"1"
任何其他字符c只能是c

我们可以将它存储在一个数组数组中：

"11422971" -> [ ["0", "1"], ["0, "1"], ["4"], ... ]

要将字符串转换为此格式，您可以执行split和map：

const chars = "11422971"
  .split("")
  .map(c => c === "1" || c === "0" ? ["1", "0"] : [ c ]);

获得此格式后，剩下的逻辑是从此数组创建所有可能的组合。有很多方法可以这样做（搜索“数组组合”或“排列”）。我选择显示递归模式：

const chars = "11422971"
  .split("")
  .map(c =>
    c === "1" || c === "0" 
      ? ["1", "0"]
      : [ c ]
    );

const perms = ([ xs, ...others ], s = "", ps = []) =>
    xs 
      ? ps.concat(...xs.map(x => perms(others, s + x, ps)))
      : ps.concat(s);
      
console.log(perms(chars));

Answer 2

你可以用一个像字符串的数字来做，并在解析它之后，就像那样

var number =“12551”; number = number.replace（“1”，“0”）;

号码的结果将是“02550”

之后解析数到int

Answer 3

这将生成所有排列。

const generatePermutations = (number) => {
  let digits = number.split('');
  
  // find out which digits can be flipped
  let digitPositions = digits.reduce((acc, val, i) => {
    if (val === '0' || val === '1') acc.push(i);
    return acc;
  }, []);
  
  // we're going to be taking things in reverse order
  digitPositions.reverse();
  
  // how many digits can we flip
  let noBits = digitPositions.length;
  
  // number of permutations is 2^noBits i.e. 3 digits means 2^3 = 8 permutations.
  let combinations = Math.pow(2, digitPositions.length);
  
  let permutations = [];
  
  // for each permutation
  for (var p = 0; p < combinations; p++) {
    // take a copy of digits for this permutation
    permutations[p] = digits.slice();
    
    // set each of the flippable bits according to the bit positions for this permutation
    // i = 3 = 011 in binary
    for (var i = 0; i < noBits; i++) {
      permutations[p][digitPositions[i]] = '' + ((p >> i) & 1);
    }
    
    permutations[p] = permutations[p].join('');
  }
  
  return permutations;
};

console.log(generatePermutations('11422970'));

Answer 4

如果您正在寻找recursive方法：

function recursive(acc, first, ...rest) {
    if(!first) return acc;
    if(first == '0' || first == '1') {
        var acc0 = acc.map(x => x + '0');
        var acc1 = acc.map(x => x + '1');
        return recursive([].concat(acc0, acc1), ...rest);
    } else {
        return recursive(acc.map(x => x + first), ...rest); 
    }
}

recursive([''], ...'11422971')
// output ["00422970", "10422970", "01422970", "11422970", "00422971", "10422971", "01422971", "11422971"]

Answer 5

这只是以二进制计算并填写每个值的模板。

＆＃13;

function getPossibleValues(str) {
    function getResult(n) {
        let nIndex = 0;
        const strValue = n.toString(2).padStart(nDigits, '0');
        return str.replace(rxMatch, () => strValue.charAt(nIndex++));
    }
    const rxMatch = /[01]/g;
    const nDigits = str.length - str.replace(rxMatch, '').length;
    const nMax = Math.pow(2, nDigits);
    const arrResult = [];
    for(let n = 0; n<nMax; n++) {
        arrResult.push(getResult(n));
    }
    return arrResult;
}

console.log(getPossibleValues('11422970'));

＆＃13;

Answer 6

谢谢大家的回应，你挽救了我的生命，顺便说一句，我使用的方法是，

0-将数字转换为字符串。（所以我们可以执行像split（）这样的字符串操作

1-计算字符串中1的数量（让我们说字符串是＆＃34; 11422971＆＃34;，所以我们得到三个1＆＃39; s，我用了split（＆＃39; 1＆＃39;） - 1来计算）

2-生成三位数长度的二进制（即从000到111）。三个来自第一步。

2-将字符串分解为单个字符，（我们会得到阵列= [＆＃39; 1＆＃39;＆＃39; 1＆＃39;＆＃39; 4＆＃39;＆＃39 2＆＃39;＆＃39 2＆＃39;＆＃ 39; 9＆＃39;，＆＃39; 7＆＃39;，＆＃39; 1＆＃39;]）

3-取第一个二进制数（即b = 0b000）

4-用字母数组中的第一个1替换b的第一个二进制数字（即将1替换为0），同样用b的第二个二进制数字替换第二个1，依此类推。

5-我们将获得第一个组合（即＆＃34; 00422970＆＃34;）

5-对我们在步骤2中生成的所有二进制数重复步骤3和4.

从自然数

6 个答案: