Почему мой код возвращает значение true только один раз при сравнении двух массивов?

Question

Я пытаюсь решить проблему codewars, и я не могу заставить свой код работать.

a1 = [121, 144, 19, 161, 19, 144, 19, 11];
a2 = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19];

Test.assertEquals(comp(a1, a2), true);

  function comp(array1, array2){
     let newArray1Squared = [];
     let newArray1 = a1.sort(function(a, b){
     return a - b;
  });

  newArray1.map(function(num){
    newArray1Squared.push(num*num);
  });

  let newArray2 = a2.sort(function(a, b){
    return a - b;
  });

  for (let i = 0; i<newArray1Squared.length; i++){
    if (newArray1Squared[i] === newArray2[i]){
      return true;
    } else {
      return false;
    }
  }
}

Пока это мой код. И проблема в следующем:

Для двух массивов a и b напишите функцию comp (a, b) (compSame (a, b) в Clojure), которая проверяет, имеют ли два массива "одинаковые" элементы, с одинаковые кратности. «То же» означает здесь, что элементы в b являются элементами в квадрате, независимо от порядка.

Примеры Допустимые массивы

a = [121, 144, 19, 161, 19, 144, 19, 11]  
b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]

comp (a, b) возвращает true потому что в b 121 квадрат 11, 14641 квадрат 121, 20736 квадрат 144, 361 квадрат 19, 25921 квадрат 161 и т. д. Это становится очевидным, если мы напишем элементы b в виде квадратов:

Answer 1

Функция вызывается только один раз и завершается при использовании оператора return. Вы проверяете только первое значение массива.

Вам необходимо реорганизовать свою функцию, чтобы использовать for l oop снаружи, и запускать тест в каждом цикле.

Я думаю, что это работает :

a1 = [121, 144, 19, 161, 19, 144, 19, 11];
a2 = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19];


let newArray1 = a1.sort(function(a, b){
  return a - b;
});
let newArray2 = a2.sort(function(a, b){
    return a - b;
});

for (let i = 0; i<newArray1.length; i++){  
    console.log(comp(newArray1[i], newArray2[i])); //Run the test for every value in the array
}

function comp(value1, value2){
  let squareValue1 = value1*value1; 
  return squareValue1 === value2;
}

Answer 2

Вы можете решить эту проблему, используя объект для хранения счетчика вхождений каждого значения в массиве 1, затем go через массив 2 и уменьшив счетчик вхождений в объекте, и, наконец, вы выполните итерацию по объекту, чтобы увидеть, все ли значения: 0.

Проверьте ниже:

var a1 = [121, 144, 19, 161, 19, 144, 19, 11];
var a2 = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19];

function comp(array1, array2) {
  var temp = {};

  if(array1.length != array2.length)
    return false;

  for(let a of array1) {
    if(temp[a]) {
      temp[a]++;
    } else {
      temp[a] = 1;
    }
  }

  for(let a of array2) {
    let sqrt = Math.sqrt(a);
    if(temp[sqrt] && temp[sqrt] > 0) {
      temp[sqrt]--;
    } else {
      return false;
    }
  }

  var keys = Object.keys(temp);

  for(let key of keys) {
    if(temp[key] != 0)
      return false;
  }

  return true;
}

console.log(comp(a1, a2));

Answer 3

В вашем for l oop вы в настоящее время сравниваете только первый элемент в отсортированных массивах. Любой элемент, кроме самого низкого, рассматриваться не будет, поскольку после сравнения двух самых низких функция будет либо return true, либо return false.

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

const a1 = [121, 144, 19, 161, 19, 144, 19, 11];
const a2 = [11 * 11, 121 * 121, 144 * 144, 19 * 19, 161 * 161, 19 * 19, 144 * 144, 19 * 19];
console.log(comp(a1, a2));

function comp(array1, array2) {
  if (array1.length !== array2.length) {
    return false;
  }
  const arr1Sq = array1
    .map(num => num ** 2)
    .sort((a, b) => a - b);
  array2.sort((a, b) => a - b);
  return arr1Sq.every((num, i) => array2[i] === num);
}

.sort имеет, однако, сложность O(n log n). Для более крупных входных данных лучше использовать объект или карту вместо этого, чтобы собрать количество вхождений для общей сложности O(n):

const a1 = [121, 144, 19, 161, 19, 144, 19, 11];
const a2 = [11 * 11, 121 * 121, 144 * 144, 19 * 19, 161 * 161, 19 * 19, 144 * 144, 19 * 19];
console.log(comp(a1, a2));

function comp(array1, array2) {
  if (array1.length !== array2.length) {
    return false;
  }
  const counts = {};
  for (const item of array1) {
    const squared = item ** 2;
    counts[squared] = (counts[squared] || 0) + 1;
  }
  for (const item of array2) {
    counts[item]--;
    if (counts[item] === -1 || Number.isNaN(counts[item])) {
      return false;
    }
  }
  return true;
}