Programmieren lernen

package scores;

import java.util.Arrays;

public class Scores {
	
	public static void main( String[] args ){
		
		int[] scores1 = { 3, 3, 3, 3, 3, 5, 1 };
		int[] scores2 = { 9, 3, 6, 19 };
		
		int[] ranks1 = get_ranks(scores1);
		int[] ranks2 = get_ranks(scores2);
		
		String s1 = Arrays.toString(scores1);
		String s2 = Arrays.toString(scores2);
		
		String r1 = Arrays.toString(ranks1);
		String r2 = Arrays.toString(ranks2);
		
		System.out.println( s1 + " ---> " + r1 );
		System.out.println( s2 + " ---> " + r2 );
		
	}
	
	private static int[] get_ranks( int[] scores ){
		
		final class ScoreAndIndex implements Comparable<ScoreAndIndex>{
			
			public int score;
			public int index;

			@Override
			public int compareTo(ScoreAndIndex s) {
				
				return s.score - this.score;
				
			}
		}
		
		ScoreAndIndex[] scores_and_indexes = new ScoreAndIndex[ scores.length ];
		int[] ranks = new int[ scores.length ];
		
		for( int i = 0; i <= scores.length - 1; ++i ){
			
			scores_and_indexes[i] = new ScoreAndIndex();
			scores_and_indexes[i].score = scores[i];
			scores_and_indexes[i].index = i;
		
		}
		
		Arrays.sort( scores_and_indexes );
		
		int prev_score = Integer.MIN_VALUE;
		int curr_score;
		int rank = 0;
		for( ScoreAndIndex s: scores_and_indexes ){
			
			curr_score = s.score;
			if( curr_score != prev_score ){
				++rank;
			}
			
			ranks[ s.index ] = rank;
			prev_score = curr_score; 
		}
		
		return ranks;
		
	}
	
}
                

Lösung von: reeman :3 (TU Ilmenau)

print join($",makeRank(9,3,6,19)).$/;
#ergibt 2 4 3 1
print join($",makeRank(3,3,3,3,3,5,1)).$/;
#ergibt 2 2 2 2 2 1 3 

sub makeRank {
my %hash;
my @rank = sort {$a<=>$b} grep {!$hash{$_}++} @_;
my @result = @_;
for my $i (0..$#rank){
    for my $x (0..$#result)
    {$result[$x] = $#rank-$i if($rank[$i]==$result[$x]);}
}
return map{++$_} @result;
}
                

Lösung von: Paul Scheinast (http://scheinast.eu)

var anArray = [9, 3, 6, 19],
    anotherArray = [3, 3, 3, 3, 3, 5, 1];
    
function rank(arr) {
   var sortArr = [].concat(arr).sort(function(a, b) { return b - a }),
       rankArr = new Array(arr.length),
       rnk = 1,
       current, i;
   while (sortArr.length > 0) {
      current = sortArr.shift();
      for (i = 0; i < arr.length; i++)
         if (arr[i] == current) rankArr[i] = rnk;
      if (current != sortArr[0]) rnk++;      
   }   
   return rankArr;
}

console.log(rank(anArray).join(", "));
console.log(rank(anotherArray).join(", "));   

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

# coding: utf-8
def computeScores(scores):
    # Ranking feststellen & Dictionary aufbauen
    work = scores[:]            # Arbeitsbereich
    work.sort()
    work.reverse()              # absteigend
    scoredict = {}
    rank = 1
    last = ""
    for i in work:
        if i != last:           # Dubletten nicht hochzählen
            scoredict[i] = rank
            rank = rank + 1
        last = i

    # Ranking der orig. Reihenfolge erzeugen
    result = []
    posn = 0
    for i in scores:
        result.append(scoredict[i])
        posn = posn + 1
    print "\nRanking der Zahlen ", scores, " ist: ", result
    return()
    
computeScores([9,3,6,19])
computeScores([3,3,3,3,3,5,1])
                

Lösung von: J. Reppe ()

let scores = [3;3;3;3;3;5;1] //[9; 3; 6; 19]

let rank n =
    let rec rank' r s =
        match s with 
        | [] -> r
        | x::xs -> rank' (if n < x then r + 1 else r) xs
    rank' 1 scores

let ranking =
    scores
    |> List.rev
    |> List.fold (fun acc x -> (rank x)::acc) []
    |> printfn "%A"
                

Lösung von: Vural Acar ()

REPORT  zranking.

PARAMETERS: pa_1 TYPE string.

DATA: lt_score TYPE STANDARD TABLE OF string,
      ls_score LIKE LINE OF lt_score,
      lt_sortiert TYPE STANDARD TABLE OF i,
      ls_sortiert LIKE LINE OF lt_sortiert,
      lt_hilfsliste TYPE STANDARD TABLE OF i,
      ls_hilfsliste LIKE LINE OF lt_hilfsliste,
      lt_ranking TYPE STANDARD TABLE OF i,
      ls_ranking LIKE LINE OF lt_ranking,
      lv_index TYPE i,
      lv_index2 TYPE i,
      lv_ausgabe TYPE string,
      lv_string TYPE string,
      lv_sortiert_alt TYPE i.

SPLIT pa_1 AT ',' INTO TABLE lt_score. " Eingabe wird gesplittet

lt_sortiert[] = lt_score[].
lt_hilfsliste[] = lt_score[].
lt_ranking[] = lt_score[].

SORT lt_sortiert DESCENDING. " Score wird sortiert.

" Löschen von Doppelten Werten
LOOP AT lt_sortiert INTO ls_sortiert.
  IF ls_sortiert EQ lv_sortiert_alt.
    DELETE lt_sortiert INDEX sy-tabix.
  ENDIF.
  lv_sortiert_alt = ls_sortiert.
ENDLOOP.

" Ermittlung des Rankings
LOOP AT lt_sortiert INTO ls_sortiert.
  lv_index = sy-tabix.
  LOOP AT lt_ranking INTO ls_ranking.
    IF ls_ranking EQ ls_sortiert.
      lv_index2 = sy-tabix.
      ls_hilfsliste = lv_index.
      MODIFY lt_hilfsliste INDEX lv_index2 FROM ls_hilfsliste.
    ENDIF.
  ENDLOOP.
ENDLOOP.

" Für gewünschte Ausgabe wird die Tabelle in einen String umgewandelt.
LOOP AT lt_hilfsliste INTO ls_hilfsliste.
  lv_string = ls_hilfsliste.
  CONCATENATE lv_ausgabe lv_string INTO lv_ausgabe SEPARATED BY ','.
ENDLOOP.
SHIFT lv_ausgabe BY 1 PLACES LEFT. " Löschen des ersten Kommas.

WRITE: / 'Liste: ',
         pa_1.

WRITE: / 'Ranking: ' NO-GAP,
         lv_ausgabe.
                

Lösung von: Alexander S. (msg systems)

// NET Core 3.x

using System;
using System.Collections.Generic;
using System.Linq;

namespace CS_MDL_CORE_Ranking
{
    class Program
    {
        static void Main(string[] args)
        {
            var l = new List<int>() { 3, 3, 3, 3, 3, 5, 1 };
            PrintList(l);
            PrintRanking(l);
            Console.WriteLine();
            PrintRankingTuple(l);
            Console.WriteLine();
            PrintRankingList(l);
            Console.WriteLine();
            PrintRankingOrderedList(l);
        }
        static void PrintList(IEnumerable<int> l) => Console.Write($"[{ string.Join(", ", l) }] -> ");

        static void PrintRanking(IEnumerable<int> l) => Console.WriteLine($"[{ string.Join(", ", l.Select(x => new { r = l.OrderBy(x => -x).ToList().IndexOf(x) + 1 }).Select(x => x.r))}]");

        static void PrintRankingTuple(IEnumerable<int> l) => l.Select(x => new { n = x, r = l.OrderBy(x => -x).ToList().IndexOf(x) + 1 }).Select(x => (x.n, x.r)).ToList().ForEach(x => Console.WriteLine(x));

        static void PrintRankingList(IEnumerable<int> l) => l.Select(x => new { num = x, rank = l.OrderBy(x => -x).ToList().IndexOf(x) + 1 }).ToList().ForEach(x => Console.WriteLine(x));

        static void PrintRankingOrderedList(IEnumerable<int> l) => l.Select(x => new { num = x, rank = l.OrderBy(x => -x).ToList().IndexOf(x) + 1 }).ToList().OrderBy(x => x.rank).ToList().ForEach(x => Console.WriteLine(x));
    }
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <vector>
#include <algorithm>

std::vector<int> get_ranking(const std::vector<int>& in_) {
    std::vector<int> srt_{ in_ }, rnk_{}, out_{};
    std::sort(srt_.rbegin(), srt_.rend());
    srt_.push_back(INT_MIN);
    auto cnt{ 1 };

    for (size_t i{ 1 }; i < srt_.size(); i++)
        rnk_.push_back(srt_[i] < srt_[i - 1] ? cnt++ : cnt);

    for (const auto& i : in_) {
        const auto it{ std::find(srt_.begin(), srt_.end() - 1, i) };
        out_.push_back(rnk_[it - srt_.begin()]);
    }
    return out_;
}

void print(const std::vector<int>& v) {
    for (auto it{ v.begin() }; it != v.end() - 1; ++it)
        std::cout << *it << ", ";
    std::cout << v.back() << "\n";
}

int main() {
    print(get_ranking({ 9, 3, 6, 19 }));
    print(get_ranking({ 3, 3, 3, 3, 3, 5, 1 }));
}
                

Lösung von: Jens Kelm (@JKooP)