Ranking methods: Difference between revisions

The numerical rank of competitors in a competition shows if one is better than, equal to, or worse than another based on their results in a competition.

 

Show here, on this page, the ranking of the test scores under each of the numbered ranking methods.

<br><br>

 

=={{header|AutoHotkey}}==

for index, val in StrSplit(data, "`n", "`r") {

RegExMatch(val, "^(\d+)\s+(.*)", Match)

}

return Res%opt%

(

44 Solomon

. "`nOrdinal Ranking:`n" Rank(data, 4)

. "`nFractional Ranking:`n" Rank(data, 5)

Output:<pre>Standard Ranking:

1 44 Solomon

5 41 Barry

7 39 Stephen</pre>

 

=={{header|AWK}}==

{{trans|Python}}

This uses separate files for each method of ranking:

## Dense ranking in file: ranking_d.awk

##

}

//{sc_rank()}

 

The input as a file <code>ranking.txt</code>:

 

C:\Users\RC\Code></pre>

 

=={{header|C}}==

Takes the scores as input via a file, prints out usage on incorrect invocation.

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Input file, first row is number of records :

<pre>

7.0 39 Stephen

</pre>

{{trans|D}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>Standard Rank

5.0 41 Barry

7.0 39 Stephen</pre>

 

=={{header|D}}==

import std.stdio;

 

 

writeln;

 

{{out}}

=={{header|Elixir}}==

{{trans|Ruby}}

def methods(data) do

IO.puts "stand.\tmod.\tdense\tord.\tfract."

|> Enum.chunk(2)

|> Enum.map(fn [score,name] -> {String.to_integer(score),name} end)

 

{{out}}

7 7 4 7 7 39 Stephen

</pre>

 

=={{header|Go}}==

 

import (

show("\nOrdinal", OrdinalRank)

show("\nFractional", FractionalRank)

{{out}}

<pre>

 

=={{header|Haskell}}==

 

 

-- make sure the input is ordered and grouped by score

prepare :: ItemList -> ItemGroups

 

-- give an item a rank

rank n (a, b) = (n, a, b)

 

-- ranking methods

standard, modified, dense, ordinal :: ItemGroups -> RankItemList Int

ms _ [] = []

 

md _ [] = []

 

md _ [] = []

md n (x:xs) = map (rank n) x ++ md (n + 1) xs

 

 

fractional :: ItemGroups -> RankItemList Double

mf _ [] = []

 

-- sample data

test :: ItemGroups

[ (44, "Solomon")

, (42, "Jason")

, (41, "Bernard")

, (41, "Barry")

 

-- print rank items nicely

nicePrint xs items = do

 

main :: IO ()

main = do

1 44 Solomon

2 42 Jason

5.0 41 Bernard

5.0 41 Barry

 

=={{header|J}}==

Implementation:

 

44 Solomon

42 Jason

fractional=: #/.~ # ] (+/%#)/. #\

 

 

Note that we assume that the competitors are already in the right order. Also, of course (as is common when using J) we use the J command line, because that is portable across operating systems (for example: the OS command line is difficult to use on phones).

Task examples:

 

┌─┬──┬───────┐

│1│44│Solomon│

├───┼──┼───────┤

│7 │39│Stephen│

 

=={{header|Java}}==

{{works with|Java|8}}

 

public class RankingMethods {

}

}

 

<pre>Standard ranking

5,0 41 Barry

7,0 39 Stephen</pre>

 

=={{header|JavaScript}}==

( This version chooses to use a secondary (alphabetic) sort after the numeric sort by score. That does, of course, affect the ordinal placements for some players)

 

var xs = 'Solomon Jason Errol Garry Bernard Barry Stephen'.split(' '),

return wikiTable(tbl, true, 'text-align:center');

 

{{out}}

===ES6===

 

const xs = 'Solomon Jason Errol Garry Bernard Barry Stephen'.split(' '),

ns = [44, 42, 42, 41, 41, 41, 39];

 

return wikiTable(tbl, true, 'text-align:center');

 

{| class="wikitable" style="text-align:center"

 

For the sake of brevity, only the ranks are printed.

# Ties share what would have been their first ordinal number

def standard_ranking:

else [ resolve, [ $i + 1 ] ]

end )

[

"Solomon", 44,

task

{{Out}}

standard: [1,2,2,4,4,4,7]

=={{header|Julia}}==

'''ties''', a helper function used by some of the ranking methods. It lists any duplicated scores.

function ties{T<:Real}(a::Array{T,1})

unique(a[2:end][a[2:end] .== a[1:end-1]])

end

<code>ties</code> assumes that the there are at least 2 scores in the list to be checked, and the calling functions are designed to avoid calls to it in this case.

 

'''Standard Ranking Function'''

function rankstandard{T<:Real}(a::Array{T,1})

r = collect(1:length(a))

return r

end

 

'''Modified Ranking Function'''

function rankmodified{T<:Real}(a::Array{T,1})

indexin(a, a)

end

 

'''Dense Ranking Function'''

function rankdense{T<:Real}(a::Array{T,1})

indexin(a, unique(a))

end

 

'''Ordinal Ranking Function'''

function rankordinal{T<:Real}(a::Array{T,1})

collect(1:length(a))

end

For ordinal ranking, there are a variety of ways of handling tied scores. I've taken the easy way out and assumed that the position in the list already reflects any tie-breaking policy. In this case, there is not much that needs to be done.

 

'''Fractional Ranking Function'''

function rankfractional{T<:Real}(a::Array{T,1})

r = float64(collect(1:length(a)))

return r

end

 

'''Main'''

scores = [44, 42, 42, 41, 41, 41, 39]

names = ["Solomon", "Jason", "Errol", "Garry",

println()

end

 

{{out}}

 

=={{header|Kotlin}}==

 

/* all ranking functions assume the array of Pairs is non-empty and already sorted by decreasing order of scores

printRankings("Ordinal ranking", ordinalRanking(scores), scores)

printFractionalRankings("Fractional ranking", fractionalRanking(scores), scores)

 

{{out}}

</pre>

 

"Errol", "Garry", "Bernard", "Barry", "Stephen"}};

 

 

Grid@{fmtRankedData[data, #] & /@ {"standard", "modified", "dense",

{{out}}

1 44 Solomon

3 42 Errol

5 41 Bernard

5 41 Garry

 

=={{header|PARI/GP}}==

 

Replace "2" with "2.0" in <code>fractional</code> if you prefer decimal to fractional.

modified(v)=v=vecsort(v,1,4); my(last=v[#v][1]-1); forstep(i=#v,1,-1, v[i][1]=if(v[i][1]>last,last=v[i][1]; i, v[i+1][1])); v;

dense(v)=v=vecsort(v,1,4); my(last=v[1][1]+1,rank); for(i=1,#v, v[i][1]=if(v[i][1]<last,last=v[i][1]; rank++, rank)); v;

dense(v)

ordinal(v)

{{out}}

<pre>%1 = [[1, "Solomon"], [2, "Errol"], [2, "Jason"], [4, "Barry"], [4, "Bernard"], [4, "Garry"], [7, "Stephen"]]

%5 = [[1, "Solomon"], [5/2, "Jason"], [5/2, "Errol"], [5, "Garry"], [5, "Bernard"], [5, "Barry"], [7, "Stephen"]]</pre>

 

 

 

my $rank = 1;

}

}

 

my $rank = 0;

}

}

 

 

 

my $rank = 1;

}

}

 

{{out}}

 

Modified:

 

Dense:

 

Ordinal:

 

Fractional:

 

=={{header|PowerShell}}==

function Get-Ranking

{

}

}

$scores = "44 Solomon","42 Jason","42 Errol","41 Garry","41 Bernard","41 Barry","39 Stephen"

$scores | Get-Ranking -Standard

{{Out}}

<pre>

Stephen 39 7

</pre>

$scores | Get-Ranking -Modified

{{Out}}

<pre>

Stephen 39 7

</pre>

$scores | Get-Ranking -Dense

{{Out}}

<pre>

Stephen 39 4

</pre>

$scores | Get-Ranking -Ordinal

{{Out}}

<pre>

Stephen 39 7

</pre>

$scores | Get-Ranking -Fractional

{{Out}}

<pre>

Stephen 39 7

</pre>

 

=={{header|Python}}==

"""Modified competition ranking"""

lastresult, fifo = None, []

print('\n%s:' % ranker.__doc__)

for rank, score in ranker(scores):

 

{{out}}

 

=={{header|Racket}}==

;; Tim-brown 2014-09-11

 

(caddr r)

(cdddr r)))

 

{{out}}

= 5 41 Barry

7 39 Stephen</pre>

 

=={{header|REXX}}==

44 Solomon 1 1 1 1 1

42 Jason 2 3 2 2 2.5

cp=p

End

{{out}}

<pre>44 Solomon 1 1 1 1 1

 

=={{header|Ruby}}==

42 Jason

42 Errol

end

s_rnk += names.size

{{out}}

<pre>

=={{header|Scala}}==

This example uses a type-safe singly-linked object model with no mutable state variables, which makes it longer than the Ruby version above, but demonstrates an object-oriented functional programming approach.

case class Score(score: Int, name: String) // incoming data

case class Rank[Precision](rank: Precision, names: List[String]) // outgoing results (can be int or double)

println(rankFractional(test) mkString "\n")

 

{{out}}

<pre>Standard:

 

=={{header|Sidef}}==

Pair(Solomon => 44),

Pair(Jason => 42),

say "\nDense:"; display( dense(scores))

say "\nOrdinal:"; display( ordinal(scores))

{{out}}

<pre>

 

=={{header|Tcl}}==

# Extract the groups in the data (this is pointless for ordinal...)

set s [set group [set groups {}]]

puts " $rank\t$score\t$who"

}

{{out}}

<pre>

7 39 Stephen

</pre>

 

=={{header|Visual FoxPro}}==

#DEFINE CTAB CHR(9)

#DEFINE CRLF CHR(13) + CHR(10)

ENDFOR

ENDPROC

{{out}}

<pre>

7 7 4 7 7.0 39 "Stephen"

</pre>

 

=={{header|zkl}}==

sink:=List();

scores.reduce('wrap(ps,sn,buf){

print(group,"%5.2f".fmt(r));

}

scores:=T(T(44,"Solomon"), T(42,"Jason"), T(42,"Errol"), T(41,"Garry"),

T(41,"Bernard"),T(41,"Barry"),T(39,"Stephen"),);

"Dense:" .println(); rankViaDense(scores);

"Ordinal:" .println(); rankViaOrdinal(scores);

{{out}}

<pre>