Programmieren lernen

import math, random

def mittel(liste):
    summe=0
    for zahl in liste:
        summe+=zahl
    schnitt=summe/len(liste)
    return schnitt

noten=[]
for i in range(20):
    item = random.randint(10,60)/10
    noten.append(item)

noten.remove(max(noten))
noten.remove(min(noten))
print(mittel(noten))

                

Lösung von: Name nicht veröffentlicht

import math
notenliste = []
def calculate(ende = False):
    while ende == False:
        try:
            note = float(input("Note eingeben (für Ende Buchstaben eingeben): "))
            notenliste.append(note)
            
        except:
            ende = True
    avg = round((sum(notenliste)/len(notenliste)),2)
    def aufrunden(avg,schritt):
        return round(math.ceil(avg/schritt)*schritt,2)
    def abrunden (avg,schritt):
        return round(math.floor(avg/schritt)*schritt,2)
    print ("Max ist: ", max(notenliste))    
    print ("Min ist: ", min(notenliste))
    
    print ("Notenliste pur: ", notenliste)
    notenliste.remove(max(notenliste))
    notenliste.remove (min(notenliste))
    print ("Notelinste ohne schlechteste und ohne beste Note = ", notenliste)
    
    print("Durschnitt exakt: ", avg)
    print ("Aufgerundet auf 0.1: ", aufrunden(avg,0.1))
    print ("Aufgerundet auf 0.5: ", aufrunden(avg, 0.5))
    print ("Abgerundet auf 0.1: ", abrunden(avg, 0.1))
    print ("Abgerundet auf 0.5: ", abrunden(avg, 0.5))
    
calculate()

                

Lösung von: Py Thon ()

package noten;
import java.util.*;

public class noten {
	//Variable für den Durchschnitt
	static double durchschnitt=0;
	//Liste für die zufälligen Noten
	static List<Double> noten = new ArrayList<Double>();
	//Main methode
	public static void main(String[] args)
	  {
			//Zufallszahlen in die Liste einsetzen
	    	for(int i=0;i<20;i++)
	    		{
	    				Random random=new Random();
	    				double note = Math.round(10.0+random.nextDouble()*(6.0-1.0) * 10.0) / 10.0 ;
	    				noten.add(note);
	      
	    		}
	    //Platzhalter für die größte Zahl innerhalb des Arrays
	    double tempmax = 0;
	    //größte Zahl innerhalb des Arrays herausfinden
	    for (int i = 0; i < noten.size(); i++)
	    	{
	    		if (noten.get(i) > tempmax)
	    			{
	    				tempmax = noten.get(i);
	    			}
	    	}
	
	    //Platzhalter für die kleinste Zahl innerhalb des Arrays
	    double tempmin = 10.0;
	    //kleinste Zahl innerhalb des Arrays herausfinden
	 	for (int i = 0; i < noten.size(); i++)
	 	    	{
	 	    		if (noten.get(i) < tempmin)
	 	    			{
	 	    				tempmin = noten.get(i);
	 	    			}
	 	    	}

	 			//größte und kleinste Zahl entfernen
	 	    	noten.remove(tempmin);
	 	    	noten.remove(tempmax);
	 	    	
	 	    	//Zusammenzählen der Werte aus dem Array
	 	    	for(int i=0;i<noten.size();i++)
	 	    	{
	 	    		durchschnitt+=noten.get(i);
	 	    	}
	 	    	
	 	    	//Die Summe durch die Anzahl der Elemente des Arrays teilen
	 	    	durchschnitt=durchschnitt/noten.size();
	 	    	//Auf einen Integer runden
	 	    	durchschnitt=Math.round(durchschnitt * 10.0) / 10.0;
	 	    	//Verdoppelten Wert runden
	 	    	durchschnitt=Math.round(durchschnitt*2);
	 	    	//halbieren, um auf eine .0 oder .5 Zahl zu kommen
	 	    	durchschnitt=durchschnitt/2;
	 	    	System.out.println(durchschnitt);
	  }
	
	
}

                

Lösung von: Name nicht veröffentlicht

import random
def average(noten):
        summe = 0
        for i in noten:
                summe += float(i)
        average=summe/itemscount
        return average
noten = []
for i in range(20):
	item = random.uniform(1,6)
	item1 = "%.1f" % item
	noten.append(item1)
maxNote = max(noten)
minNote = min(noten)
positionMax = noten.index(maxNote)
noten.pop(positionMax)
positionMin = noten.index(minNote)
noten.pop(positionMin)
itemscount = len(noten)
print("%.f" % average(noten))



                

Lösung von: Name nicht veröffentlicht

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

namespace Schulnoten_Simulation {
	class Program {
		static void Main() {
			Random rnd = new Random();
			List<double> Noten = new List<double>();

			for (int i = 0; i < 20; i++)
				Noten.Add(rnd.Next(10, 61) / 10.0);

			Noten.Remove(Noten.Min());
			Noten.Remove(Noten.Max());

			Console.WriteLine("\nSchnitt: {0:0.0}", Math.Round(Noten.Sum() / Noten.Count / 0.5) * 0.5);

			Console.ReadKey(true);
		}
	}
}
                

Lösung von: Marcel Kapma ()

var grades = [],
    average = 0,
    i;
    
// zufallsnoten erzeugen
for (i = 0; i <= 20; i++) {
   grades.push(((Math.random() * (6 - 1)) + 1).toFixed(1));
}
grades.sort();

// statistische ausreißer entfernen
// mehrfache werden berücksichtigt
while (grades[0] == grades[1]) grades.shift();
while (grades[grades.length-1] == grades[grades.length-2]) grades.pop();
/* alternative (da man bei mehrfachen schlecht von
   ausreißern sprechen kann): */
// grades.shift(); grades.pop();

// durchschnitt ermitteln
for (i = 0; i < grades.length; i++) average += parseFloat(grades[i]);
average = (average / grades.length);

// durchschnitt verdoppeln, runden, und halbieren
average = Math.round(average * 2);
average /= 2;

console.log("Schülerdurchschnitt: " + average);
                

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

// Vira
namespace ProgrammierAufgaben
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    class Program
    {
        static void Main(string[] args)
        {
            rand = new Random();
            //Add grades
            List<double> Grades = GenerateGrades(20);
            //Remove extremes
            Grades.RemoveAll(d => d == Grades.Max() || d == Grades.Min());
            Console.WriteLine("Durchschnitt: {0:0.0}", Math.Round(Grades.Sum() / Grades.Count / 0.5) * 0.5);
            Console.ReadKey(true);
        }

        private static Random rand;
        private static List<double>GenerateGrades(int Length)
        {
            List<double> ToRet = new List<double>();

            for (int i = 0; i < Length; i++)
            {
                ToRet.Add((double)rand.Next(10, 61) / 10d);
            }

            return ToRet;
        }
    }
}

                

Lösung von: Thomas Rührig (Htl-Donaustadt (bzw ÖZBF nominiert - TU-Wien))

import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Random;

public class Main
{
	DecimalFormat df = new DecimalFormat("0.0");
	
	private float[] generateNotes()
	{
		Random note = new Random();		
		float [] notesStart = new float[20];
		
		for(int i = 0;i < notesStart.length;i++)
		{
			String s;
			
			s = df.format((Math.round((note.nextFloat() * 5 + 1) * 10.0) / 10.0));
			notesStart[i] = Float.parseFloat(s.replace(',', '.'));			
		}
		
		Arrays.sort(notesStart);
		return Arrays.copyOfRange(notesStart, 1, 19);
	}
	
	private void calculateAverage()
	{
		float[] notesAfter = new float[18];
		float average = 0;
		String s;
		
		notesAfter = generateNotes();
			
		for(int i = 0;i < notesAfter.length;i++)
		{
			average = average + notesAfter[i];
		}
		
		average = (float) (Math.round(average / notesAfter.length * 10.0) / 10.0);
		average = Math.round(average * 2);
		s = df.format(average);
		average = Float.parseFloat(s.replace(',', '.')) / 2;
		
		System.out.printf("Der Notengesamtdurchschnitt beträgt %s auf halbe Zehntel gerundet", average);
	}

	public static void main(String[] args)
	{
		Main run = new Main();
		
		run.calculateAverage();;
	}

}

                

Lösung von: Andy Großhennig (Bundeswehr)

(**
    Schülernoten (Simulationen)
    F#
*)
open System

let rnd = Random()

let round d =
     Math.Round(Math.Ceiling(d / 0.5) * 0.5, 3)

let noten = [ for i in 0..20 -> 
              float (rnd.Next(1, 6)) + float (rnd.Next(0, 9)) / 10.0 ]

let durchschnitt = 
    noten
    |> (List.sort >> List.tail)
    |> (List.sortBy(~-) >> List.tail)
    |> (List.average >> round)



printfn "Durchschnitt: %f" durchschnitt
                

Lösung von: Vural Acar ()

from random import randint

listenoten = []
notensumme = 0

for i in range(20):                             
    note = randint(10,60)/10
    listenoten.append(note)
    notensumme = notensumme + note

notensumme = notensumme - max(listenoten) 
notensumme = notensumme - min(listenoten)
notensumme = notensumme / 18
notensumme = round(notensumme,1)            #wegen allgemeiner ungenauigkeit beim rechnen mit dezimalzahlen

notensumme1 = notensumme

while notensumme - 0.5 >= 0:
    notensumme = notensumme - 0.5
    
notensumme = round(notensumme, 1)           #ebenfalls wegen allgemeiner ungenauigkeit beim rechnen mit dezimalzahlen
x = 0.5 - notensumme
notensumme = notensumme1 + x
print(notensumme)
                

Lösung von: Jasper -- (Gymnasium)

noten = Array.new

0.upto(19) do
  noten.push(((rand(1.0..6.0))*10.0).round / 10.0)
end

noten.sort!
noten.pop
noten.shift

sum = 0
noten.each {|i|
  sum += i
}

notenschnitt = (sum / noten.length * 10.0).round / 10.0
notenschnitt = (notenschnitt * 2.0).round / 2.0
p notenschnitt

                

Lösung von: Name nicht veröffentlicht

public class Programmieraufgaben_ch{
	public static void main (String [] Args) {
		schuelernoten();
	}
    public static void schuelernoten () {
    	//rNmb = Zufallszahl, noteListe wird alle Noten enthalten
    	Random rNmb = new Random();
    	double note;
    	double [] notenListe = new double [19];
    	
    	//weist jedem Index eine Note zwischen 1-6 zu
    	for (int i = 0; i<19; i++) {
    		//da .nextDouble eine Zahl zwischen 0.1-0.9 ausgibt wird mit 10 multipliziert
    		note = 10*(rNmb.nextDouble());
    		
    		//prüft ob note zwischen 1-6 liegt
    		if (note >= 1 && note <= 6) {
    			//wenn ja wird noteListe[i] eine mit 1 Stelle hinterm Komma zugewiesen
    			double temp = Math.round(10*note);
    			notenListe[i] = temp / 10;
    		} //wenn nein wird die for Schleife um einen Durchgang verlängert
    		else {
    			i--;
    		}
    	}
    	//aufrufen der Methoden average, gibt durchschnitt zurück
    	double durchschnitt = average(notenListe);
    	
    	//speichern der Nachkommastelle als String und Double
    	String nachkommaS = String.valueOf(durchschnitt -(int) durchschnitt);
    	double nachkommaD = durchschnitt - (int) durchschnitt;
    	
    	//rundet auf nächste Zahl (2,6 -> 3,0 | 2,3 -> 2,5) AUSNAHME: 2,0->2,0
    	if (nachkommaS.contains("0.0")) {
    		durchschnitt -= (nachkommaD);
    	}
    	else if (nachkommaD > 0.5) {
    		durchschnitt += (1-nachkommaD);
    	} else {
    		durchschnitt += (0.5-nachkommaD);
    	}
    	System.out.println("Durchschnitt: " + durchschnitt);
    }
    
    public static double average (double [] liste) {
    	double groesterWert = 0;
    	double kleinsterWert = 6;
    	double durchschnitt = 0;
    	
    	//for-Schleife geht durch komplette Liste, addiert alle Werte und ermittelt größten & kleinsten Wert
    	for (int i = 0; i<liste.length-1; i++) {
    		durchschnitt += liste[i];
    		if (groesterWert < liste[i]) { groesterWert = liste[i]; }
    		if (kleinsterWert > liste[i]) { kleinsterWert = liste[i]; }
    	}
    	
    	//Durchschnitt um groesterWert und kleinsterWert bereinigt
    	durchschnitt -=kleinsterWert+groesterWert;
    	//Durchschnitt = Listenlänge - 1 (Listenlänge = Menge aller Elemente - 1)
    	durchschnitt /=liste.length-1;
    	return durchschnitt;
    }
}
                

Lösung von: Thomas Anderson (Freie Universität Berlin)

package lernen1;

public class NotenDurchschnitt {

   public static void main (String[] args) {
	   
	   double[] noten = new double[20]; 
	   final double MIN = 1;
	   final double MAX = 6;
	   double gesamt = 0;
	   double durchschnitt = 0;
	   
	   // Zufallszahlen generieren
	   for(int i=0; i<noten.length; i++) { 
		   double a = ((Math.random()*MAX)+MIN); 
		   a = Math.round(a*10.0)/10.0;
		     // Zufallszahlzahl darf nicht grösser als 6.0 sein
		     if(a>6.0){
		    	a = 6.0;
		     }
		     
		   // Zufallszahl in Array schreiben 
	       noten[i] = a;  
	    }
	   
	   // Array aufsteigend sortieren
	   java.util.Arrays.sort(noten);
	   // Kleinsten und grössten Wert auf Null setzen
	   noten[0] = 0.0;
	   noten[19] = 0.0;
	   
	   // Array auslesen
	   for(int f = 0; f < noten.length; f++) {
		   // Werte addieren
    	  gesamt = gesamt + noten[f];   	      	   
	   } 
	   // Durchschnitt berechnen
	   durchschnitt = gesamt / noten.length;
	   // Auf eine Kommastelle runden
	   durchschnitt = Math.round(durchschnitt*10.0)/10.0;
	   // Auf 0.5 runden
	   durchschnitt = Math.round(durchschnitt*2.0)/2.0;
	   // Ausgabe
	   System.out.println("Der Notendurchschnitt beträgt: " + durchschnitt);
	   	   
		   
   }
	
	 
}
                

Lösung von: Al Ex (Wirt)

static void Schuelernoten()
        {
            Random r = new Random();
            float[] noten = new float[20];
            for (int i = 0; i < 20; i++)
            {
                float tempGrade = 1 + (float)r.NextDouble() * 5;
                noten[i] = tempGrade;
            }
            Array.Sort(noten);  //Nach Wert sortieren
            noten = noten.Where(w => w != noten[19]).ToArray(); //Beste und schlechteste Note entfernen
            noten = noten.Where(w => w != noten[0]).ToArray();

            float summe = 0.0F;
            for (int a = 0; a < noten.Length; a++)
            {
                summe += noten[a];
            }
            summe /= 18;
            Console.Write("Notenschnitt: " + summe.ToString("0.0"));

            Console.Write("\n");
            Main(null);
        }
                

Lösung von: Name nicht veröffentlicht

Module Module1

    Sub Main()
        Dim arr As New List(Of Double)
        Dim rand As New Random()
        Dim count As Integer = 0

        Console.WriteLine("Ungefiltert: ")

        While arr.Count < 20
            Dim zahl As Double = Math.Round(rand.Next(100, 600) / 100, 1)

            arr.Add(zahl)
            Console.WriteLine(zahl)
            count += 1
        End While

        arr.Sort()

        arr.RemoveAt(19)
        arr.RemoveAt(0)

        Console.WriteLine()
        Console.WriteLine("Gefiltert und gestrichen: ")

        Dim summe As Double
        For Each el In arr
            Console.WriteLine(el)
            summe += el
        Next

        Console.WriteLine()
        Console.WriteLine("Summe: " & summe)
        Console.WriteLine("Ungerundet: " & summe / arr.Count)

        summe /= arr.Count : summe *= 2
        summe = Math.Round(summe, MidpointRounding.AwayFromZero)
        summe /= 2

        Console.WriteLine("Gerundet: " & summe)

        Console.ReadLine()
    End Sub
End Module
                

Lösung von: Elias Zech (Optics Balzers)

<?php
$y = array();
$abc = array();


//Hier werden die Zufallszahlen zwischen 1,0 bis 6,0 in ein Array gepusht
for ($i=1; $i<=20; $i++)
{
    array_push($y,(mt_rand(10, 60) / 10));
}

//Hier wird das Array sortiert
natsort($y);

//Hier wird das erste und letzte Element aus dem Array gelöscht
$temp = array_shift($y);
$temp1 = array_pop($y);

/*Hier wird der Durchschnitt bestimmt und
 auf die erste Nachkommastelle gerundet*/
$durchschnitt = array_sum($y) / count($y);
$ergebnis = round($durchschnitt, 1);





//Hier wird der Durchschnitt auf die nächste halbe Note gerundet
if (strpos($ergebnis, ".") == true) {

    $abc = explode(".", (string)$ergebnis);

    if ($abc[1] >= 7.5)
    {
        $abc[1] = 0;
        $abc[0] += 1;
    }
    else if ($abc[1] >= 5 && $abc[1] < 7.5)
    {
        $abc[1] = 5;
    }
    else if ($abc[1] >= 2.5 && $abc[1] < 5)
    {
        $abc[1] = 5;
    }
    else
    {
        $abc[1] = 0;
    }

    $abc = implode(".", $abc);
    echo "Der Durchschnitt: " . $abc;

}
else
{
    $abc = $ergebnis;
    echo "Der Durchschnitt: " . $abc;
}

?>
                

Lösung von: Maik Scheiermann (Powercloud GmbH)

REPORT  zschuelernoten.

DATA: lv_random TYPE i,
      lv_random2 TYPE i,
      lv_note TYPE p DECIMALS 1,
      lv_durchschnitt TYPE p DECIMALS 1,
      lt_noten TYPE STANDARD TABLE OF string,
      ls_noten LIKE LINE OF lt_noten,
      lv_gerundet TYPE p DECIMALS 1.


DO 20 TIMES. " 20 Noten werden generiert.

  " Da nur Integer generiert werden können, werden zwei Zahlen berechnet.
  " Die erste zwischen 1 und 5 und die zweite zwischen 0 und 10.
  CALL FUNCTION 'QF05_RANDOM_INTEGER'
    EXPORTING
      ran_int_max   = 5
      ran_int_min   = 1
    IMPORTING
      ran_int       = lv_random
    EXCEPTIONS
      invalid_input = 1
      OTHERS        = 2.
  IF sy-subrc <> 0.
    MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
            WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
  ENDIF.

  CALL FUNCTION 'QF05_RANDOM_INTEGER'
    EXPORTING
      ran_int_max   = 10
      ran_int_min   = 0
    IMPORTING
      ran_int       = lv_random2
    EXCEPTIONS
      invalid_input = 1
      OTHERS        = 2.
  IF sy-subrc <> 0.
    MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
            WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
  ENDIF.

  " Zweite Zahl wird durch 10 geteilt um einen beliebigen Wert zwischen 0.0 und 1.0 zu erhalten.
  lv_note = lv_random2 / 10.
  " Erste Zahl wird nun addiert. Nun haben wir eine Zufallszahl zwischen 1.0 und 6.0
  lv_note = lv_note + lv_random.

  " Note wird in die Liste eingetragen
  APPEND lv_note TO lt_noten.

ENDDO.

" Liste wird sortiert
SORT lt_noten ASCENDING.

" Erster und letzter Eintrag werden gelöscht
DELETE lt_noten INDEX 20.
DELETE lt_noten INDEX 1.

" Durchschnitt wird ausgerechnet.
LOOP AT lt_noten INTO ls_noten.
  WRITE: / ls_noten.
  lv_durchschnitt = lv_durchschnitt + ls_noten.
ENDLOOP.

lv_durchschnitt = lv_durchschnitt / 18.

" Es wird auf x.0 oder x.5 gerundet und ausgegeben.
lv_gerundet = lv_durchschnitt MOD '0.5'.

IF lv_gerundet = 0.
  WRITE: / lv_durchschnitt.
ELSEIF lv_gerundet <= '0.2'.
  lv_durchschnitt = lv_durchschnitt - lv_gerundet.
  WRITE: / lv_durchschnitt.
ELSEIF lv_gerundet >= '0.3' AND lv_gerundet <= '0.7'.
  lv_durchschnitt = lv_durchschnitt - lv_gerundet + '0.5'.
  WRITE: / lv_durchschnitt.
ELSEIF lv_gerundet >= '0.8'.
  lv_durchschnitt = lv_durchschnitt - lv_gerundet + '1'.
  WRITE: / lv_durchschnitt.
ENDIF.
                

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

package ch.schuelernoten;
/**
 * 
 * 
 * WICHTIGE ANMERKUNG...
 * Da ich erst 12 Jahre alt bin, kann es sein, dass mein Code ein bisschen schlecht geschrieben wurde!
 * 
 * 
 */
import java.util.ArrayList;
import java.util.Random;

public class Main {
	
	static Random random;
	
	static float[] noten = new float[20];
	static ArrayList<Float> NotenArray = new ArrayList<>();
	
	static float Durchschnitt = 0;
	
	static float groesste, kleinste;
	
	public static void main(String[] args) {
		random = new Random();
		
		for (int i = 0; i < 10; i++) {
			
		
			//  1.   Erstelle zufällige Noten.
			zufaelligeNoten();
			//	2.	 streichen Sie die beste und die schlechteste Note (statistische Ausreißer),
			findeKleinste();
			findeGroesste();
			//  3. Entferne die grösste und kleinste.
			entferneMinMax();
			//  4. Errechne den Durchschnitt.
			errechneDurchschnitt();
			//  5. Erhalte den Durchschnitt
			float d = Durchschnitt;
			d = ((float)((int)(d*10))) / 10;
			System.out.println(d);
		}
		 
	}
	
	private static void errechneDurchschnitt() {
		int NotenAnzahl = NotenArray.size();
		float summeVonNoten = 0;
		for (int i = 0; i < NotenAnzahl; i++) {
			summeVonNoten += NotenArray.get(i);
		}
		Durchschnitt = summeVonNoten / NotenAnzahl;
	}

	private static void entferneMinMax() {
		
		for (int i = 0; i < noten.length; i++) {
			if(!(noten[i] == kleinste || noten[i] == groesste)) {
				NotenArray.add(noten[i]);
			}
		}
		
	}

	private static void findeKleinste() {
		float kleinste = 6;
		for (int i = 0; i < noten.length; i++) {
			if(noten[i] < kleinste)
				kleinste = noten[i];
		}
		
	}
	
	private static void findeGroesste() {
		float groesste = 6;
		for (int i = 0; i < noten.length; i++) {
			if(noten[i] < groesste)
				groesste = noten[i];
		}
		
	}
	

	private static void zufaelligeNoten() {
		
		for (int i = 0; i < noten.length; i++) {
			noten[i]  = random.nextFloat() * 5 + 1;
			//System.out.println(noten[i]);   :::: Zu debug zwecken
		}
		
	}
	
}

                

Lösung von: Name nicht veröffentlicht

<?php

$notes = array_map(function () {
    return (mt_rand(10, 60) / 10);
}, range(1, 20));

sort($notes);

$result = ceil(array_sum(array_slice($notes, 1, -1)) / (count($notes) - 2) * 2) / 2;

echo $result;


                

Lösung von: Vural Acar ()

import random

def generateNotes():
    notes =[]
    for i in range(0,20):
        notes.append(round(random.uniform(1,6)))
    return notes


def deleteBestAndWorst(notes):
    sortedNotes = sorted(notes)
    del sortedNotes[-1] #delete worst
    del sortedNotes[0]  #delete best
    return sortedNotes
    

notes1 = generateNotes()
notes2 = deleteBestAndWorst(notes1)
notes3 = []
sum = 0

for i in notes2:
    sum += i

for i in notes2:

    if(round(i%1,1) < 0.5):
        notes3.append(i-(i%1))
    elif(round(i%1,1) > 0.5):
        notes3.append(i+(1-(i%1)))
    else:
        notes3.append(i)

print "Durchschnitt: " + str(round(sum/len(notes3),1))
                

Lösung von: Name nicht veröffentlicht

import random


def average():
    marks = []
    dup_removed = []

    for i in range(20):
        mark = random.randint(10, 60) / 10
        marks.append(mark)
    marks.sort()

    for mark in marks:
        if not mark == marks[0] or not mark == marks[-1]:
            if mark not in dup_removed:
                dup_removed.append(mark)

    final = 0.0
    item_counter = 0

    for mark in dup_removed[:]:
        rounded_mark = round(mark * 2) / 2
        final += rounded_mark
        item_counter += 1

    mark_average = round(final / item_counter, 2)
    print(mark_average)


average()

                

Lösung von: Infinit Loop ()

// NET Core 3.x

using System;
using System.Linq;

namespace CS_Aufgabe_Schuelernoten
{
    class Program
    {
        static void Main(string[] args)
        {
            var lst = Enumerable.Range(0, 20).Select(x => Math.Round((new Random().Next(10, 61) / 10.0 ) * 2, 0) / 2).OrderBy(x => x).ToList().GetRange(1, 18);
            lst.ForEach(x => Console.WriteLine($"{x:F1}"));
            Console.WriteLine($"Durschnitt: {lst.Average():F1}");
        }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

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

namespace Schülernoten
{
    class Program
    {
        static float KleinsterWert(float[] noten)   // kleinsten Wert rausfiltern
        {
            float kleinsterWert = noten[0];
            for (byte i = 0; i < noten.Length; i++) {
                if (kleinsterWert > noten[i])
                    kleinsterWert = noten[i];
            }

            return kleinsterWert;
        }
        static float GrössterWert(float[] noten)    // grössten Wert rausfilten
        {
            float grössterWert = noten[0];
            for (byte i = 0; i < noten.Length - 1; i++) {
                if (grössterWert < noten[i])
                    grössterWert = noten[i];
            }

            return grössterWert;
        }
        static void Main()
        {
            Random r = new Random();
            float[] noten = new float[20];
            byte i = 0;
            for (i = 0; i < 20; i++) {
                float zwischenNoten = (float)r.Next(10, 61);
                noten[i] = zwischenNoten / 10;
            }

            float kleinsterWert = KleinsterWert(noten);
            float grössterWert = GrössterWert(noten);
            float durchschnitt = 0;
            List<float> gefillNoten = new List<float>();
            for (i = 0; i < noten.Length; i++) {
                if (noten[i] != kleinsterWert && noten[i] != grössterWert) { // kleinsten u. grössten Wert rauslöschen
                    gefillNoten.Add(noten[i]);
                    durchschnitt += noten[i];
                }
            }

            durchschnitt /= gefillNoten.Count; // durschnitt berechnen
            for (i = 0; i < gefillNoten.Count; i++) {
                Console.WriteLine("Note {0}: {1}", i+1, gefillNoten[i]);   // noten ausgabe
            }

            Console.WriteLine("\nDurschschnitt: {0:0.0}", Math.Round(gefillNoten.Sum() / gefillNoten.Count / 0.5) * 0.5);   // Durschnitt ausgabe
            Console.ReadKey();  // endl
        }
    }
}

                

Lösung von: Name nicht veröffentlicht

// C++ 17 | VS-2022
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iomanip>

int main() {
    srand((int)time(nullptr));
    std::vector<double>v{};
    for (size_t i{ 0 }; i < 20; ++i)
        v.push_back(floor((rand() % 55 + 10.0) / 5.0) * 0.5);
    std::sort(v.begin(), v.end());
    const auto first{ v.begin() + 1 }, last{ v.end() - 1 };
    const auto avg{ std::accumulate(first, last, 0.0) / (last - first) };
    for (auto it{ first }; it != last; ++it)
        std::cout << std::fixed << std::setprecision(1) << *it << "\n";
    std::cout << std::setprecision(2) << "Durchschnitt: " << avg << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <random>
#include <vector>


class Student_Grades {
private:
    const double min_grade_{ 1.0 };
    const double max_grade_{ 6.0 };
    const size_t num_grades_{ 20 };
    const bool outliers_{ true };

    std::vector<double> grades_{ get_grades() };
    std::vector<double>::iterator first_{ grades_.begin() + outliers_ };
    std::vector<double>::iterator last_{ grades_.end() - outliers_ };
    double avg_{ std::accumulate(first_, last_, 0.0) / (last_ - first_) };

    const double get_rng_rnd_num();
    const std::vector<double> get_grades();

public:
    Student_Grades() {  }
    Student_Grades(size_t num_grades) : num_grades_{ num_grades } {  }
    Student_Grades(size_t num_grades, bool outliers) : num_grades_{ num_grades }, outliers_{ outliers } {  }
    Student_Grades(double min_grade, double max_grade, size_t num_grades, bool outliers) :
        min_grade_{ min_grade }, max_grade_{ max_grade }, num_grades_{ num_grades }, outliers_{ outliers } {  }

    friend std::ostream& operator<<(std::ostream&, const Student_Grades&);
};

inline const double Student_Grades::get_rng_rnd_num() {
    std::random_device dev;
    std::mt19937 rng(dev());
    std::uniform_real_distribution<double>dist(min_grade_, max_grade_);
    return dist(rng);
}

inline const std::vector<double> Student_Grades::get_grades() {
    std::vector<double>out{};
    for (size_t i{ 0 }; i < num_grades_; ++i)
        out.push_back(get_rng_rnd_num());
    std::sort(out.begin(), out.end());
    return out;
}

inline std::ostream& operator<<(std::ostream& os, const Student_Grades& sg) {
    for (auto it{ sg.first_ }; it != sg.last_; ++it)
        os << std::fixed << std::setprecision(1) << *it << "\n";
    os << std::setprecision(2) << "Durchschnitt: " << sg.avg_ << "\n\n";
    return os;
}

int main() {
    std::cout << Student_Grades();
    std::cout << Student_Grades(10);
    std::cout << Student_Grades(10, false);
    std::cout << Student_Grades(2.0, 4.0, 10, true);
}


                

Lösung von: Jens Kelm (@JKooP)