测验：转换为二进制数字，用JavaScript重叠数组

Question

我已经在JavaScript中解决了以下测验，并在下面附加了测验和我的解决方案。 我不觉得正确解决问题，因为我知道我错过了如何调用功能！ 任何人都可以帮助我更简单的方式使用调用函数的方法重写代码？或者任何一种最简单的方式都欢迎！

测验：

鉴于三个输入：两个阵列与包含的十进制数和它们的长度的数目相同的长度， 转换在两个阵列的数字为二进制数，像这样：

01001 
10100 
11100 
10010 
01011 

11110 
00001 
10101 
10001 
11100 

然后，通过重叠在彼此之上，使得具有从每个阵列1S一个新的数组结合两个阵列， （1个覆盖0），像这样：

11111 
10101 
11101 
10011 
11111 

作为最后的步骤中，转换该阵列为具有＃S-和的条件下空格的格式（＃= 1，空间= 0） 最后，你应该得到这作为输出>

[ '#####', '# # #', '### #', '# ##', '#####' ] 

我的解决方案：

function solution(n, arr1, arr2) { 
    var convArr1 = arr1.map(function(numten) {  
     return numten.toString(2); 
    }) 
    var convArr2 = arr2.map(function(numten) { 
     return numten.toString(2); 
    }) 
    var newArr1 = convArr1.map(function(binNum) { 
     if (binNum.length != n) { 
      let zero = '0'; 
      for (let i = 1; i < n - binNum.length; i++) { 
       zero = zero + 0; 
      } 
      binNum = zero + binNum; 
      return binNum; 
     } else { 
      return binNum; 
     }  
    }) 
    var newArr2 = convArr2.map(function(biNum) { 
     if (biNum.length != n) { 
      var zero = '0'; 
      for (let i = 1; i < n - biNum.length; i++) { 
       zero = zero + '0'; 
      } 
      biNum = zero + biNum; 
      return biNum; 
     } else { 
      return biNum; 
     }  
    }) 
    // console.log(newArr1, newArr2); 
    var answer = ["", "", "", "", ""]; 
    var element = ""; 
    function compare(a, b) { 
     for (var i = 0; i < a.length; i++) { 
      if (a[i] === '1' || b[i] === '1') { 
       answer[i] = answer[i] + '#'; 
      } else { 
       answer[i] = answer[i] + ' '; 
      } 
     } 
    } 
    var compareArr = []; 

    for (var i = 0; i < n; i++) { 
     var numInArr1 = newArr1[i]; 
     var numInArr2 = newArr2[i]; 
     compare(numInArr1, numInArr2); 
    } 
    return answer; 
} 

console.log(solution(5, [9, 20, 28, 18, 11], [30, 1, 21, 17, 28])); 

Answer 1

你所说的 '1个覆盖0' 什么是二元运算符。 | operator (pronounce 'OR')取2个十进制数的二进制表示，然后比较每个二进制数（=每个位），以产生一个1，如果其中一个位或它们两者都等于1的话。

您正在询问一种方法'召回'或重新使用用于转换arr1的功能来转换arr2。但是这两种转换并不是真的需要。使用|操作员不需要转换十进制数字，因为这是计算机内部使用的。

你可以试试这个...

function solution (n, arr1, arr2) { 

    result = arr1.map(function (element, index) { 
     // take the element and the relative element of the other array 
     // and use the binary OR operator 
     return element | arr2[index]; 
    }).map(function (element) { 
     // make a string of the required number of spaces ... 
     // and add our binary pattern of replacements for 1's and 0's 
     binary = " ".repeat(n) + element.toString(2).replace(/1/g,'#').replace(/0/g,' '); 

     // truncate to return only the last n bits 
     return binary.slice(-n); 

    }); 
    return result; 
} 

console.log(solution(5, [9, 20, 28, 18, 11], [30, 1, 21, 17, 28])); 

很多发生在同一arr1阵列。这就是为什么我一个接一个地写了.map。这被称为方法链接。第一个映射方法需要arr1，然后生成一个新的数组。当然，该数组也有我们可以调用的.map方法。第一张地图用于组合arr1和arr2。第二个地图调用用于将结果转换为数组，其模式为#和SPACE。

在第一张地图调用回调函数需要一个额外的参数：

arr1.map(function (element, index) { 
     // take the element and the relative element of the other array 
     // and use the binary OR operator 
     return element | arr2[index]; 
}) 

我们需要一个映射过去，因为我们需要的arr2阵列内的相同元素每个元素的索引号。

Answer 2

在JavaScript中，我们可以在小数使用位操作，然后通过.toString(2)功能解析这些回二进制：

function solution(n, arr1, arr2) { 
 
    return Array.from(arr1.keys()) 
 
     .map(i => { 
 
      const num = arr1[i] | arr2[i]; 
 
      const padded = "0".repeat(n) + num.toString(2); 
 
      const binary = padded.substr(padded.length - n); 
 
      return binary.split("") 
 
       .map(c => c === "0" ? " " : "#") 
 
       .join(""); 
 
     }); 
 
} 
 
console.log(solution(5, [9, 20, 28, 18, 11], [30, 1, 21, 17, 28])); 
 
// Out: 
 
// ["#####", "# # #", "### #", "# ##", "#####"]

Answer 3

这里是一个容易解决的问题:)

function solution(num, inputOne, inputTwo) { 
 
    return Array(num).fill(0).map(function(un, index) { 
 
    return (inputOne[index] | inputTwo[index]).toString(2).replace(/0/g, ' ').replace(/1/g, '#'); 
 
    }); 
 
} 
 

 
console.log(solution(5, [9, 20, 28, 18, 11], [30, 1, 21, 17, 28]));