essayer d'imprimer toutes les valeurs qui sont duplicate. Avoir un problème visualisant ce que je dois faire. Cela ne fonctionne pas.
Ceci est différent de toute autre question similaire car je veux que toutes les valeurs dupliquées soient imprimées, pas seulement celles qui ont des duplicats. Strong> P> Pourriez-vous aussi donner la complexité du temps / espace du résultat également? strong> p> Ceci devrait imprimer 2, 2, 4, 4, 7, 7 P> P>
const printDuplicates = (arr) => {
let newArray = [];
for (let i = 0; i < arr.length; i++) {
if (arr[i] === arr[i] + 1) {
newArray.push(arr[i]);
}
}
return newArray
}
console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));
5 Réponses :
o (2n) forte> complexité de temps (détails ici ) p >
function printDuplicates(a) {
let r={};
a.map(a=>!(1-(r[a]=++r[a]|0)) );
return a.filter(x=>r[x]);
}
console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]))
Vous devez ajouter plus d'informations sur le code
@ Jyy ce n'est pas clair?
Compte tenu de la question, je pense que cela ne suffit pas à comprendre
je comprends beaucoup mais il y a beaucoup de choses en cours
Essayez ceci:
p>
arr.filter(y => y == x).length
Vous devez ajouter plus d'informations sur le code
@Jey merci, à la caisse mon édition.
Vous filtrez donc les résultats filtrés?
Non, le filtre interne S vient d'être utilisé pour compter les occurrences. Comme dans elle filtre le tableau et compte le nombre de fois que l'élément est apparu. Ensuite, le premier filtre utilise cette valeur pour décider s'il souhaite inclure l'élément ou non
@ mph85 vérifier ma mise à jour
Ah ICIC Merci pour cela, a du sens. Je cherche également la complexité de temps / espace aussi. J'ai un peu savoir comment calculer le temps, mais pas la complexité spatiale
@ MPH85 Eh bien, si vous avez besoin d'une méthode théorique, je ne pense pas avoir quelque chose à offrir. Mais si vous voulez juste une réponse pratique, je pense que vous pouvez utiliser un très très grand tableau en tant que cas de test et surveiller l'utilisation de la RAM tout en exécutant chaque algorithme.
hm rien de fou, juste une explication simple. Peut-être que quelque chose comme je filtrais la première fois, cela devrait être O (n), et puisque nous exécutons ce filtre à nouveau, peut-être O (N2)?
@ MPH85 Eh bien, c'est la complexité du temps et que vous avez dit que vous savez à ce sujet, je parlais de complexité de l'espace. Mais de toute façon, je pense que tu as raison et c'est O (N2)
Je pourrais me tromper, mais on m'a dit que peut-être dans ce cas, la complexité de temps et d'espace serait la même.
@ mph85 désolé, je ne sais pas à ce sujet
Pas d'inquiétude, j'apprécie l'aide, j'ai accepté votre réponse
Question rapide, quelle est cette partie arr.filter (y => y == x) .Length> 1 , le longueur supérieure à 1 tout?
@ MPH85 Nombre d'occurrences supérieures à 1
@AMIR, fondamentalement, cette partie arr.filter (y => y === x) .Length> 1 dit que je veux filtrer toutes les valeurs qui sont dupliquées ou qui sont égales à celle-ci. cela se produit plus d'une fois? et le filtre extérieur veut renvoyer ces résultats filtrés?
Voici une solution - bien que je dois admettre que ce n'est pas le plus élégant mais le plus facile à comprendre:
Il y a de nombreuses façons de le faire, voici un exemple en utilisant p> array.filter code>
const printDuplicates = (arr) => {
let newArray = [];
for (let i = 0; i < arr.length; i++) {
let targetValue = arr[i];
let numFound = arr.filter(val => val === targetValue).length;
let results = {
targetValue,
numFound
}
newArray.push( results );
i += ( numFound - 1 );
}
return newArray
}
console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));
apprécier l'aide, mais tout ce que je cherchais était les valeurs qui étaient duplicats, cela va au-delà de cela
Oui, cela fait, mais c'est une habitude à moi d'utiliser une collection pour pouvoir filtrer ultérieurement.
Si les duplicats sont adjacents et que vous souhaitez les afficher, y compris les répétitions, y compris les répétitions.
p>
const printDuplicates = (arr) => arr.filter((_,indx) => arr[indx] === arr[indx+1] || arr[indx] === arr[indx-1]); console.log(printDuplicates([1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9]));
Quel est ce soulignement (_, indx) tout?
Filtre iTère via la matrice et dans chaque itération vous donne (élément, index, Arr) dans cet ordre, et je n'ai pas besoin de l'élément, donc je mets un soulignement pour l'ignorer et d'utiliser le indice.
Ah donc à tout moment vous voulez ignorer cela, vous devez mettre un soulignement?
Non, vous pouvez mettre n'importe quoi, et simplement ne pas l'utiliser.
Vous voulez
arr [i + 1] , pasarr [i] + 1 . Je vote pour fermer ceci comme faute de frappe.arr [i] === arr [i] + 1 ne peut jamais être vrai. Une valeur ne peut pas être égale à elle-même + 1. (Exception:Infinity ).Plus que l'infini:
1e20 === 1e20 + 1@Trincot: assez juste. Valeurs> = 2 ^ 53 En raison du manque de précision.
Je n'ai pas abouti de réponses, c'est tout le monde
@ MPH85 Si l'une des réponses résout votre problème, veuillez l'accepter. Ou dites-nous ce qui ne va pas pour que nous puissions aider
@ mph85 est ma réponse claire pour vous?
La plupart de ces réponses fonctionnent, ai-je seulement autorisé à accepter une réponse?
J'ai suscité toutes les réponses, mais cela ne montre que parce que je suis toujours noobie, je pense avoir besoin de quelques points de reproduction plus pour qu'il apparaisse