1
votes

findTwins, qui accepte un tableau d'entiers et trouve deux des mêmes nombres et renvoie le nombre qui est répété deux fois

J'obtiens une erreur et j'ai une idée de la raison pour laquelle "count" renvoie une erreur. Veuillez aider.

Ecrivez une fonction appelée findTwins, qui accepte un tableau d'entiers et trouve deux des mêmes nombres et renvoie le nombre qui est répété deux fois. La fonction doit retourner null s'il n'y a pas de nombre répété deux fois.

function findTwins(arr) {
  if (arr.length === 0) return null;
  let count = {};
  //count occurances of each item
  for (let i = 0; i < arr.length; i++) {
    let num = arr[i];
    //if element isn't in given key, assign it value '0'
    if (count[num] === undefined) {
      count[num] = 0;
    } //if element has occured in object, increase it by 1
    count[num]++;
  }

  //iterate through count object   
  for (let key in count) {
    //if value of count is 2, returns that key
    if (count[key] === 2) {
      return key;

      //if there are no repeats in array, return null    
    } else {
      (count[key] === 0) {
        return null;
      }
    }
  }
}

console.log(
  findTwins([2, 3, 6, 34, 7, 8, 2]), // 2
  findTwins([]), // null
  findTwins([3, 1, 4, 2, 5]) // null
)

javascript object count

0 commentaires

3 Réponses :

2
votes

Il vous manque un "si" dans (count [key] === 0) {
Vous devez renvoyer null à la fin de la fonction pour gérer une non-correspondance
Je n'utiliserais pas pour (let key in count) { d'un tableau - il existe des moyens beaucoup plus sûrs et meilleurs d'itérer un tableau que la traversée d'objet
li>
La réduction ou le filtrage sont de meilleures méthodes pour traiter votre tableau:

Voici une solution basée sur https://stackoverflow.com/a/35922651/295783

function findTwins(arr) {
  let res = [];
  if (arr && arr.length) {
    for (let i = 0; i < arr.length; i++) {
      var num = arr[i];
      if (arr.indexOf(num) !== arr.lastIndexOf(num) &&
          res.indexOf(num) === -1) res.push(num)
    }
  }
  return res.length ? res : null;
}


console.log(
  findTwins([2, 3, 6, 34, 7, 8, 2]), // 2
  findTwins([]), // null
  findTwins([3, 1, 4, 2, 5]), // null
  findTwins([3, 1, 2,5,4, 2, 5]) // null
)

Elle est une version basée sur la suggestion de https://stackoverflow.com/a/54966920/295783

function findTwins(arr) {
  let ret = null;
  if (arr && arr.length) ret = arr.filter(function(value, index, self) {
    return (self.indexOf(value) !== index)
  })
  return !ret || ret.length == 0 ? null : ret;
}

console.log(
  findTwins([2, 3, 6, 34, 7, 8, 2]), // 2
  findTwins([]), // null
  findTwins([3, 1, 4, 2, 5]) // null
);

0 commentaires

1
votes

Vous avez une erreur de syntaxe ici que vous avez manquée if

function findTwins(input){
  let twins = input.reduce( (op,inp) => ( (op[inp]? op[inp]++ : op[inp] = 1),op),{})
  let final =  Object.keys(twins).reduce((op,key) => ((twins[key]===2 ? op.push(+key) : op ),op),[])
  return final.length > 0 ? final : null
}

console.log(
  findTwins([2, 3, 6, 34, 7, 8, 2]), // 2
  findTwins([]), // null
  findTwins([3, 1, 4, 2, 5, 5, 5, 5]), // null
)

La meilleure façon est d'utiliser la réduction

function findTwins(input){
  let twins = input.reduce((op,inp)=>{
    if(op.entry[inp]){
      op.entry[inp]++;
      if(op.entry[inp] === 2){
        op.twins.push(inp)
      }
    } else{
      op.entry[inp] = 1
    }
    return op
  },{twins:[],entry:{}})
  return twins.twins.length > 0 ? twins.twins : null
}

console.log(
  findTwins([2, 3, 6, 34, 7, 8, 2]), // 2
  findTwins([]), // null
  findTwins([3, 1, 4, 2, 5]), // null
  findTwins([3, 1, 4, 2, 5,5,2,3,1,4])
)

Si vous ne voulez renvoyer que des nombres qui apparaissent exactement deux fois que vous ne pouvez en boucle dans cet exemple

else {
      (count[key] === 0) {  //<- here you missed if
        return null;
      }
    }

3 commentaires

@mplungjan mais c'est différent à bien des égards de votre compagnon de réponse. J'utilise réduire au lieu de filtre et d'index de. votre réponse nécessite une double boucle sur le tableau une par filtre et une seconde par indexof. tandis que celui-ci ne l'est pas. et de plus, je peux raccourcir la déclaration en réduisant mais la lisibilité est importante. je l'ai posté en envisageant une solution alternative

@mplungjan qu'entendez-vous par ce compagnon? pourrait s'il vous plaît l'expliquer un peu. tout ce qu'il fait est juste une comparaison qui a un impact presque négligeable

Ok, j'ai dû comprendre ceci: {twins: [], entry: {}}

1
votes

En utilisant indexOf et lastIndexOf, nous pouvons obtenir la position et à travers cela obtenir les éléments répétés dans un tableau.

var x = [2, 3, 6, 34, 7, 8, 2]

const c = x.filter(v => {
  if (x.indexOf(v) !== x.lastIndexOf(v)) {
    x.splice(x.lastIndexOf(v))
    return v;
  }
})
console.log(c)

2 commentaires

Solution intéressante cependant - pourquoi le filtre? On dirait que cela fonctionnerait avec une simple itération

@mplungjan Avec cela, nous n'aurons pas à parcourir l'élément répété également.