Juste au cas où vous manqueriez, la question concerne la suppression des doublons sur un tableau code> code>. Qui peuvent être appliqués des algorithmes très rapides (comparés aux tableaux non formés) pour éliminer les doublons.
Exemple: strong> p> voir?, il est très rapide. Je vais essayer d'expliquer ce qui vient d'arriver. P> Les matrices triées * Pourraient ressembler à ceci: p> * Le tri pourrait être ASC ou DESC, ou par d'autres méthodes étranges, mais l'important est que chaque élément dupliqué soit à côté de l'autre. p> Nous nous sommes arrêtés à Ensuite, nous avons ajouté le dernier élément quel que soit quoi que ce soit parce que: p> cas A: p> cas B: p> Si vous comprenez vraiment ce qui se passe, vous saurez que nous n'avons pas ajouté aucun Question: fort> p> qui expliquait, je veux faire la même chose, mais ignorer la valeur Je veux enlever ceux-ci. Et sur le cas, j'ai des valeurs réelles Ma mauvaise tentative est celle-ci: p> array.longueur-1 code> parce que nous n'avons rien à vérifier avec p> ..., 9,9,9]; // nous avons dup (S) à gauche du dernier élément code> p> ..., 7,9,10]; // Nous n'avons pas de dup (S) à gauche du dernier élément code> p> 9 code> sur le cas A. Ainsi, à cause de cela, nous voulons ajouter le dernier élément, peu importe si nous sommes au cas où nous sommes au cas ou b. P>
non définie code> sur des cas tels que: p> non définies code> non définies, celles-ci ne doivent pas être supprimées. P> var out=[];
for (var i=0,len=arr.length; i < len - 1;) {
var x = false;
var y = false;
for (var j = i, jo; j < len - 1; j++) {
if (j in arr) {
x = true;
jo = arr[j];
i = j + 1;
break;
}
}
if (x == false) {
break;
}
for (var u = i, yo; u < len - 1; u++) {
if (u in arr) {
y = true;
yo = arr[u];
i = u + 1;
break;
}
}
if (y == false) {
out.push(jo);
break;
}
if (jo !== yo) {
out.push(jo);
}
}
out.push(arr[len - 1]);
15 Réponses :
Ceci est une doublure: si vous n'avez pas déjà uniquify code> écrit (la fonction que vous avez écrite pour supprimer des duplicates), vous pouvez aussi Utilisez cette double doublure: p> var a=[];
a[0]=1; a[1]=undefined; a[2]=undefined;
a[10]=2; a[11]=2;
Notez que cela nécessite un navigateur moderne qui prend en charge array.reduce . Par exemple, cela ne fonctionnera pas sur <= IE8.
Merci de votre préoccupation. Cependant, cela fait plus d'une demi-dix décennie depuis la libération de IE8. Le système d'exploitation qu'il a été publié a été officiellement fin de vie par Microsoft depuis des années. Même sur Windows 7, selon ordinateurworld.com/s/article/9215845/... Microsoft a commencé à proposer des téléchargements popup poussés sur des ordinateurs qui utilisent toujours IE8 (et c'était il y a un an). Cela a été dans la norme ECMAScript 5 depuis 2009. Programmation sans Array.map () /. Filtre () /. TRANEACH () est une douleur sans comparer et rappeler C.
Je ne parle pas de ceux-ci non définis, je parle de la non-définition qui ne sera pas alertée ici ici pour (var i = 0; i
@ninjagecko 2009 n'est pas "il y a plus d'une demi-décennie", et c'est-à-dire <= 8 a encore plus de deux fois la part de marché de IE9, donc je pense que c'est toujours une préoccupation valable.
(La première non-bêta) IE8 a été libérée en 2009 et en décembre 2011 avait toujours une part de marché de 22%, mais si vous êtes heureux de ne pas tenir compte d'un utilisateur potentiel sur cinq, allez à l'avance. Notez que de nombreuses personnes ne sont empêchées d'utiliser IE9 en raison des restrictions de politique informatique de chantier (par exemple, sur mon lieu de travail actuel, nous sommes toujours sur XP et IE_7_).
@Peterolson: Ah Désolé, je voulais dire 2008, il y a 4 ans. Je concéderai le point de partage du marché, avec la mise en garde voulant que ce soit une préoccupation dépend de votre public. Si la plupart de ces ordinateurs ont réellement des humains derrière eux et si les humains visiteront le site que l'on construit ou parle la même langue, ne peut être mesuré que en collectant des statistiques sur le site que l'on consiste à bâtir. Il est clair que 5 à 10% des utilisateurs d'Internet sont toujours sur MIE8. On peut toujours répondre à ces utilisateurs sans aller d'être insensé ou ralentir l'évolution des normes Web, en utilisant des bibliothèques telles que JQuery / GWT ou le lien ci-dessus.
Je pense que c'est ce que vous voulez. C'est un algorithme assez simple.
var out = [], previous;
for(var i = 0; i < arr.length; i++) {
var current = arr[i];
if(!(i in arr)) continue;
if(current !== previous) out.push(current);
previous = arr[i];
}
Cela ne répond pas à l'exigence de l'OP de distinguer entre les éléments de tableau qui ont été attribués à la valeur non définie non définie (qui doivent être conservés) et des index qui n'ont jamais eu une valeur attribuée.
@nnnnnn Je ne suis pas sûr que je comprenne, je lui ai demandé quel comportement il voulait et il vient de supprimer de supprimer des Dupes même s'il n'y a pas d'indéfinie entre les deux. Ne veut-il pas que des dupes soient supprimés pour les tableaux qui ont des valeurs affectées à non défini entre les valeurs dupliquées?
Considérez: var arr = []; arr [5] = 1; arr [9] = indéfini; arr [11] = indéfini; arr [13] = 3 - Après ce code arr.length est 14, mais les positions d'index 0-4, 6-8, 10 et 12 n'ont jamais été attribuées de valeur et il est ceux que l'OP veut sauter. Les index 9 et 11 ont été explicitement attribués non définis et ne doivent pas être ignorés. OP a mentionné cela sous la "question" en rubrique à mi-chemin à travers le poste, mais ne l'expliquait pas très bien. Et puis le commentaire censé clarifier en fait rendu moins clair (alors peut-être que j'ai mal interprété).
@Peterolson Je voulais dire non défini qui ne détiennent pas la valeur non définie . En d'autres termes, ils n'apparaîtront pas ici pour (i = 0; i
Oui, c'est ce que je cherchais. Je suis désolé que mes instructions non soi-seules vous mènent à y répondre après «Nnnnnn». J'accorde l'entière responsabilité de ce qui s'est passé ici.
Pour un début, je ne suis pas entièrement certain que votre code d'origine est casher. Il me semble que cela ne fonctionne peut-être pas bien lorsque la liste d'origine est vide, puisque vous essayez de pousser le dernier élément, peu importe quoi. Il peut être mieux écrit comme suit: sur votre question actuelle, je vais y répondre comme un algorithme puisque je ne connais pas beaucoup de JavaScript, mais il me semble que vous pouvez Rappelez-vous simplement le dernier numéro transféré, quelque chose comme:
J'aime cette logique, signalez-vous quand d'abord est meilleur que de vérifier si la longueur de la matrice est 0
Un moyen explicite serait d'emballer la matrice ( Supprimer les valeurs code> non définies em>) et utilisez votre algorithme existant pour les doublons à ce sujet. function pack(_array){
var temp = [],
undefined;
for (i=0, len = _array.length; i< len; i++){
if (_array[i] !== undefined){
temp.push(_array[i]);
}
}
return temp;
}
L'idée "Pack" a également été mon première impulsion et des points bonus pour s'assurer que non défini est vraiment non défini, mais que votre implémentation ne respecte pas l'exigence de l'OP de distinguer les éléments de la matrice qui ont été attribué la valeur indéfinie non définie (qui doit être conservée) et des index qui n'ont jamais eu une valeur attribuée (qui doivent être sautés).
@nnnnnn, hmm .. Point valide, bien que je ne sois pas sûr si c'était bien le problème de l'OP. Je le lis comme une explication que les valeurs sont vraiment indéfinies. Non pas qu'il voulait une manipulation différente.
Peut-être quelque chose comme ceci:
var out = [],
prev;
for(var i = 0; i < arr.length; i++) {
if (!(i in arr))
continue;
if (arr[i] !== prev || out.length === 0) {
out.push(arr[i]);
prev = arr[i];
}
}
Parfait. Je vais simplement changer les symboles d'égalité en arr [i]! == prev et out.length == 0 . (Je pense que c'est ce que tu veux dire en premier lieu)
Merci. Oui, j'aurais dû dire arr [i]! == prev - bonne prise - j'ai mis à jour ma réponse pour refléter ceci. Mais j'ai dit que out.length === 0 (la longueur du tableau sera toujours numérique).
"La longueur du tableau sera toujours numérique", alors pourquoi le === ?
Pourquoi pas === ? J'utilise == n'est allé que je veux pouvoir comparer les opérandes de (potentiellement) différents types pouvant être contraints au même type et à la même valeur.
J'utilise seulement === et ! == Quand je pense que la force pourrait produire des éléments inattendus, si je sais exactement ce que je traite, et que == ou ! = ne me fera jamais dans des problèmes, je vais les utiliser et économiser 1 caractère
Une fonction très simple, la matrice d'entrée doit être triée:
function removeDupes2(arr) {
var noDupes = [],
o;
for (var i=0, j=0, iLen=arr.length; i<iLen; i++) {
o = arr[i];
if (o != noDupes[j] && i in arr) {
noDupes.push(o);
j = noDupes.length - 1;
}
}
return noDupes;
}
Il supprime les deux éléments qui contiennent la valeur non définie et le faux non défini . (Je veux seulement retirer les faux)
Edit très simple de changer cela (fait), bien que ce soit une exigence étrange
Je crois ce que vous essayez de réaliser n'est pas tout à fait possible, mais je pourrais me tromper.
C'est comme l'un de ces problèmes classiques CS comme celui où un coiffeur dans un village ne fait que raser celui qui ne le fait pas se raser eux-mêmes.
Si vous définissez la valeur d'un élément d'index d'un tableau comme Ce que vous devez vérifier est de savoir si une valeur est si non défini code>, ce n'est pas vraiment non défini code>.
N'est-ce pas le cas? Une valeur ne peut être que non définie code> quand il n'a pas été initialisé. P> null code> ou indéfini code>. Si NULL code> ou dupliquer saute la valeur, sinon le retenir. p> null code> Les valeurs et les doublons sont ce que vous essayez de sauter, puis de la fonction ci-dessous fera le tour. P> function removeDuplicateAndNull(array){
if(array.length==0)
return [];
var processed = [], previous=array[0];
processed.push(array[0]);
for(var i = 1; i < array.length; i++) {
var value = array[i];
if( typeof value !== 'undefined' && value ==null)
continue;
if(value !== previous || typeof value === 'undefined')
processed.push(value);
previous = array[i];
}
return processed;
}
Les ouvrages ANS acceptés, il filtre le non défini mais respectant le jeu manuellement non défini. Utilisez son code avec -> var arr = []; arr [3] = 1; arr [5] = non défini; arr [6] = non défini; Arr [8] = TRU E; ARR [10] = vrai; et la sortie doit être 1 , true
Supposons que vous ayez une matrice de tri et vous ne pouvez pas utiliser de matrice supplémentaire pour trouver et supprimer des doublons:
dans Python P>
def findDup(arr, index=1, _index=0):
if index >= len(arr):
return
if arr[index] != arr[_index]:
findDup(arr, index+1, _index+1)
if arr[index] == arr[_index]:
arr = deletedup(arr, index)
findDup(arr, index, _index) #Has to remain same here, because length has changed now
def deletedup(arr, del_index):
del arr[del_index]
return arr
arr = [1, 2, 3, 4, 4, 4, 5, 6, 7, 7, 7, 7, 7]
findDup(arr)
print arr
splice(targetPosition,noOfElementsToBeRemoved)
Ce code est écrit dans JavaScript . Son très simple. code:
arr.filter ((e, i, a) => E! == A [I-1]); CODE> H2> Je suis très surpris par la complexité d'autres réponses ici, même celles qui utilisent .filter () code> p> même en utilisant la syntaxe ES5 ancienne sans flèche Fonctions: p> xxx pré> exemple: p> xxx pré> Si vous devez muter la matrice en place, utilisez simplement: P >
arr = arr.filter((e, i, a) => e !== a[i - 1]);
Voici la solution JavaScript simple sans utiliser d'espace supplémentaire.
function removeDuplicates(A) {
let i = 0;
let j = i + 1;
while (i < A.length && j < A.length) {
if (A[i] === A[j]) {
A.splice(i, 1);
j=i+1;
} else {
i++;
j++;
}
}
return A;
}
console.log('result', removeDuplicates([0,1,1,2,2,2,2,3,4,5,6,6,7]))
Vous pouvez essayer le moyen simple un code de doublure
Voici une solution simple pour supprimer des doublons de la matrice triée.
p>
function removeDuplicate(arr) {
let i=0;
let newArr= [];
while(i < arr.length) {
if(arr[i] < arr[i+1]) {
newArr.push(arr[i])
} else if (i === (arr.length-1)) {
newArr.push(arr[i])
}
i++;
}
return newArr;
}
var arr = [1,2,3,4,4,5,5,5,6,7,7]
console.log(removeDuplicate(arr))Cette solution supprime les éléments dupliqués sur place. Non recommandé pour la programmation fonctionnelle
p>
const arr =[0,0,1,1,2,2,2,3,4,5,5,6,7,7,8,9,9,9];
const removeDuplicates = (nums) => {
nums.forEach((element, idx) => {
nums.splice(idx, nums.lastIndexOf(element) - idx)
})
}
removeDuplicates(arr)
console.log(arr);
Quel comportement voulez-vous? Voulez-vous simplement ignorer les parties de la matrice qui n'existent pas, ou quoi?
@Peter je veux supprimer des DUPS même s'il n'y a pas d'indéfini entre
Je pense que vous devriez simplement emballer la matrice initiale dans une ( retirer des valeurs indéfinies ) et travailler avec cela pour la vérification en double ..