Question

我知道这个主题已经有了一个主题，但我只是想知道为什么这个解决方案不适用于HackerRank＆＃34;比较Triplets＆＃34 34;问题？当它应该是1时，我只输出1。

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

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

＆＃13;

New-AzureRmApiManagementOperation -Context $context -ApiId $aid -OperationId $oid -Name $name -Method $method -UrlTemplate $template -TemplateParameters $tparam

＆＃13;

----更新----

上面的代码仅适用于第一个测试用例而不是其他测试用例。下面的代码虽然很笨重，却适用于所有测试用例。

＆＃13;

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('');
}

＆＃13;

Answer 1

我认为我的解决方案要简单得多，并且不考虑等级参数的长度。

this.parsedData = [
            {   
                employeeName: 'Frances Adiova',
                psid: '31449',
                region: 'APAC',
                subRegion: 'SEA',
                role: 'CAM',
                year: '2018'
            },
            {
                employeeName: 'Julien Nicolas',
                psid: '28313',
                region: 'APAC',
                subRegion: 'SEA',
                role: 'RAM',
                year: '2018'
            }
        ];

Answer 2

如果将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
}

Answer 3

这个问题可以有很多不同的解决方案，但上述解决方案的问题是不应该有＆＃34;否则＆＃34;声明因为在那种情况下第二次比较永远不会发生。校正：

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('');
}

Answer 4

由于使用Javascript类型强制，因此此处的某些答案包含不必要的条件和三元运算符。

在2019年Hackerrank三元组问题的迭代中，他们要求您的最终输出是一个数组，数组的得分为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];
}

Answer 5

只是一个小提示：

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

Answer 6

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

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

然后返回解析数组而不是拆分

Answer 7

关闭你的更新我能够进一步增强它，因为他们给你的输入已经是两个阵列，这样做更干净。您提供的方法是抛出运行时错误。

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;
}

Answer 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;
}

Answer 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]
}

Answer 10

function 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;

}

Answer 11

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;
}

Answer 12

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

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];

}

Answer 13

这是您的解决方案 第一条路

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];
  }
}

Answer 14

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

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
}

Answer 15

我认为我想出了一种最荒谬，最不可读但最简洁的方法：

@Component({
  selector: "my-app",
  templateUrl: "./app.component.html",
  styleUrls: ["./app.component.css"]
})
export class AppComponent {
  name = "Angular " + VERSION.major;
  numbers = Array.from(Array(100).keys());
}

我很确定，我可以将其扩展为假设地（在语言范围内）处理无限数量的元组，但是我今天已经完成了。

Answer 16

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

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

Hackerrank比较Triplets Javascript

16 个答案: