1
votes

Recherche dans un tableau multidimensionnel (algorithme)

La question

Ecrivez une fonction qui obtient une séquence et une valeur et renvoie vrai / faux selon que la variable existe ou non dans une séquence multidimensionnelle.

Exemple:

var locate = function(arr, value){
  let count = 0;
  arr.flat().map((item)=>{
    value == item ? count++ : count;
  });

  return count > 0 ? true : false;
}

Ma solution semble fonctionner, mais Code Wars dit: "arr.flat n'est pas une fonction.

J'utilise le navigateur de code camp gratuit pour exécuter et testez mon code, et les journaux de ma console suggéraient que cela fonctionnait, mais Code Wars disait que arr.flat n'est pas une fonction. Voici mon code:

locate(['a','b',['c','d',['e']]],'e'); // should return true
locate(['a','b',['c','d',['e']]],'a'); // should return true
locate(['a','b',['c','d',['e']]],'f'); // should return false

Ma question

Mon code est-il correct ou non? Sinon, qu'est-ce qui ne va pas? Si tel est le cas, pourquoi Code Wars pourrait-il générer une erreur?

javascript algorithm arrays

2 commentaires

Array.prototype.flat () n'est pas encore largement supporté, peut-être que Code Wars ne le supporte pas non plus? Vous pouvez toujours utiliser l'une des alternatives MDN propose .

ça a du sens! Merci :)

4 Réponses :

1
votes

Cela semble fonctionner ici. Il est donc probable que le navigateur sur lequel vous testez ne prend pas en charge flat()

var locate = function(arr, value){
  let count = 0;
  arr.flat().map((item)=>{
    value == item ? count++ : count;
  });
  return count > 0 ? true : false;
}

console.log(locate(['a','b',['c','d',['e']]],'e')); // should return true
console.log(locate(['a','b',['c','d',['e']]],'a')); // should return true
console.log(locate(['a','b',['c','d',['e']]],'f')); // should return false

0 commentaires

2
votes

Vous pouvez adopter une approche récursive avec un court-circuit lors de la recherche.

function locate(array, value) {
    return array.some(v => Array.isArray(v) && locate(v, value) || v === value);
}

console.log(locate(['a', 'b', ['c', 'd', ['e']]], 'e')); // true
console.log(locate(['a', 'b', ['c', 'd', ['e']]], 'a')); // true
console.log(locate(['a', 'b', ['c', 'd', ['e']]], 'f')); // false

0 commentaires

1
votes

Vous n'avez pas besoin de .flat pour cela (bien que cela permettrait la solution la plus élégante de const Locate = (arr, value) => arr.flat (). includes (valeur); ). Voici une solution récursive simple utilisant une boucle for ordinaire:

const locate = function(arr, value) {
  for(let i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[i]) {
      if (locate(arr[i], value) {
        return true;
      } 
    }
    if (arr[i] === value) {
      return true;
    } 
  }
  return false;
}

0 commentaires

1
votes

Puisque flat est pris en charge dans votre environnement, écrivez votre propre méthode flat et utilisez le includes

const flat = (arr, res = []) => (
  arr.forEach((item) =>
    Array.isArray(item) ? flat(item, res) : res.push(item)
  ),
  res
);

const locate = (arr, value) => flat(arr).includes(value);

console.log(locate(["a", "b", ["c", "d", ["e"]]], "e"));
console.log(locate(["a", "b", ["c", "d", ["e"]]], "a"));
console.log(locate(["a", "b", ["c", "d", ["e"]]], "f"));

0 commentaires