Hackerrank 比较 Triplets Javascript

【问题标题】：Hackerrank Compare the Triplets JavascriptHackerrank 比较 Triplets Javascript
【发布时间】：2018-09-13 13:30:37
【问题描述】：

我知道已经有一个关于这个主题的帖子，但是我只是想知道为什么这个解决方案不适用于 HackerRank 的“比较三胞胎”问题？当它应该是 1 1 时，我只得到 1 的输出。

问题表明，如果 a0 > b0、a1 > b1 或 a2 > b2（反之亦然），对于任何不相等的比较，结果应该打印单独的间隔整数 1。

https://www.hackerrank.com/challenges/compare-the-triplets/problem

function solve(a0, a1, a2, b0, b1, b2) {
    
    var solution = []

    if (a0 > b0 || a1 > b1 || a2 > b2) {
        solution += 1;
    } else if (a0 < b0 || a1 < b1 || a2 < b2 ) {
        solution += 1;
    }
    return solution.split('');
}

---- 更新----

上面的代码只适用于第一个测试用例而不是其余的。下面的代码虽然笨重，但适用于所有测试用例。 

function solve(a0, a1, a2, b0, b1, b2) {
    var s = [0, 0];
    
    if (a0 > b0) {s[0] += 1;} 
    if (a1 > b1) {s[0] += 1;} 
    if (a2 > b2) {s[0] += 1;}
    if (a0 < b0) {s[1] += 1;}
    if (a1 < b1) {s[1] += 1;}
    if (a2 < b2) {s[1] += 1;}
        
    return s;
}

【问题讨论】：

  • 一个输出到什么输入？到目前为止，您只展示了一个函数声明。请edit您的问题并提供minimal reproducible example。
  • 你可以让其他人帮助解决代码挑战吗？
  • 要向数组添加值，请使用solution.push(1)，而不是solution += 1。
  • solution.split('') 你不能拆分数组？！
  • @JonasW。这看起来不像是公开比赛，所以应该没问题。

标签： javascript integer


【解决方案1】：

只是一个小提示：

  console.log((a0 > b0) + (a1 > b1) + (a2 > b2))) // 1

【讨论】：

    【解决方案2】：

    每次第一个元组的元素大于第二个元组的元素时，您应该添加一个点，即

    let solution = [0,0];
a0>b0?solution[0]+=1:a0<b0?solution[1]+=1:'';

    然后返回未拆分的解数组

    【讨论】：

      【解决方案3】：

      这个问题可以有许多不同的解决方案，但上述解决方案的问题是不应该有“else”语句，因为在这种情况下，第二次比较永远不会发生。更正：

      function solve(a0, a1, a2, b0, b1, b2) {

    var solution = []

    if (a0 > b0 || a1 > b1 || a2 > b2) {
        solution += 1;
    }
if (a0 < b0 || a1 < b1 || a2 < b2 ) {
        solution += 1;
    }
    return solution.split('');
}

      【讨论】：

      • 见鬼，就是这样。谢谢@Khyati。不过我很好奇，这个解决方案会被认为是一个好习惯吗？我很惊讶我在网上没有找到任何类似的解决方案，大多数都非常冗长。
      • 嗨贾斯汀，这个解决方案不能被认为是一个好的解决方案，因为如果两者的分数都是 0 或 1，它只会给出正确的结果。但是对于任何 1 的分数将是 2/ 3，这个解决方案不会产生正确的结果。例如：如果输入集变为- 5, 6, 7, 3, 8, 10 以下可以是一个解决方案： function solve(a0, a1, a2, b0, b1, b2) { score_a = ((a0>b0)? 1:0)+ ((a1>b1)?1:0)+ ((a2>b2)?1:0) ; score_b = ((a0
      • 谢谢@Khyati。我在最后一条消息之后再次尝试，发现它不适用于其余的测试用例，所以我最终只使用了一堆 if 语句。我仍在熟悉操作符，例如 : 和 ?这似乎更有效率。
      • 你是否检查过这个条件 var a = [17,28,30] 和 var b = [99,16,8] 以上解决方案是错误的；
      【解决方案4】：

      结束您的更新后，我能够进一步增强它，因为他们为您提供的输入已经是两个数组，这样做更简洁。您提供的方法引发了运行时错误。

      function solve(a, b) {

    var results = [0,0];

    if (a[0] > b[0]) {results[0] += 1;} 
    if (a[1] > b[1]) {results[0] += 1;} 
    if (a[2] > b[2]) {results[0] += 1;}
    if (a[0] < b[0]) {results[1] += 1;}
    if (a[1] < b[1]) {results[1] += 1;}
    if (a[2] < b[2]) {results[1] += 1;}

    return results;
}

      【讨论】：

        【解决方案5】：

        我的解决方案，我认为它更简单，并且不假设评级参数的长度。

        let counterA = 0,
    counterB = 0;
for(let i=0;i<a.length;i++){
    if(a[i] > b[i]){
        counterA++;
    }
    else if(a[i] < b[i]){
        counterB++;
    }
}

return [counterA,counterB];

        【讨论】：

          【解决方案6】：

          如果将 a 和 b 视为数组，则似乎传递了hackerrank：

          function compareTriplets(a, b) {
    let score = [0,0]

    for (let i = 0; i < a.length; i++)
        a[i] > b[i] ? score[0]++ : a[i] < b[i] ? score[1]++ : ""
    return score
}

          【讨论】：

            【解决方案7】：

            由于 Javascript 类型强制，这里的一些答案有不必要的条件和三元运算符。

            在 Hackerrank 三元组问题的 2019 年迭代中，他们要求您的最终输出是一个数组，其分数首先是 alice，然后是 bob，即[2,1]

            所以你可以这样做：

            function compareTriplets(a, b) {
  var alice = (a[0] > b[0]) + (a[1] > b[1]) + (a[2] > b[2]);
  var bob = (a[0] < b[0]) + (a[1] < b[1]) + (a[2] < b[2]);
  return [alice, bob];
}

            【讨论】：

              【解决方案8】：

              这个问题在 ES6 语法中更紧凑和更好的答案可以是：

              function compareTriplets(a, b) {

    let ascore = 0, bscore = 0;
    a.forEach((item, i) => {
        (a[i] > b[i]) && ascore++;
        (a[i] < b[i]) && bscore++;
    });

    return [ascore, bscore];
}

              或者你可以参考这个：

              function compareTriplets(a, b) {

    let score = [0, 0];
    a.forEach((item, i) => {
        (a[i] > b[i]) && score[0]++;
        (a[i] < b[i]) && score[1]++;
    });

    return score;
}

              【讨论】：

                【解决方案9】：

                我已经通过以下解决方案解决了这个问题。

                    function compareTriplets(a, b) {
    let alice = 0, bob = 0;
    for (let i = 0; i < a.length; i++){
        if (a[i] > b[i]) alice += 1;
        if(a[i]<b[i]) bob +=1
    }
    return [alice,bob]
}

                【讨论】：

                  【解决方案10】：

                  函数 compareTriplets(a, b) {
                  var score = [0, 0];

                  for (var i = 0; i < a.length; i++) {       // iterate through the array
    if (a[i] > b[i]) {
        result[0]++;
    } else if (a[i] < b[i]) {
        result[1]++;
    }
}
return score;

                  }

                  【讨论】：

                    【解决方案11】：

                    这是您可以尝试的另一种解决方案...

                    function compareTriplets(a, b) {
let p1 = 0, p2 = 0, aliceScore = 0, bobScore = 0;
while (p1 < a.length && p2 < b.length) {
    if (a[p1] > b[p2]) {
        aliceScore += 1;
        p1 += 1;
        p2 += 1;
    } else if (a[p1] < b[p2]) {
        bobScore += 1;
        p1 += 1;
        p2 += 1;

    } else {
        p1 += 1;
        p2 += 1;
    }
}
return [aliceScore, bobScore];
}
compareTriplets([10 ,12, 50],[20,20,10]);

                    Click here to RUN

                    【讨论】：

                      【解决方案12】： 
                      var a = [9, 7, 3];
var b = [3, 2, 1];

function compareTriplets(a, b){
    var score = [0, 0];
    for(var i = 0; i <= a.length; i +=1){
        if(a[i] > b[i]){
            score[0]+=1;
        } else if(a[i] < b[i]){
            score[1]+=1;
        } else{
            continue;
        }
    }
    return score;
}

                      【讨论】：

                        【解决方案13】：

                        我的解决方案。我认为它的可读性很好。

                        function compareTriplets(a, b) {

let aScore = 0;
let bScore = 0;

a.forEach((x,index)=>{
    if (x>b[index]) {
        aScore++;
    } else if (x<b[index]) {
        bScore++;
    }
});

return [aScore, bScore];

}

                        【讨论】：

                          【解决方案14】：

                          这是您的解决方案 第一路 

                          function compare(a, b) {
  const score = [0, 0];
  for (let i = 0; i < 3; i++) {
    if (a[i] > b[i]) {
      score[0]++;
    } else if (a[i] < b[i]) {
      score[1]++;
    } else {
      score[1] === score[1];
    }
  }
}

                          第二种方式 

                          function compare(a, b) {
  const score = [0, 0];
  for (let i = 0; i < 3; i++) {
    a[i] > b[i] ? score[0]++ : a[i] < b[i] ? score[1]++ : score[1] === score[1];
  }
}

                          【讨论】：

                          • 解释你的答案是做什么的
                          【解决方案15】：

                          使用记分板和递增的更简单方法

                          function compareTriplets(a, b) {
let scoreBoard = [0, 0]
for (let i = 0; i <= 100; i++) {
    if (a[i] > b[i]) {
        scoreBoard[0]++
    } else if (a[i] < b[i]) {
        scoreBoard[1]++
    }
}
return scoreBoard
}

                          【讨论】：

                            【解决方案16】：

                            我想我想出了最荒谬但不可读但简洁的方法：

                            const compareTriplets = (a, b) => [[a, b], [b, a]].map((c, i) => c[0].reduce((acc, _curr, i) => acc + (c[0][i] > c[1][i]), 0));

                            我很肯定我可以扩展它来处理假设（在语言范围内）无限数量的元组，但我已经完成了这一天。

                            【讨论】：

                            • 我会离开任何在他们的代码库中有这个的公司
                            • 我不会怪你哈哈。我会杀死任何试图通过代码审查获得这样的东西的人
                            【解决方案17】：

                            使用三元运算符

                            https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator

                            ReactJS 使用了大量的三元运算符进行条件渲染。非常整洁，将来会是一个有用的捷径：P

                             function compareTriplets(a, b) {
  
   let result = [0,0];

   a.forEach((element, i) =>  
        a[i] > b[i] ? result[0]++ : 
        a[i] < b[i] ? result[1]++ : 
        null )

   return result 
}

                            【讨论】：

                              猜你喜欢
                              • 1970-01-01
                              • 2020-11-24
                              • 1970-01-01
                              • 1970-01-01
                              • 2014-10-16
                              • 2012-04-28
                              • 2013-11-21
                              • 2016-11-18
                              • 2017-11-26
                              相关资源
                              最近更新 更多
                              热门标签
                              Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode