Classement des éléments du tableau

J'ai besoin d'un algorithme pour classer les éléments d'un tableau en Javascript.

Exemple : j'ai un tableau comme suit:

[79, 5, 18, 5, 32, 1, 16, 1, 82, 13]

J'ai besoin de classer les entrées en valeur. Donc, 82 devraient recevoir de rang 1, 79 rang 2 etc.
Si les deux entrées ont la même valeur qu'ils reçoivent le même rang et le rang pour une valeur inférieure est soulevée.

Donc, pour ce tableau, le nouveau classement de la matrice serait de:

[2, 7, 4, 7, 3, 9, 5, 9, 1, 6]

Comment puis-je faire cela ?

source d'informationauteur Yùz Nagami | 2013-02-12

25
```
var arr = [79, 5, 18, 5, 32, 1, 16, 1, 82, 13];
var sorted = arr.slice().sort(function(a,b){return b-a})
var ranks = arr.slice().map(function(v){ return sorted.indexOf(v)+1 });
```
Résultat :
```
[2, 7, 4, 7, 3, 9, 5, 9, 1, 6]
```
Si vous souhaitez être compatible avec les anciens navigateurs, vous pouvez avoir à définir une cale pour indexOf et pour carte (notez que si vous voulez le faire très vite pour de très grands tableaux, vous feriez mieux d'utiliser for boucles et l'utilisation d'un objet sous forme de cartes au lieu de indexOf).

Cela ne fonctionne pas avec les anciens navigateurs, car il utilise ECMAScript 5 caractéristiquesmais il vous permet de rapidement et de manière succincte, de produire un tableau de classement, même pour de très grands réseaux. (Il n'utilise pas indexOf qui fait une recherche linéaire et peut donc être lent pour de grands tableaux.)

function cmp_rnum(a,b) {
    //comparison function: reverse numeric order
    return b-a;
}
function index_map(acc, item, index) {
    //reduction function to produce a map of array items to their index
    acc[item] = index;
    return acc;
}
function ranks(v) {
    var rankindex = v.slice().sort(cmp_rnum).reduceLeft(index_map, Object.create(null));
    //reduceLeft() is used so the lowest rank wins if there are duplicates
    //use reduce() if you want the highest rank
    return v.map(function(item){ return rankindex[item]+1; });
}

Exemple de sortie:

> ranks([79, 5, 18, 5, 32, 1, 16, 1, 82, 13]);
  [2, 7, 4, 7, 3, 9, 5, 9, 1, 6]

function rank(arr, f) {
    return arr
    .map((x, i) => [x, i])
    .sort((a, b) => f(a[0], b[0]))
    .reduce((a, x, i, s) => (a[x[1]] =
        i > 0 && f(s[i - 1][0], x[0]) === 0 ? a[s[i - 1][1]] : i + 1, a), []);
}

Utilisation:

rank([79, 5, 18, 5, 32, 1, 16, 1, 82, 13], (a, b) => b - a);
//[2, 7, 4, 7, 3, 9, 5, 9, 1, 6]

Ressemble un peu moche, mais il n'utilise pas indexOf() ou un objet/de la carte, de sorte que non seulement il tourne un peu plus vite, mais plus important encore, il respecte le sens de "même rankedness" tel que défini par la fonction de comparaison. Si l'on utilise indexOf() ou un objet, "même rankedness" ne peut signifier a === b ou String(a) === String(b).

Vous pouvez également utiliser findIndex():

function rank(arr, f) {
    const sorted = arr.slice().sort(f)
    return arr.map(x => sorted.findIndex(s => f(x, s) === 0) + 1)
}

J'avais besoin de le même bout de code pour des opérations de planification script que j'écrivais. J'ai utilisé des objets et de leurs propriétés ou des clés, ce qui peut avoir n'importe quelle valeur et peut être consulté chaque fois que nécessaire. Aussi, autant que j'ai lu dans certains articles, la recherche de propriétés dans les objets peuvent être plus rapides que la recherche dans des tableaux.

Le script ci-dessous a trois étapes simples:

trier les valeurs (ascendant ou descendant n'a pas d'importance pour le reste du script)
trouver le rang et le nombre d'occurrences de chaque valeur
remplacer les valeurs données avec des rangs en utilisant les données à partir de l'étape 2

Remarque! Le script ci-dessous ne seront pas de sortie en double rangs, mais plutôt par incréments de rangs pour les valeurs en double/éléments.

function rankArrayElements( toBeRanked ) {
//STEP 1
var toBeRankedSorted = toBeRanked.slice().sort( function( a,b ) { return b-a; } ); //sort descending
//var toBeRankedSorted = toBeRanked.slice().sort( function( a,b ) { return a-b; } ); //sort ascending
var ranks = {}; //each value from the input array will become a key here and have a rank assigned
var ranksCount = {}; //each value from the input array will become a key here and will count number of same elements
//STEP 2
for (var i = 0; i < toBeRankedSorted.length; i++) { //here we populate ranks and ranksCount
var currentValue = toBeRankedSorted[ i ].toString();
if ( toBeRankedSorted[ i ] != toBeRankedSorted[ i-1 ] ) ranks[ currentValue ] = i; //if the current value is the same as the previous one, then do not overwrite the rank that was originally assigned (in this way each unique value will have the lowest rank)
if ( ranksCount[ currentValue ] == undefined ) ranksCount[ currentValue ] = 1; //if this is the first time we iterate this value, then set count to 1
else ranksCount[ currentValue ]++; //else increment by one
}
var ranked = [];
//STEP 3
for (var i = toBeRanked.length - 1; i >= 0; i--) { //we need to iterate backwards because ranksCount starts with maximum values and decreases
var currentValue = toBeRanked[i].toString();
ranksCount[ currentValue ]--;
if ( ranksCount[ currentValue ] < 0 ) { //a check just in case but in theory it should never fail
console.error( "Negative rank count has been found which means something went wrong :(" );
return false;
}
ranked[ i ] = ranks[ currentValue ]; //start with the lowest rank for that value...
ranked[ i ] += ranksCount[ currentValue ]; //...and then add the remaining number of duplicate values
}
return ranked;}

J'ai aussi besoin de faire autre chose pour mon script.

Au-dessus de la sortie a la signification suivante:

index - l'ID de l'élément dans le tableau d'entrée
valeur - le rang de l'élément du tableau input

Et j'ai besoin d'fondamentalement d'échange de l'indice par la valeur", de sorte que j'ai une liste d'élément Id d', disposées dans l'ordre de leur rang:

function convertRanksToListOfElementIDs( ranked ) {  //elements with lower ranks will be first in the list
var list = [];
for (var rank = 0; rank < ranked.length; rank++) { //for each rank...
var rankFound = false;
for (var elementID = 0; elementID < ranked.length; elementID++) { //...iterate the array...
if ( ranked[ elementID ] == rank ) { //...and find the rank
if ( rankFound ) console.error( "Duplicate ranks found, rank = " + rank + ", elementID = " + elementID );
list[ rank ] = elementID;
rankFound = true;
}
}
if ( !rankFound ) console.error( "No rank found in ranked, rank = " + rank );
}
return list;}

Et quelques exemples:

ToBeRanked:

[36, 33, 6, 26, 6, 9, 27, 26, 19, 9]

[12, 12, 19, 22, 13, 13, 7, 6, 13, 5]

[30, 23, 10, 26, 18, 17, 20, 23, 18, 10]

[7, 7, 7, 7, 7, 7, 7, 7, 7, 7]

[7, 7, 7, 7, 7, 2, 2, 2, 2, 2]

[2, 2, 2, 2, 2, 7, 7, 7, 7, 7]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

rankArrayElements( ToBeRanked ):

[0, 1, 8, 3, 9, 6, 2, 4, 5, 7]

[5, 6, 1, 0, 2, 3, 7, 8, 4, 9]

[0, 2, 8, 1, 5, 7, 4, 3, 6, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[5, 6, 7, 8, 9, 0, 1, 2, 3, 4]

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

convertRanksToListOfElementIDs( rankArrayElements( ToBeRanked ) ):

[0, 1, 6, 3, 7, 8, 5, 9, 2, 4]

[3, 2, 4, 5, 8, 0, 1, 6, 7, 9]

[0, 3, 1, 7, 6, 4, 8, 5, 2, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[5, 6, 7, 8, 9, 0, 1, 2, 3, 4]

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

-2

Je ne suis pas bon en Javascript, mais en PHP, il peut être fait très facilement la façon suivante. Quelqu'un de bon en JavaScript peut venir avec le code pertinent.

$marks = [79, 5, 18, 5, 32, 1, 16, 1, 82, 13];
public function getRank($marks) {
$rank = 1; $count = 0; $ranks = [];
//sort the marks in the descending order
arsort($marks,1);
foreach($marks as $mark) {
//check if this mark is already ranked
if(array_key_exists($mark, $ranks)) {
//increase the count to keep how many times each value is repeated
$count++;
//no need to give rank - as it is already given
} else {
$ranks[$mark] = $i+$j;
$i++;
}
return $ranks;
}

Vous devez vous connecter pour publier un commentaire.