Тест Javascript Array ведет себя неверно, когда это правда

Question

Я пытаюсь сделать многопользовательскую игру в покер на Node.js, и у меня было много проблем в последнее время.Это главный.Этот код должен идентифицировать стрит-руку из массива.Однако мой код, очевидно, не универсален.Я сделал 2 массива в качестве тестовых случаев, и разные результаты получаются, когда даже только массивы идентифицируются как прямые.Пожалуйста помоги.

Вот код:

    var arr = [9,1,2,11,8,12,10];   // first array
    var arr2 = [9,1,8,4,5,3,2];     // second array
    var straight = [];

    // Removes duplicate elements in an array
    /* example:
    array = removeDuplicates(array)
    */
    function removeDuplicates(arr){
        let unique_array = []
        for(let i = 0;i < arr.length; i++){
            if(unique_array.indexOf(arr[i]) == -1){
                unique_array.push(arr[i])
            }
        }
        return unique_array
    }

    //Sorts the array
    arr.sort(function(a,b){return b-a});

    //Removes duplicates
    arr = removeDuplicates(arr);

    // Displays sorted and cleaned up array
    console.log(arr)

    /*Basic translation: loops through the array
    and if the difference between the a term and
    the term after it is 1, it will append it to the 
    array 'straight'. It will break if the difference 
    is greater than 1. Then it will remove those elements
    from the original array and retry to append consecutive
    elements in the 'straight' array.
    */
    for (var i=1; i<arr.length+1; i++) {
      if (arr[i-1] - arr[i] === 1) {
        straight.push(arr[i-1],arr[i]); // error occurs at this line
      } else if (arr[i-1] - arr[i] > 1){
        break; }

        if (straight.length === 2) {
          arr.splice(arr.indexOf(straight[0]),1)
          arr.splice(arr.indexOf(straight[1]),1)
          straight = [];

          for (var i=1; i<arr.length; i++) {
            if (arr[i-1] - arr[i] === 1) {
              straight.push(arr[i-1],arr[i]);
            }
          }
        }
    };

    // There are duplicates and I don't know why sometimes
    straight = removeDuplicates(straight)
    console.log(straight);

По какой-то причине это не работает.Но он будет работать ТОЛЬКО для первого массива, если вы измените

straight.push(arr[i-1],arr[i]); 

на

straight.push(arr[i-1],arr[i],arr[i]);

Он будет работать ТОЛЬКО для второго массива, если вы поменяете имена переменных:

  var arr2 = [9,1,2,11,8,12,10];   // first array
  var arr = [9,1,8,4,5,3,2];     // second array

и запустить код без дальнейших изменений, я не знаю, почему это происходит.Я даже дошел до того, что записал логическое значение

    arr[i-1] - arr[i] === 1

на консоль (я имею в виду в цикле), и это получается четыре раза подряд (проходя через первые 5 индексов массива)), поэтому я не знаю, почему он останавливается на 11 для первого массива и решает, что 11-10 не равен 1.

Answer 1

let arr = [9,1,2,11,8,12,10];

function checkStraight(arr) {
  let answer = [];
  
  if(arr.length < 5)
    return false;

  arr = [...new Set(arr)];
  arr.sort(function(a,b){return b-a});

  for(let index=0; index < arr.length; index++){
    if(answer.length === 5) break;

    if(answer.length === 0){
      answer.push(arr[index])
    }

    if(answer[answer.length-1] - arr[index] === 1){
    	answer.push(arr[index]);
    }else{
      answer = [];
      answer.push(arr[index])
    }
  } 
  
  return answer
}

console.log(checkStraight(arr));

Вы можете попробовать выполнить код, должно быть довольно просто.По сути, вместо того, чтобы сравнивать элементы внутри собственного массива, мы сравниваем два массива и условно помещаем совпавшую прямую карту в новый массив

** предположения: ** Поскольку мы играем в покер, предполагая, что раз 5 последовательных карт былинайдено, это считается прямой и дальнейшая проверка не требуется

Answer 2

вашей логике немного сложно следовать - я думаю, что проблема, которую вы видите, связана с очисткой массива straight в части if (straight.length === 2).Вот мой шанс упростить вещи:

const isStraight = a => { 
  const uniq = a.filter((val, idx) => a.indexOf(val) === idx);
  uniq.sort((a, b) => a-b); 
  const tries = uniq.length - 4;
  for (var i=0; i<tries; i++) {
    if (uniq[i + 4] - uniq[i] === 4) {
      return true;
    }
  }
  return false; 
}

console.log(isStraight([9,1,2,11,8,12,10]));
console.log(isStraight([9,1,8,4,5,3,2]));
console.log(isStraight([2,5,4,3,6,8,7]));
console.log(isStraight([2,5,4,3,6,8,7,10]));
console.log(isStraight([2,5,2,4,7,3,6,8,8,8,8,7]));
console.log(isStraight([1,2,3,4,6,7,8,9,11,12,13,13]))