Flash as3 Comment puis-je supprimer les doublons dans un tableau?

Salut, je viens d'avoir un tableau de noms (chaînes de caractères) en flash, et je veux faire en sorte que tous les doublons à partir de la matrice sont supprimés, ou au moins qu'une fonction est exécutée qu'une seule fois par reocurring valeur dans le tableau.

InformationsquelleAutor mheavers | 2011-05-13
  1. 5

    Plus de chat dépouillement:

    var a:Array = ["Tom", "John", "Susan", "Marie", "Tom", "John", "Tom", "Eva"];
a.sort();
var i:int = 0;
while(i < a.length) {
    while(i < a.length+1 && a[i] == a[i+1]) {
        a.splice(i, 1);
    }
    i++;
}
    InformationsquelleAutor Lars Blåsjö
  2. 18

    De nombreuses façons. Vous pouvez trier le tableau et itérer sur elle en ignorant les entrées qui correspondent à l'itération précédente. Ou vous pouvez utiliser indexOf() pour rechercher les doublons. Ou vous pouvez prendre une passe sur le tableau, construire un dictionnaire à la clé sur les cordes (et d'ignorer les touches qui ont déjà une entrée).

    Ici est le Dictionnaire façon, la mémoire, le coût de 1 booléen par entrée unique, facile sur la mémoire pour quand vous vous attendez à beaucoup de dupes, et rapide. Si vous avez relativement peu de dupes, le tri + abattage consécutives de dupes est probablement plus efficace

    import flash.utils.Dictionary;

var array:Array = ["harry","potter","ron","harry","snape","ginny","ron"];
var dict:Dictionary = new Dictionary();

for (var i:int = array.length-1; i>=0; --i)
{
    var str:String = array[i] as String;
    trace(str);
    if (!dict[str])
    {
        dict[str] = true;
    }
    else
    {
        array.splice(i,1);
    }
}

dict = null;


trace(array);

    Voici un tri moyen, mais attention: CELA NE permet PAS de PRÉSERVER l'ORDRE! Vous n'avez pas dit si ce qui compte. Mais parce que c'est à l'aide de quicksort, il a tendance à avoir O(N log N) performance, en plus de la dispense de passer, à moins bien sûr de vos données est un cas pathologique.

    var array:Array = ["harry","potter","ron","harry","ron","snape","ginny","ron"];

array.sort();
trace(array);

for (var i:int = array.length-1; i>0; --i)
{
    if (array[i]===array[i-1])
    {
        array.splice(i,1);
    }
}


trace(array);

    En plus de ne pas préciser si l'ordre des questions, vous n'avez pas de dire si c'est des questions qui des dupes est à gauche: l'un à l'indice le plus bas, ou le dernier a trouvé. Si ce qui compte, vous aurez besoin de re-commander mon dictionnaire exemple à courir dans la direction opposée. J'ai commencé à la fin parce que de fait, il est OK pour faire une épissure sans invalider le nombre de boucles (c'est à dire en modifiant la matrice.longueur au cours de la boucle) Si l'ordre des questions, boucle habituelles dans le sens de la marche et de la copie de la première occurrence de chaque chaîne d'un nouveau tableau, ou de modifier le compteur de la boucle comme ceci. C'est probablement la technique que j'utilise, car elle préserve la commande et conserve la première rencontrées instance de chaque chaîne:

    import flash.utils.Dictionary;

var array:Array = ["harry","potter","ron","harry","snape","ginny","ron"];
var dict:Dictionary = new Dictionary();

var len:int = array.length;
for (var i:int = 0; i<len; ++i)
{
    var str:String = array[i] as String;
    if (!dict[str])
    {
        dict[str] = true;
    }
    else
    {
        array.splice(i,1);
        i--; len--;
    }
}

dict = null;


trace(array);
    InformationsquelleAutor Adam Smith
  3. 4

    Bonnes réponses!

    J'ai vérifié quelques-uns d'entre eux, et ils ont de moins bons résultats, contrairement à la mienne.
    Exemple:

    const origin: Vector.<String> = Vector.<String>(["a", "c", "d", "c", "b", "a", "e", "b", "a"]);

function getUniqueVector(origin: Vector.<String>): Vector.<String> {
    const n: uint = origin.length;
    var res: Vector.<String> = new Vector.<String>();
    var i: int = 0;

    while(i < n) {
        var el: String = origin[i];
        if(res.indexOf(el) == -1) res.push(el);
        i += 1;
    }

    return res;
}

trace(getUniqueVector(origin)); //unique elements vector

    Statistiques avec mes données:

    Dict approche: 8946ms, 8718ms, 8936ms

    Obj approche: 8800ms, 8809ms, 8769ms

    Mon ancienne approche: 8723ms, 8599ms, 8700ms

    Cette approche: 6771ms, 6867ms, 6706ms

    Mise à jour 02 /JUL /2019

    Intéressant de noter que, pour de meilleures performances, pour créer l'objet, et de définir chaque poussée de valeur de la clé de O(1) de la complexité de la récupération, de sorte que les résultats seront un peu mieux.

    Mais le Flash est mort, et probablement ActionScript, donc c'était un enterrement de discours 🙁

    InformationsquelleAutor dimpiax
  4. 3

    C'est une façon de le faire, je suis sûr qu'il en existe d'autres. 

    function removeDuplicate(sourceArray:Array) : void
{
    for (var i:int = 0; i < sourceArray.length - 1; i++)
    {
        for (var j:int = i + 1; j < sourceArray.length; j++)
        {
                if (sourceArray[i] === sourceArray[j])
                {   
                     //Remove duplicated element and decrease j index.
                     sourceArray.splice(j--, 1);
                }
        }
    }
}
    • Que feriez en place, mais c'est très gourmande en termes de temps, de la complexité, pas la meilleure solution. Il ya beaucoup de façons de le faire qui ne sont pas en O(N^2). Exactement la solution est optimale pour les données réelles dépend un peu de ce qu'il est attendu pour la fréquence des dupes.
    • ouais,d'accord. Juste lui donner un concept à travailler avec. Compte tenu de toute situation, vous pouvez choisir un autre marteau.
    • Mais, je suppose un tutoriel sur tout le potentiel de marteaux et de leurs avantages et inconvénients, pourrait être utile. Je vais passer sur ce point pour l'instant.
    • J'ai jeté mes idées dans mon post. Je n'avais pas pris la peine d'écrire du code plus tôt, parce que j'étais au travail, mais si le tableau a beaucoup attendu de la duplication, à l'aide d'un dictionnaire comme une simple carte est un O(N), solution sur le plan du temps, et vous aurez à le plus besoin de 1 Booléen par unique entrée de la valeur de la mémoire supplémentaire (beaucoup moins que n'importe quelle solution qui consiste à copier les chaînes de caractères à un nouveau tableau).
    InformationsquelleAutor prototypical
  5. 1

    Voici une autre façon de faire, peut-être un peu plus agréable à regarder:

    var removeList:Array = [];

//loop over every item in the original array
for each (var item:* in array) {
    //loop over every item again, checking for duplicates
    for each (var other:* in array) {
        //if two items that aren't the same item are equal and `other` doesn't
        //exist in the remove list, then cache it for later removal.
        if (item == other && item !== other && removeList.indexOf(other) == -1)
            removeList.push(other);
    }
}

//next, loop over the cached remove list and remove 'selected' items for removal
for each (var remove:* in removeList) 
    array.splice(array.indexOf(remove), 1);

    Ce n'est probablement pas le plus performant manière de faire, @prototype de la méthode est sans doute beaucoup plus efficace, mais c'est la théorie que vous avez demandé 🙂

    InformationsquelleAutor Naftuli Kay
  6. 1

    J'ai voté pour Adam option, mais ensuite, j'ai trouvé cela, et il me semble que cela pourrait être une meilleure performance sage encore?

      for (var i:uint = array.length; i > 0; i--){
     if (array.indexOf(array[i-1]) != i-1){
        array.splice(i-1,1);
     }
  }

    L'idée ici est que vous boucle vers l'arrière à travers la matrice, et depuis indexOf vous donne la première survenue d'index, vous pouvez vérifier la trouvé de l'indice à l'indice actuel(i) et supprimer si non le même.

    InformationsquelleAutor Flion
  7. 1

    Ici est une façon plus élégante de la suppression des doublons:

    var items:Vector.<String> = Vector.<String>(['tortoise', 'cat', 'dog', 'bunny', 'dog', 'cat', 'bunny', 'lion']);

var uniqueItems:Vector.<String> = items.filter(function(item:String, index:int, vector:Vector.<String>):Boolean {
    return index==0?true:(vector.lastIndexOf(item, index-1) == -1);
});

    Même approche pour un tableau:

    var items:Array = ['tortoise', 'cat', 'dog', 'bunny', 'dog', 'cat', 'bunny', 'lion'];

var uniqueItems:Array = items.filter(function(item:String, index:int, array:Array):Boolean {
        return index==0?true:(array.lastIndexOf(item, index-1) == -1);
    });
    InformationsquelleAutor CyberProdigy
  8. 0

    aurait @prototype de la réponse donne pas de questions si les sourceArray[i] correspond à sourceArray[j] plus d'une fois, car la longueur de sourceArray serait plus courte si un élément a été .splice()d hors de lui?

    J'ai réécrit cette méthode pour compter de la fin pour que cela n'arrive pas

    for (var i:int = sourceArray.length - 2; i >= 0; --i) 
{
    for (var j:int = sourceArray.length - 1; j > i; --j)
    {
        trace(i, j);
        if (sourceArray[j] === sourceArray[i]) sourceArray.splice(j, 1);
    }
}
    InformationsquelleAutor obie
  9. 0
    function removeDuplicateElement(_arr:Array):Array{
   //set new Dictionary
   var lDic:Dictionary = new Dictionary();
   for each(var thisElement:* in _arr){
      //All values of duplicate entries will be overwritten
      lDic[thisElement] = true;
   }
   _arr = [];
   for(var lKey:* in lDic){
     _arr.push(lKey);
  }
  return _arr;
}
    InformationsquelleAutor Nizar