Récupérer les valeurs les plus élevées dans un array

Version imprimable

Voir 40 message(s) de cette discussion en une page

Ha oui je vois le souci, c'est le tri alpha et comme c'est un mixte ça va être tricky a résoudre ...

J'y suis presque...
j'ai juste un petit souci avec le dernier élément :(

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var reg=/[.,]/g;
 
function mysort(a,b) {
ta=a.split(reg);
tal=ta.length;
while(tal++<maxl){
ta.push("0");
}
tb=b.split(reg);
tbl=tb.length;
while(tbl++<maxl){
tb.push("0");
}
l=0,va=0, vb=0;
while (l++<maxl) {
va+= +ta[l] * Math.pow(10,l);
vb+= +tb[l] * Math.pow(10,l);
}
return (ta[0] > tb[0] && va > vb)? -1: 1 ;
}
 
var i=-1, maxl=0;
t=["A,1.2.3.0.0.7","A,45.2.3.4","A,306.0.0","A,306.0.0.1","ABBA,86.0.22.1","ABBA,9.0","ABBA,0.0.7.45.12"];
//determination de la longueur max
while(t[++i]){
l=t[i].match(reg).length;
maxl= (maxl<l)?l:maxl;
}
 
t.sort(mysort);
console.log(t);

26/03/2021, 08h30
javatwister

J'ai l'impression que ton tableau n'est pas trié (?)

j'avais en fait le même souci de longueur uniforme sur le premier élement des arrays...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
var reg=/[.,]/g;
 
function mysort(a,b) {
ta=a.split(reg);
tal=ta.length;
while(tal++ <maxl){
ta.push(0);
}
tb=b.split(reg);
tbl=tb.length;
while(tbl++ <maxl){
tb.push(0);
}
 
l=maxl,va=0, vb=0;
while (l-- >1) {
while(ta[0].length<max0){ta[0]+=' '}
while(tb[0].length<max0){tb[0]+=' '}
 
va += 1*ta[l] * Math.pow(10,maxl-l);
vb += 1*tb[l] * Math.pow(10,maxl-l);
}
 
return ((ta[0] + va > tb[0] + vb) )? 1: -1 ;
}
 
var i=-1, maxl=0, max0=0;
t=["A,1.2.3.0.0.7","A,45.2.3.4","A,306.0.0","A,306.0.0.1","ABBA,86.0.22.1","ABBA,9.0","ABBA,0.0.7.45.12"];
//determination de la longueur max
while(t[++i]){
tp=t[i].match(reg);
l=tp.length
l0=tp[0].length
maxl= (maxl<l)?l:maxl;
max0=(l0>max0)?l0:max0;
}
 
t.sort(mysort);
console.log(t);

C'est ce que tu veux ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  'A.6.2.0',
  'A.6.3.0',
  'B.3.2.0',
  'C.4.3.0',
  'C.4.3.1',
  'F.5.6.0',
  'F.5.8.0',
  'G.12.2.0',
  'M.5.0.0',
  'M.5.1.0',
  'R.5.2.1',
  'R.5.4.1'
]

Alors, cela marche :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function sort(array) {
  return [...array]
    .map((str) => str.match(/[\dA-Z]+/g))
    .map((arr) => arr.map((val) => isNaN(Number(val)) ? val : Number(val)))
    .sort((ARR, arr) => {
      for (let i = 0; i < ARR.length; i++) {
        const [A, a] = [ARR[i], arr[i]];
        if (A > a) { return 1 };
        if (A < a) { return -1 };
      }
      return 0;
    })
    .map((arr) => arr.join('.'));
}

Moins obscur que les autres 8-)

03/04/2021, 07h49
javatwister

Mais ça faussera les résultats avec des chaînes de longueurs différentes...

Ah, t'a raison, mais pour quoi mon code ne marche pas pour cette liste ?

Code:

1
2
3
4
5
[
  'ABBA,81',
  'ABBA,9',
  'ABBA,0'
]

Résultat :

Code:

[ 'ABBA.0', 'ABBA.9', 'ABBA.81' ]

Je ne comprends pas :weird:

EDIT Je suis stupide :mouarf: 9 < 81, oui ça marche !

______

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const array = ["A,1.2.3.0.0.7", "A,45.2.3.4", "A,306.0.0", "A,306.0.0.1", "ABBA,86.0.22.1", "ABBA,9.0", "ABBA,0.0.7.45.12"];
 
function sort(array) {
  return [...array]
    .map((str) => str.match(/[\dA-Z]+/g))
    .map((arr) => arr.map((val) => isNaN(Number(val)) ? val : Number(val)))
    .sort((ARR, arr) => {
      for (let i = 0; i < Math.max(ARR.length, arr.length); i++) {
        const [A, a] = [ARR[i], arr[i]].map((val) => val === undefined ? 0 : val);
        if (A > a) { return 1 };
        if (A < a) { return -1 };
      }
      return 0;
    })
    .map((arr) => arr.join('.'));
}
 
console.log(sort(array));
// Résultat :
[
  'A.1.2.3.0.0.7',
  'A.45.2.3.4',
  'A.306.0.0',
  'A.306.0.0.1',
  'ABBA.0.0.7.45.12',
  'ABBA.9.0',
  'ABBA.86.0.22.1'
];

Ça marche, non ?

03/04/2021, 23h10
CosmoKnacki

Trier le tableau est inutile. La question est de récupérer l'item avec le numéro de version le plus élevé pour chaque préfixe du tableau de départ.

Voir 40 message(s) de cette discussion en une page