Ranking methods: Difference between revisions

<br><br>

 

 

 

script standardRanking

-- Properties and handlers inherited or overridden by the other script objects.

property results : missing value

property startIndex : 1

property step : 1

property currentRank : missing value

on resultsFrom(theScores)

copy theScores to my results

tell sorter to sort(my results, my startIndex, my endIndex, {comparer:me})

set my currentRank to my startIndex's contents

repeat with i from (my startIndex) to (my endIndex) by (my step)

my rankResult(i)

end repeat

set my results to missing value

end resultsFrom

on isGreater(a, b)

end isGreater

on rankResult(i)

set thisScore to thisResult's score

if (thisScore is not currentScore) then

set my currentScore to thisScore

end if

end rankResult

end script

 

property parent : standardRanking

property endIndex : 1

property step : -1

on rankResult(i)

set thisScore to thisResult's score

if (thisScore is not my currentScore) then

set my currentScore to thisScore

end if

end rankResult

end script

on rankResult(i)

end rankResult

end script

on rankResult(i)

set thisScore to thisResult's score

if (thisScore is not my currentScore) then

-- The average of any run of consecutive integers is that of the first and last.

set average to (i - 1 + (my currentRank)) / 2

repeat with j from (my currentRank) to (i - 1)

end repeat

set my currentRank to i

set my currentScore to thisScore

end if

end rankResult

end script

set rankings to {type}

repeat with thisResult in theResults

end repeat

end formatRankings

 

set astid to AppleScript's text item delimiters

set AppleScript's text item delimiters to astid

 

local theScores, output

 

{{output}}

1 Solomon (44)

2 Errol (42)

5.0 Bernard (41)

5.0 Garry (41)

 

=={{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

matrix, with the ranking added.

 

modified ← ∊∘(⌈\∘⌽¨⊢⊂⍳∘≢)∘(1,2≠/⊢)∘(1⌷[2]⊢),⊢

dense ← (+\1,2≠/1⌷[2]⊢),⊢

ordinal ← ⍳∘≢,⊢

 

{{out}}

{{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>:

 

=={{header|BASIC}}==

20 DIM S(N),N$(N),R(N)

30 FOR I=1 TO N: READ S(I),N$(I): NEXT

550 DATA 41,Bernard

560 DATA 41,Barry

 

{{out}}

=={{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>

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>Standard Rank

=={{header|C++}}==

{{trans|C#}}

#include <iomanip>

#include <iostream>

 

return 0;

{{out}}

<pre>Standard Rank

 

=={{header|Cowgol}}==

 

# List of competitors

print_nl();

n := n + 1;

 

{{out}}

 

=={{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}}

=={{header|Factor}}==

{{works with|Factor|0.99 2019-07-10}}

math math.ranges math.statistics math.vectors sequences

splitting.monotonic ;

[ [ print ] [ .rank nl ] bi* ] 2 5 mnapply ;

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

Data 44,"Solomon", 42,"Jason", 42,"Errol", 41,"Garry"

Data 41,"Bernard", 41,"Barry", 39,"Stephen"

MostarTabla

Sleep

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

show("\nOrdinal", OrdinalRank)

show("\nFractional", FractionalRank)

{{out}}

<pre>

 

=={{header|Haskell}}==

 

type Item = (Int, String)

nicePrint "Dense:" $ dense test

nicePrint "Ordinal:" $ ordinal test

{{Out}}

<pre>Standard:

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

( 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|Modula-2}}==

{{trans|C}}

FROM FormatString IMPORT FormatString;

FROM RealStr IMPORT RealToFixed;

 

ReadChar

{{out}}

<pre>Ordinal Ranking

===Using an auxiliary table===

To simplify, it’s convenient to build a table giving for each score the list of competitor names.

 

type

echo "Fractional ranking:"

for (rank, name, score) in groups.fractionalRanks():

 

{{out}}

===Without an auxiliary table===

But it is possible to do the ranking without an auxiliary table.

 

type

echo "Fractional ranking:"

for (rank, name, score) in Data.fractionalRanks():

 

{{out}}

 

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"]]

=={{header|Perl}}==

{{trans|Raku}}

'Solomon' => 44,

'Jason' => 42,

print "Dense:\n" . dense(%scores) . "\n";

print "Ordinal:\n" . ordinal(%scores) . "\n";

{{out}}

<pre style="height:35ex">Standard:

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{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>

 

=={{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}}

=={{header|Raku}}==

(formerly Perl 6)

Solomon => 44,

Jason => 42,

say "\nDense:"; .perl.say for dense @scores;

say "\nOrdinal:"; .perl.say for ordinal @scores;

{{out}}

<pre>Standard:

 

=={{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}}==

{{trans|Raku}}

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>

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

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

printRankings.call("Dense ranking", denseRanking.call(scores), scores)

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

 

{{out}}

7.00 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>