Java-Code

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/* #352 AUSGABENSTELLUNG:
Bei internationalen Wettkämpfen bewerten in Einzelwettbewerben sieben Wettkampfrichter die Sprünge.
Jeder vergibt pro Sprung 0 bis 10 Punkte, mit Schritten von halben Punkten.
Die zwei höchsten und niedrigsten Wertungen werden gestrichen.
Die verbleibenden drei Wertungen werden addiert und das Ergebnis mit dem Schwierigkeitsgrad multipliziert.
Das Endresultat entspricht der erzielten Punktzahl des Springers.

Beispiel 1:
Schwierigkeitsgrad: 2,1
Punkte: 7,5 | 7,5 | 7,0 | 8,0 | 8,0 | 7,5 | 8,5
Gestrichen: 7,5 | 7,5 | 7,0 | 8,0 | 8,0 | 7,5 | 8,5
Wertung: 7,5 + 7,5 + 8,0 = 23 * 2,1 = 48,3

Beispiel 2:
Schwierigkeitsgrad: 1,6
Punkte: 7,5 | 7,5 | 7,5 | 7,5 | 7,5 | 7,5 | 7,5
Gestrichen: 7,5 | 7,5 | 7,5 | 7,5 | 7,5 | 7,5 | 7,5
Wertung: 7,5 + 7,5 + 7,5 = 22,5 * 1,6 = 36

Erstelle eine Methode/Funktion, mit der die obige Aufgabenstellung gelöst werden kann.

Viel Spaß
 */


public class Turmspringen {
	
	public static void main(String[] args) {
		
		System.out.println("Wertung: "+valuation());
	}
	
	public static float valuation() {
		
		//Schwierigkeitsgrad abfragen
		Scanner scanner = new Scanner(System.in);
		System.out.println("Geben Sie den Schwierigkeitsgrad ein: ");
		float difficulty = scanner.nextFloat();
		
		//Neues Punkte-Array erzeugen
		float[] points = new float[7];
		
		//Punkte-Array mit Bewertungen befüllen
		for(int i = 0; i < points.length; i++) {
			System.out.println("Geben Sie die "+(i+1)+". Bewertung ein (0 bis 10, mit Schritten von halben Punkten): ");
			points[i] = scanner.nextFloat();
		}
		scanner.close();
		
		//Punkte-Array sortieren
		Arrays.sort(points);
		
		//Punkte-Array zu einer ArrayList konvertieren
		ArrayList<Float> pointsList = new ArrayList<Float>(); 
		
		for(int i = 0; i < points.length; i++) {
			pointsList.add(points[i]);
		}
		
		//ersten beiden und letzten beiden Bewertungen löschen
		pointsList.remove(0);
		pointsList.remove(0);
		pointsList.remove(pointsList.size()-1);
		pointsList.remove(pointsList.size()-1);
		
		//ArrayList wieder zu Array konvertieren
		float[] filteredArray = new float[pointsList.size()];
		int index = 0;
		for(Float point : pointsList)
		{
			filteredArray[index++] = point;
		}
		
		//Summe aus Punkten bilden und mit Schwierigkeitsgrad multiplizieren
		float sum = 0;
		for(int i = 0; i < filteredArray.length; i++) {
			sum += filteredArray[i];
		}
		
		float valuation = sum * difficulty;
		
		return valuation;	
	}
}

Java-Code

import java.util.ArrayList;
import java.util.Locale;

import javax.swing.JOptionPane;

public class Task352 {

	public static void main(String[] args) {
		ArrayList<Double> a = new ArrayList<Double>();
		double score = 0;
		double diff = 0;
		int judges;
		int rule;

		do {
			do {
				judges = Integer.parseInt(JOptionPane.showInputDialog("Bitte geben Sie die Anzahl der Richter ein: "));
				rule = Integer.parseInt(JOptionPane
						.showInputDialog("Wie viele Zahlen sollen vom Maximum und Minimum gestrichen werden?"));
			} while (!validate(judges, rule));

			for (int i = 0; i < judges; i++) {
				a.add(input(i, true));
			}
			diff = input(0, false);

			clean(a, rule);
			score = conclude(a, diff);

		} while (JOptionPane.showConfirmDialog(null,
				"Die End-Punktzahl lautet: " + toString(a, diff) + score + "\nNeue Punktzahl berechnen?", "Aufgabe 352",
				0) == 0);
	}

	private static String toString(ArrayList<Double> a, double diff) {
		String s = "";

		for (int i = 0; i < a.size(); i++) {
			if (i < a.size() - 1) {
				s += a.get(i) + "+";
			} else {
				s += a.get(i);
			}
		}
		s += "*" + diff;
		return s + "= ";
	}

	private static double conclude(ArrayList<Double> a, double d) {
		double r = 0;
		for (int i = 0; i < a.size(); i++) {
			r += a.get(i);
		}
		return Double.parseDouble(String.format(Locale.ENGLISH, "%.1f", r * d));
	}

	private static boolean validate(int judges, int rule) {
		if (judges - rule * 2 > 0) {
			return true;
		}
		JOptionPane.showMessageDialog(null, "Diese Einstellungen sind nicht erlaubt.", "Aufgabe 352", 0);
		return false;
	}

	private static void clean(ArrayList<Double> a, int rule) {

		for (int i = 0; i < rule; i++) {
			int max = 0;
			for (int j = 0; j < a.size(); j++) {
				if (a.get(j) > a.get(max)) {
					max = j;
				}
			}
			a.remove(max);
		}

		for (int i = 0; i < rule; i++) {
			int min = 0;
			for (int j = 0; j < a.size(); j++) {
				if (a.get(j) < a.get(min)) {
					min = j;
				}
			}
			a.remove(min);
		}
	}

	private static double input(int i, boolean b) {
		if (b) {
			return Double.parseDouble(JOptionPane
					.showInputDialog("Bitte geben Sie die vergebene Punktzahl von Richter " + (i + 1) + " ein:"));
		}
		return Double.parseDouble(JOptionPane.showInputDialog("Bitte geben Sie die Schwierigkeitsstufe ein:"));
	}
	/*
	 * Zur Erläuterung: Ich habe diese Aufgabe ein bisschen erweitert, indem man die
	 * Anzahl der Richter und die Punktestreichung im Programm selbst regulieren
	 * kann. Wäre vielleicht auch die schwierigere Variante.
	 */
}