Organisez les doublons dans un tableau individuel qui est ordonné

Vous pouvez extraire des valeurs uniques en utilisant Set , puis les trier (car le tri d'un tableau de tableaux est plus complexe), puis utiliser array.reduce pour acquérir tous les éléments dans le tableau d'origine et poussez soit la valeur unique si elle est unique, sinon le tableau de valeurs (je ne sais pas pourquoi vous en avez besoin, mais quand même ..)

Référence de documentation supplémentaire:

• Qu'est-ce que Set ?
• Array.reduce

Code de travail ci-dessous:

let arr = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];

// I want to create this [[1,1,1,1],[2,2,2], 4,5,10,[20,20], 391, 392,591]

console.log([...new Set(arr)].sort((a,b) => a - b).reduce((accumulator, next) => {
	const filtered = arr.filter(i => i === next);
  return accumulator.push(filtered.length === 1 ? filtered[0] : filtered), accumulator
}, []));

Bien qu'il existe d'autres approches, chaque fois que j'ai besoin d'analyser des valeurs uniques d'un tableau de cette manière, je créerai un objet avec les propriétés de l'objet représentant les regroupements de valeurs du tableau

const arr = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];

const obj = arr.reduce((accum, val) => {
    accum[val] = accum[val] || [];
    accum[val].push(val);
    return accum;
}, {});

const finalArr = Object.values(obj).map(val => val.length > 1 ? val : val[0]);
console.log(finalArr);

Ensuite vous pouvez utiliser une méthode d'objet native pour obtenir toutes les clés ou valeurs de l'objet si vous en avez besoin (ou si votre objectif final est différent, vous pouvez utiliser l'objet selon vos besoins)

Object.keys(obj)
// or
Object.values(obj)

Vous pouvez utiliser réduire puis Array.fill . Ici, la réduction créera un objet comme celui-ci

let arr = [1, 2, 4, 591, 392, 391,1, 2, 5, 10, 2, 1, 1, 1, 20, 20];

let k = arr.reduce(function(acc, curr) {
  if (curr in acc) {
    acc[curr] += 1;
  } else {
    acc[curr] = 1
  }

  return acc;
}, {});

let grouped = [];
for (let keys in k) {
  if (k[keys] !== 1) {
    grouped.push(new Array(k[keys]).fill(+keys, 0))
  } else {
    grouped.push(+keys)
  }
}
console.log(grouped)

ce qui signifie qu'il y a 4 1s , 3 2s et ainsi de suite. Ensuite, vous pouvez utiliser le remplissage de tableau après avoir itéré cet objet. La syntaxe du tableau fill est arr.fill (valeur [ start [ end]])

Donc dans notre cas, nous allons caser new Array (k [keys]). fill (+ keys, 0, k [keys]) crée un nouveau tableau de longueur 4 , 3 donc allumé sauf pour 1 et à partir du 0ème index, il se remplit avec la clé

{
  "1": 4,
  "2": 3,
  "4": 1,
  "5": 1,
  "10": 1,
  "20": 2,
  "391": 1,
  "392": 1,
  "591": 1
}

Vous pouvez compter les occurrences, puis utiliser cet objet pour créer votre tableau final.

const arr = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];

const count = arr.reduce((acc, val) => {

  acc[val] = acc[val] + 1 || 1;

  return acc;
}, {});

const result = Object
  .keys(count)
  .sort((a, b) => a - b)
  .map((key) => count[key] === 1 ? +key : Array.from({ length: count[key] }).fill(+key));

console.log(result);

Vous pouvez faire cela de différentes manières. Mais si vous voulez réaliser de la meilleure façon, vous devez éviter les n boucles carrées .
Ainsi peut créer un dictionnaire de nombre de valeurs. Et faites une boucle sur les clés de l'objet dans l'ordre trié.

Utilisation de Array.reduce pour créer un objet de nombre d'élément de tableau. et Array.fill pour enregistrer un tableau avec les mêmes valeurs.

//Given Array
const arr = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];

   //Dictionary with count of each values in array
const arrCountObj = arr.reduce((acc, el) => {
  if (acc[el]) {
    acc[el] += 1
  } else {
    acc[el] = 1
  }
  return acc
}, {})
console.log(arrCountObj)
   //Looping over sorted dictionary keys to create array based on condition
var out = Object.keys(arrCountObj).sort((a, b) => a - b).map(x => arrCountObj[x] > 1 ? new Array(arrCountObj[x]).fill(+x) : arrCountObj[x])

console.log(out)

Complexité temporelle: O (nlogn)

Vous pouvez trier le tableau et jeter un œil aux deux derniers éléments et à l'élément réel.

var array = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20],
    result = array
        .sort((a, b) => a - b)
        .reduce((r, c, i, { [i - 2]: a, [i - 1]: b }) => {
             if (b !== c) return [...r, c];
             if (a !== c) return r.pop(), [...r, [b, c]];
             r[r.length - 1].push(c);
             return r;
        }, []);

console.log(result);

Ensuite, vérifiez si le dernier élément b et l'élément réel c sont inégaux et renvoient un nouveau tableau avec les anciens éléments et l'élément réel.

Si l'élément précédant le dernier élément a et l'élément réel est différent, il doit s'agir d'un tableau pour le dernier élément du jeu de résultats et l'élément réel. p >

Sinon, placez l'élément réel dans le dernier tableau imbriqué de l'ensemble de résultats.

[   1,   1,   1,   1,   2,   2,   2,   4,   5,  10,  20,  20, 391, 392, 591] array
                   a    b    c                                               variables
                             ^                                               actual item

Vous pouvez:

1) parcourir le tableau et construire une carte de fréquence des nombres

2) saisir et trier la clé de carte de fréquence dans l'ordre croissant

3) construire un nouveau tableau à partir des informations de la carte des fréquences

const arr = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];

const obj = arr.reduce((acc, c) => {
  return acc[c] = (acc[c] || 0) + 1, acc;
}, {});

// {"1":4,"2":3,"4":1,"5":1,"10":1,"20":2,"391":1,"392":1,"591":1}

const keys = Object.keys(obj).sort((a, b) => a - b).map(Number);

// [1,2,4,5,10,20,391,392,591]

const out = keys.map((key) => {
  return obj[key] > 1 ? Array(obj[key]).fill(key) : key;
});

// [[1,1,1,1],[2,2,2],4,5,10,[20,20],391,392,591]

console.log(JSON.stringify(out));