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

Version imprimable

19/03/2021, 13h47
Bensljul

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

Bonjour,

J'ai une interrogation à propos d'une manip que je souhaite faire.

Dans mon code jquery je récupère des infos contenus dans un csv via un appel ajax (ca pas de problème ca marche super bien ^^)

Par contre mon array contient ces infos : ["A,6.3.0","B,3.2.3","F,5.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","A,6.2.0","B,3.2.0","M,5.0.0","C,4.3.0"]

du coup par exemple on voit que j'ai "A,6.3.0" et "A,6.2.0, ma question est : est ce possible de pouvoir faire en sorte de récupérer que le "A,6.3.0" ? Et ainsi de suite pour les autres valeurs ?

je pensais au .map peut être mais j'avoue j'en suis pas sur ...

En vous remerciant d'avance.

Cordialement.

Bonjour,

pas de solution éclair mais tu peux faire ça:

Code:

1
2
3
4
5
const t=["A-6.3.0","F,5.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","A,6.2.0","B,3.2.0","M,5.0.0","C,4.3.0"]
t.sort().reverse();
let tbis="";
t.forEach(v=>{if(!tbis.match(v[0])){tbis+=" "+v}});
console.log(tbis.match(/[^ ]+/g).sort());

22/03/2021, 07h46
Bensljul

AH oui chercher les même valeur en [0] et prendre la version la plus elevée,

Merci je vais essayer ca :)
22/03/2021, 10h35
Bensljul

Mince ça marche plutôt bien excepté quand il y a une valeur qui n'est présente qu'une seule fois XD
22/03/2021, 12h17
javatwister

pas compris!

Et que ce passe-t-il alors? As-tu un exemple de tableau qui ne passe pas avec le script?

Re !!

En fait le souci c'est que j'avais une valeur par exemple "test,1.2.3" qui était toute seule dans mon array et du coup je ne sais pas pourquoi elle était sortie du résultat final.

Du coup je suis parti de ta ligne de code et j'ai créer cette fonction :
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 function lastversion(array){ var lot_array_tmp=[], comp_def =[]; for (var i=0;i<array.length;i++){ var lot=array[i].split(',')[0]; lot_array_tmp.push(lot); } lot_array=unique(lot_array_tmp); for (var i=0; i<lot_array.length;i++){ var lot=lot_array[i], v=[]; for (var j=0;j<array.length;j++){ var y= array[j], x=y.match(lot); if( x != null){ var comp= x.input, ver = comp.split(',')[1]; v.push(ver); } } comp_def.push(lot+","+v.sort().reverse()[0]); } return comp_def }
Et nickel ca marche :)

Merci beaucoup ça m'a bien aidé :)

22/03/2021, 12h57
javatwister

Non, il devait y avait un autre problème (formatage de données...): quand je teste n'importe quelle valeur, unique ou pas, ça marche! inutile de tout compliquer avec un script de 25 lignes;
Si ton tableau est bien fait, il contient en identifiant une lettre majuscule; je me suis fondé sur ça pour le code; mais si tu as des identifiants avec plusieurs lettres, des minuscules, etc, il faut le dire...

Malheureusement ce script ne marche pas comme on le voudrait. La faute à sort() qui par défaut fait un tri alphabétique, car si j'introduis dans la liste G,12.2.0 et G,8.2.0, celui qui sera renvoyé sera G,8.2.0.
Une solution pour parer au problème est d'exploser les chaînes en valeurs atomiques pour les comparer une à une. Voilà comment je procéderais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const appList = [ 'A,6.3.0', 'B,3.2.3', 'F,5.8.0', 'G,12.2.0', 'C,4.3.1',
    'M,5.1.0', 'R,5.4.1', 'F,5.6.0', 'R,5.2.1', 'A,6.2.0', 'B,3.2.0',
    'M,5.0.0', 'C,4.3.0', 'G,8.1.3'];
 
const result = appList.reduce(function (c, i) {
    const [name, ...ver] = i.split(/[,.]/);
    if ( c.has(name) ) {
        const cver = c.get(name);
        if ( (ver[0] - cver[0] || ver[1] - cver[1] || ver[2] - cver[2]) > 0 )
            c.set(name, ver);
 
    } else {
        c.set(name, ver);
    }
    return c;
}, new Map());
 
for (const [name, ver] of result) {
    console.log(`${name},${ver.join('.')}`);
}

Une autre manière de faire qui est peut-être un peu too much pour ce que tu as à faire, mais qui peut s'avérer utile si tu as d'autres manipulations à effectuer avec ces données, c'est de verser dans la poo en désignant chaque chose précisément (je suis parti sur l'hypothèse que chacun des items est un nom de software avec son numéro de version):

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class App {
    constructor(...args) {
        if ( args.length === 2 )
            [this.name, this.version] = args;
        else    
            [this.name, ...this.version] = this._parse(args[0]);
    }
 
    _parse(appStr) {
        return appStr.split(/[,.]/);
    }
 
    toString() {
        return `${this.name},${this.version.join('.')}`;
    }
}   
 
class VersionSet extends Set {
    static compare(a, b) {
        if ( typeof a === 'undefined' )
            return -1;
 
        return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
    }
 
    lastVersion() {
        let lastVersion;
        for (const version of this) {
            if ( VersionSet.compare(lastVersion, version) < 0 )
                lastVersion = version;
        }
        return lastVersion;
    }
}
 
class AppCollection extends Map {
    set(app) {
        if ( !this.has(app.name) )
            super.set(app.name, new VersionSet());
 
        super.get(app.name).add(app.version);
    }
 
    lastVersions() {
        const lastVersions = [];
        for (let [name, versions] of this) {
            lastVersions.push(new App(name, versions.lastVersion()));
        }
        return lastVersions;
    }        
}
 
const appList = [ 'A,6.3.0', 'B,3.2.3', 'F,5.8.0', 'G,12.2.0', 'C,4.3.1',
    'M,5.1.0', 'R,5.4.1', 'F,5.6.0', 'R,5.2.1', 'A,6.2.0', 'B,3.2.0',
    'M,5.0.0', 'C,4.3.0', 'G,8.1.3'];
 
let coll = new AppCollection();
for (const app of appList) {
    coll.set(new App(app));
}
 
console.log(coll.lastVersions().map((app) => `${app}`));

Là, c'est sûr on n'est plus dans les trois lignes, mais ça peut être exploitable pour d'autres choses.

22/03/2021, 21h36
javatwister

Citation:

Envoyé par CosmoKnacki

si j'introduis dans la liste G,12.2.0 et G,8.2.0, celui qui sera renvoyé sera G,8.2.0.

Ah oui, j'avais pas vu le "12" (lu trop vite), j'étais resté sur des valeurs à un chiffre :)
Je reverrai plus tard si j'ai une idée aussi...

À la limite, si par exemple on était sûr que chaque élément du numéro de version était limité à deux chiffres (ou n chiffres définis), on pourrait faire une transformation schwartzienne le temps de traiter les données, pour ensuite les remettre dans leur forme d'origine. Exemple pour deux chiffres:
Code:

1 2 3 4 5 6 7 8 9 10 const appList = [ 'A,6.3.0', 'B,3.2.3', 'F,5.8.0', 'G,12.2.0', 'C,4.3.1', 'M,5.1.0', 'R,5.4.1', 'F,5.6.0', 'R,5.2.1', 'A,6.2.0', 'B,3.2.0', 'M,5.0.0', 'C,4.3.0', 'G,8.1.3']; let result = appList.map((app) => app.replace(/\b(?=\d\b)/g, '0')); // traitement result = result.map((app) => app.replace(/\b0\B/g, ''));

bon sur ce coup-là, pas grand chose de transcendant; et je n'ai pas réfléchi au problème d'une chaîne de numéros plus longue ou aléatoire;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
const t=["A,6.3.0","AA,7.3.0","C,1.2.3","F,5.8.0","G,12.0.0","F,8.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","B,3.2.0","M,5.0.0","C,4.3.0"]
let t2=[],t3=[];
t.map(v=>
	v.split(/[.,]/)).forEach(v=>
		!t2[v[0]] ? t2[v[0]]=[v] : [t2[v[0]].push(v),t2[v[0]].sort((a,b)=>
			b[1]-a[1]||b[2]-a[2]||b[3]-a[3])]
);
 
for(i in t2){
	t3.push(t2[i].slice(0,1).join());
}
console.log(t3)

Bon j'y vais de ma petite proposition:

ça peut aussi se faire avec un custom sort et une multiplication par des puissances de dix selon le niveau
Code:

1 2 3 4 5 6 7 8 9 10 11 12 const t=["A,6.3.0","AA,7.3.0","C,1.2.3","F,5.8.0","G,12.0.0","F,8.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","B,3.2.0","M,5.0.0","C,4.3.0"] function mysort(a,b) { var reg=/[.,]/g; var i=-1; ta=a.split(reg); tb=b.split(reg); return (ta[0]+ta[1]*100+ta[2]*10+ta[3] > tb[0]+tb[1]*100+tb[2]*10+tb[3] )? 1 : -1; } t.sort(mysort); console.log(t)
il ne reste plus qu'a faire un reverse pour récupérer les valeurs voulues

Essai pour des séries de longueur variable, y compris avec un même indicatif alphabétique.
Eh bien je me rends compte que c'est long d'arriver à quelque chose...

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
40
41
42
const 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"],
t2=[],t3=[];
//On crée un tableau des valeurs à partir de chaque élément
t.map(v=>
	v.split(/[.,]/)).forEach(v=>
// puis chaque tableau de valeurs sera ajouté au tableau t2 correspondant au bon indicatif alphabétique
		!t2[v[0]] ? t2[v[0]]=[v] : t2[v[0]].push(v)
);
 
// pour chaque indicatif
for(i in t2){
// on définit la longueur maximale des tableaux de valeurs
	let maxl=0;
	t2[i].forEach(v=>{if(v.length>=maxl) maxl=v.length});
// pour chaque indice du tableau de valeurs
	for(j=1;j<maxl;j++){
// on définit la valeur maximale
		let maxv=0;
		for(let k=0;k<t2[i].length;k++){
			if(t2[i][k][j]){
				if(t2[i][k][j]>=maxv){
					maxv=parseInt(t2[i][k][j],10)
				}
			}
		};
// on élimine alors du tableau indicatif les éléments dont l'indice courant est inférieur à la valeur maximale
		for(let k=0;k<t2[i].length;k++){
			if(t2[i][k][j]){
				if(t2[i][k][j]<maxv){
					t2[i].splice(k,1);k--;
				}
			}
		}
	}
// recherche de l'indice de l'élément ayant la plus grande longueur dans le tableau indicatif 
	let lg=0,ind;
	t2[i].forEach((v,i)=>{if(v.length>=lg){lg=v.length;ind=i}});
// tableau final réunissant la valeur la plus haute de chaque tableau indicatif
	t3.push(`${i},${t2[i][ind].slice(1).join(".")}`)
}
 
console.log(t3.sort())

25/03/2021, 14h48
SpaceFrog

En effet je n'avais pas pensé à une longueur variable...

Il suffirait alors de repérer le plus long d'uniformiser la longueur des arrays issus du split et d'attribuer les puissances de 10 sur la base du plus long ...
25/03/2021, 16h18
javatwister

Pas impossible, mais l'idée est de ne pas trop uniformiser; imagine qu'un ".0" en plus signifie "Missiles armés" ou "Petit Scarabée pas content"... Eh bien la face du monde pourrait changer :P
25/03/2021, 16h38
SpaceFrog

non sans toucher à l'existant ...
donc pas de risque de lancer un missile ni de passr tous les feux au vert ...
je teste ...

Un peu obscur mais ça donne ça

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=ta[0], vb=tb[0];
while (l++<maxl) {
va+=ta[l] * Math.pow(10,l);
vb+=tb[l] * Math.pow(10,l);
}
return (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);

ca qui donne :

Citation:

0: "A,1.2.3.0.0.7"
1: "A,306.0.0"
2: "A,306.0.0.1"
3: "A,45.2.3.4"
4: "ABBA,0.0.7.45.12"
5: "ABBA,86.0.22.1"
6: "ABBA,9.0"

25/03/2021, 18h20
javatwister

3: "A,45.2.3.4" et 6: "ABBA,9.0" = erreurs de tri;

Fallait juste que j'appuie sur le bon bouton pour trouver plus simple :?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const t=["A,1.2.3.0.0.7","A,45.2.3.4","A,306.10.0","A,306.10.0.7","A,306.10.0.7.0","A,306.0.0.0.3.0","ABBA,86.0.22.1","ABBA,86.0.22.1.0","A,306.0.0.1.0","ABBA,9.0","ABBA,0.0.7.45.12"],
t2=[],t3=[];
t.map(v=> v.split(/[.,]/)).forEach(v=> !t2[v[0]] ? t2[v[0]]=[v] : t2[v[0]].push(v));
 
for(j in t2){
	t2[j].sort((a,b)=>{
		let lg=b.length > a.length ? b.length : a.length;
		for(let i=1;i<lg;i++){
			if(a[i]-b[i]!=0){
				return b[i]-a[i] || b.length - a.length
			}
		}
	})
	t3.push(`${j},${t2[j][0].slice(1).join("-")}`)
}
console.log(t3.sort())

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.