Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Schülernoten (Simulationen)

Schreiben Sie ein Programm, das 20 Zeugnisnoten (1.0 bis 6.0) in Zehntelnoten (z. B. 4.3) zufällig erzeugt (gleichverteilt: Alle Werte haben die selbe Chance). Verwenden Sie diese 20 Noten, um damit den relevanten Durchschnitt nach folgendem Verfahren berechnet.

  • streichen Sie die beste und die schlechteste Note (statistische Ausreißer),

  • ermitteln Sie den Durchschnitt der verbleibenden Zahlen und

  • runden Sie auf die nächste halbe Note (1, 1.5, 2, ..., 4.5, 5, 5.5, 6).

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

gressly 1. März 2015 14:54   reply report
Beim Streichen der besten und der schlechtesten Note kann es vorkommen, dass diese mehrfach vorkommt. Streichen Sie diese dann entweder nur einmal oder gerade alle Vorkommen. Da dieser Fall nicht sehr häufig ist, spielt die Behandlung nicht so eine Rolle.

21 Lösung(en)

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: Riko Stave ()

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 ()

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: aj6w-74tw
Autor: Philipp Gressly Freimann (SANTIS Training AG)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen