C#-Code

private static double Average(this double[] values)
{
	double sum = 0;
	//Bilde die Summer über alle Elemente
	foreach (double item in values)
	{
		sum += item;
	}
	return sum/values.Length;
}

C#-Code

	double[] werte = new double[]{3.5,7.5};
	double mittelwert = Average(werte);

C#-Code

	double[] werte = new double[]{3.5,7.5,23};
	double mittelwert = werte.Average();

C#-Code

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

namespace ConsoleApplication1
{
   /*Ich habe das Programm ein bissel erweitert, um es Praxisnäher zu machen*/
    
    class Program
    {
        static void Main(string[] args)
        {
            int anzahlWerte;         //Zur Größenermittlung des Arrays, und zur Bestimmung der Durchgänge des eintragens der Werte
            int anzahlDurchg;        //Nur zur Optischen Orientierung bei der Eingabe der Werte
            double var;              //Zum Übergeben des Wertes an das Array
            double summe = 0;        //Zur Ermittlung des Mittelwertes, auf 0 gesetzt um Fehler zu minimieren
            double mittelwert = 0;   //Zur Ausgabe des Mittelwertes, auf 0 gesetzt um die Übergabe an die Methode zu ermöglichen
            bool anzahlOk = false;   //Zur Überprüfung ob die angegeben Anzahl ein Integer ist (Abfangen von eingabe Fehlern)
            bool wertOk = false;     //Zur Überprüfung ob der Angegeben Wert ein Double ist (Abfangen von eingabe Fehlern)
            string eingabeAnzahl;    //string zur Erfassung der Daten für die Anzahl
            string eingabeVar;       //string zur Erfassung der Daten für die Werte
           

            Console.Write("Willkommen \nProgramm zum ermitteln des Mittelwertes\n");

            while (anzahlOk == false) 
            {
                Console.Write("Bitte Anzahl der Werte eingeben: ");                
                eingabeAnzahl = Console.ReadLine();                                 //Abfrage für die Anzahl der Werte
                anzahlOk = Int32.TryParse(eingabeAnzahl, out anzahlWerte);          //Überprüfung auf Richtigkeit der Eingabe
            

                if ( anzahlOk== false ){Console.WriteLine("Fehler bei der Eingabe für die Anzahl der Werte");}
                else
                {
                    double[] Datenfeld = new double [anzahlWerte];                  //Erstellen eines Datenfeldes mit Variabeler Größe
                    for (int i = 0; i < anzahlWerte; i++)                           //Ausfüllen des Datenfeldes
                    {
                        while (wertOk == false) 
                        {

                            anzahlDurchg = i + 1; 
                            Console.Write("Bitte den "+anzahlDurchg+". Wert eingeben: ");
                            eingabeVar = Console.ReadLine();
                            wertOk = double.TryParse(eingabeVar, out var);          //Überprüfen auf Richtigkeit der Eingabe, Springen aus der while-Schleife
                            Datenfeld[i] = var;
                            if (wertOk == false) Console.WriteLine("Ungültiger Wert eingegeben");
                        }
                        wertOk = false;                                             //wertOk auf falsch setzen zum ausführen der while-Schleife

                  
                    }
                    for (int a = 0; a < anzahlWerte; a++)                           //Summen Berechnung des Datenfeldes (alle Einträge)
                    {
                        summe += Datenfeld[a];
                    }
                    MittelwertBerechnen(mittelwert, summe, anzahlWerte);            //Übergabe der Werte an die Methode
                                        
                }
            }
            
        
        
        }
        static void MittelwertBerechnen(double mittelwert, double summe, int anzahlWerte) 
        {
            mittelwert =summe / anzahlWerte;
            Console.WriteLine("Der Mittelwert beträgt " + mittelwert + "\nZum Beenden eine beliebige Taste drücken...");
            Console.ReadKey();
          
        }
    }
}

C#-Code

using System;

public class Class1
{

    public static void Main(String[] args)
    {
        Double[] feldEins = { 0.2 }; // Mittelwert == .2
        Double[] feldZwei = { 6.5, 2.1, 10.9, 0 }; // Mittelwert == 4.875

        System.Console.WriteLine(berechneMittelwert(feldEins));
        System.Console.WriteLine(berechneMittelwert(feldZwei));

        System.Console.ReadKey();
    }

    private static double berechneMittelwert(double[] eingabeFeld)
    {
        Int32 feldLaenge = eingabeFeld.Length;
        Double summe = 0;
        foreach (Double wert in eingabeFeld)
        {
            summe += wert;
        }
        Double ergebenis = summe / feldLaenge;
        return ergebenis;
    }

}

C#-Code

public Double Average(params Double[] values)
{
    return values.ToList().Average();
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BerechneMittelwert
{
    class Program
    {
        static void Main(string[] args)
        {
            //Schreiben Sie eine Methode, die den Mittelwert der Werte eines eindimensionalen Feldes von double-Variablen berechnet und 
            //als Rückgabewert zurückliefert. Testen Sie die Methode durch zwei Aufrufe mit unterschiedlich großen Feldern. 
            
            double mittelwert;
            string s;
            Console.WriteLine("Bitte geben Sie mehrere Zahlen durch Leerzeichen getrennt ein!");
            s =  Console.ReadLine();
            
            try{
                string[] helper = s.Split(' ');
                int dimension = helper.Length;

                double[] myArray = new double[dimension];

                for (int i = 0; i < myArray.Length; i++) {
                    myArray[i] = Convert.ToDouble(helper[i]);
                }
                double sum=0;
                for (int i=0; i < dimension; i++ ){
                    sum += myArray[i];
                }
                mittelwert = sum / dimension;
                Console.WriteLine("Der Mittelwert ist: " + mittelwert);
            }
             
            catch(Exception e){
                 Console.WriteLine(e.Message);
            }
            Console.ReadLine();
        }
    }
}

C#-Code

namespace lesson2_Mittelwert
{
    class Program
    {
        // Feld erstellen
        private static double[] FieldCreation(int elements)
        {
            double[] field;
            Random rand = new Random();
            field = new double[elements];

            for (int i = 0; i < elements; i++)
            {
                field[i] = (i + 1) * 10 * rand.NextDouble();
            }
            return field;
        }

        // Mittelwetberechnung
        private static double Avg(double[] field)
        {
            double sum = 0;

            for (int i = 0; i < field.Length; i++)
            { 
                sum += field[i];
            }
            return sum / field.Length;
        }

        static void Main(string[] args)
        {
            string eingabeElements;
            int[] elements = new int[2];
            double[] feld;

            // Userinteraction
            for (int i = 0; i < 2; i++)
            {
                do
                {
                    Console.WriteLine("Anzahl der Elemente {0}. Aufruf: ", i + 1);
                    eingabeElements = Console.ReadLine();
                    if (Int32.TryParse(eingabeElements, out elements[i])) { }
                    else { Console.WriteLine("Falsche Eingabe für, noch mal...", i + 1); }
                }
                while (elements[i] == 0);
            }

            for (int i = 0; i < 2; i++ )
            {
                feld = FieldCreation(elements[i]);
                double average = Avg(feld);

                Console.WriteLine("Durchschnitt {0}. Aufruf beträgt: {1}", i+1, average);
            }
            Console.ReadLine();
        }
    }
}

C#-Code

public static double MittelwertBerechnen(double[] arr)
        {
            double sum = 0;

            for(int i = 0; i < arr.Length; i++)
            {
                sum += arr[i];
            }

            return sum / arr.Length;
        }

C#-Code

public static double calcAverage(double[] values)
        {
            double sum = 0;

            foreach (double item in values)
            { 
                sum += item;
            }

            return sum / values.Length;
        }

C#-Code

using System;

namespace TYP_02
{
    class Program
    {
        static void Main(string[] args)
        {
 // Feldgröße bestimmen
            int feldGröße = 0;
            while (true)
            {
                Console.WriteLine("Feldgröße?");
                string value = Console.ReadLine();
                try
                {
                    feldGröße = Convert.ToInt32(value);
                    if (feldGröße < 2)
                    {
                        continue;
                    }
                    break;
                }
                catch (Exception)
                {
                    Console.WriteLine("Kein Int! Neu eingeben!");
                    continue;
                }
                
            }

            //Feldwerte einlesen
            double[] doubleArray = new double[feldGröße];
            double eingabeDouble = 0;
            double sum = 0;

            for (int i = 0; i < feldGröße; i++)
            {
               
                while (true)
                {
                    Console.WriteLine("Bitte Wert " + (i+1) + " eingeben");
                    string value = Console.ReadLine();
                    try
                    {
                        eingabeDouble = Convert.ToDouble(value);
                        sum += eingabeDouble;
                        break;
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("kein Double Wert!");
                        continue;
                    }
                }
            }

            //Ergebnis ausgeben
            Console.WriteLine("Mitte ist: " + sum / feldGröße );
            Console.ReadLine();
        }
    }
}

C#-Code

class Program
    {
        static void Main(string[] args)
        {
            double[] doubleArray;
            doubleArray = RandomDoubleArray.generate(10, 100);
            Console.WriteLine("Array with length: " + doubleArray.Length + " Has an average of: " + Averager.getAverage(doubleArray));
            doubleArray = RandomDoubleArray.generate(20, 100);
            Console.WriteLine("Array with length: " + doubleArray.Length + " Has an average of: " + Averager.getAverage(doubleArray));
            Console.ReadKey();
        }
    }

public class RandomDoubleArray
    {
        public static double[] generate(int size, int maxValue)
        {
            Random rand = new Random();
            double[] array = new double[size];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = rand.NextDouble() * maxValue;
            }
            return array;
        }
    }

public class Averager
    {
        public static double getAverage(double[] doubleArray)
        {
            double result = 0;
            foreach (double field in doubleArray)
            {
                result = result + field;
            }
            return result / doubleArray.Length;
        }
    }

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Console;

namespace Mittelwert
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] list1 = { 1.234, 4.345, 6.234, 9.678678, 123.2342 };
            double[] list2 = { 2, 8, 4, 6, 1, 9, 0, 10 };

            Out.WriteLine(average(list2));

            Out.WriteLine(average(list1));

            Read();
        }

        static double average(double[] list)
        {
            double erg = 0;

            foreach (double d in list)
            {
                erg += d;
            }

            return erg / list.Length;
        }
    }
}

C#-Code

        public static double berechneMittelwert(double[] Mittelwerte)
        {
            double Rechnung = 0;
            for (int i = 0; i < Mittelwerte.Length; i++)
            {
                Rechnung += Mittelwerte[i];
            }
            return Rechnung / Mittelwerte.Length;
        }

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TYP_CS_Aufgabe_Nr2
{
    class Program
    {
        // Quest: eine Methode, die den Mittelwert einer 1D-Matrix von double-Variablen berechnet und als Rückgabewert zurückliefert.
        
        static void Main(string[] args)
        {
            Random rnd1 = new Random(); //                   Objekt der Random-Klasse erzeugen

            int RndNr1 = rnd1.Next(2, 10); //               mithilfe des Random-Objekts eine zufällige Länge für den Vektor bestimmen

            Console.WriteLine("Gegeben ist ein Vektor mit {0} Einträgen", RndNr1);

            double ZwischenWert = 0; //                      Zwischenwert für Mittelwertbildung
           
            double[] vektor = new double[RndNr1]; //         Vektor mit der o.g. Länge erzeugen
            for (int i = 0; i < RndNr1; i++ )
            {
                int j = i + 1;
                vektor[i] = rnd1.NextDouble() * 1000; //   Vektor mit zufälligen REAL-Werten zw. 0.0 und 1000.0 initialisieren       
                ZwischenWert += vektor[i];
                Console.WriteLine("{0}. Eintrag: {1:E3}", j, vektor[i]);
            }            
            ZwischenWert = ZwischenWert / RndNr1; //         Mittelwert bilden
            Console.WriteLine("\nDer Mittelwert lautet: {0:E3}. \nMit ENTER fortfahren...", ZwischenWert);
            Console.ReadLine();
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] array = new double[] { 1.11274, 2.264562, 3.3333, 4.4444, 5.5555 };
            double mittelwert = array.Average();
            Console.WriteLine("Ergebnis: {0}", mittelwert);
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Mittelwert_berechnen
{
    class Program
    {
        static void Main(string[] args)
        {
            Mittelwert();
            Console.ReadLine();


        }
        public static double Mittelwert()
        {
            double[] a = new double[] { 5.1, 5.5, 9.1, 23.5, 21.3, 2.1 };
            double result = a.Average();
            
            Console.WriteLine("Der Mittelwert lautet " + result);
            return result;
           

        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Mittelwert_Rechner
{
    class Program
    {
        static void Main(string[] args)
        {
            int Mittelwert, Summe = 0;
            Console.Write("Wie viele Werte sollen genutzt werden ?");
            int length = int.Parse(Console.ReadLine());
            int[] Zahlen = new int[length];

            for(int z1 = 0; z1 < Zahlen.Length; z1++)
            {
                Console.Write("Gib eine Zahl ein: ");
                Zahlen[z1] = int.Parse(Console.ReadLine());
                Summe += Zahlen[z1];
            }
            Mittelwert = Summe / Zahlen.Length;
            Console.WriteLine("Der Mittelwert ist: {0}", Mittelwert);
            Console.ReadKey();
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {

        public static double Mittelwert(double[] arr)
        {
            double sum = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                sum += arr[i];
            }
            return (sum / arr.Length);
        }

        static void Main(string[] args)
        {
            bool valid = false;
            do
            {
                Console.Clear();
                Console.WriteLine("Wieviele Werte soll das Array haben?");
                int anzahl;
                valid = Int32.TryParse(Console.ReadLine(), out anzahl);
                if (valid == true)
                {
                    double[] array = new double[anzahl];
                    for (int i = 0; i < array.Length; i++)
                    {
                        Console.WriteLine("Gib den {0}. Wert des Array ein: ", i+1);
                        array[i] = Convert.ToDouble(Console.ReadLine());
                    }
                    Console.Clear();
                    Console.WriteLine("Dein Array: ");
                    for (int i = 0; i < array.Length; i++)
                    {
                        Console.Write(array[i] + " ");
                    }
                    Console.WriteLine();
                    Console.WriteLine("Der Mittelwert ist {0}.", Program.Mittelwert(array));
                    Console.ReadLine();
                }
                else
                {
                    Console.Clear();
                    Console.WriteLine("Try again ...");
                    Console.ReadLine();
                }
            } while (valid == false);

        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Mittelwert
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] x = { 15f, 45f, 5f, 1655f, 10f };
            double[] y = { 65564f, 65456f, 987897f, 456165f, 5f };

            Program p = new Program();

            // First Try
            Console.WriteLine(p.getMittelwert(x).ToString());
            
            // Second Try
            Console.WriteLine(p.getMittelwert(y).ToString());
            
            Console.ReadKey();

        }

        public double getMittelwert(Double[] input)
        {
            // Summe / Anzahl
            double summe = 0f;
            double anzahl = 0f; 

            if (input != null)
            {
                int arrLaenge = input.Length;

                try
                {
                    anzahl = (double)arrLaenge;
                }
                catch
                {
                    return 0f;
                }

                foreach (var x in input)
                {
                    summe += x;
                }
            }

            return summe / anzahl;
        }
    }
}

C#-Code

public static double getAverage(double[] arrayOfNumbers)
        {
            double sum = 0;
            foreach (double number in arrayOfNumbers)
            {
                sum += number;
            }
            return sum/arrayOfNumbers.Length;
        }

C#-Code

private static double Mittelwert(double[] input)
{
    double mittelwert;
    double temp = 0;

    for(int i = 0; i < input.Length; i++)
    {
        temp += input[i];
    }
    mittelwert = (temp / input.Length);
    return mittelwert;
}

C#-Code

static void Main(string[] args) {
            double[] a = new double[] {1, 3, 5};
            double[] b = new double[] {1, 3};
            Console.WriteLine(Mittelwert(a));
            Console.WriteLine(Mittelwert(b));
            Console.ReadLine();
}

static double Mittelwert(double[] a) {
            double sum = 0;
            for (int i = 0; i<a.Length; i++) {
                sum += a[i];
            }
            double b = sum / a.Length;
            return b;
        }

C#-Code

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

namespace Uebungen
{
    class Program
    {
        static void Main(string[] args)
        {
            List<double> liste = new List<double>();
            double value;
            bool isNotFinished = true;

            Console.WriteLine("Geben Sie Werte ein, aus denen der Mittelwert berechnet werden soll.");

            while (isNotFinished)
            {
                Console.Write("Geben Sie einen Wert ein: ");
                string input = Console.ReadLine();
                isNotFinished = Double.TryParse(input, out value);
                if (isNotFinished)
                {
                    liste.Add(value);
                }
            }

            Console.WriteLine(liste.Average());
            Console.ReadKey();
        }
    }
}

C#-Code

using System;

namespace TrainYourProgrammer
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] arr1 = new double[] { 3.14, 15.9, 26.53, 58.979, 32.3, 84.6 };
            double[] arr2 = new double[] { 2.71, 8.28, 182.84, 590.45 };

            Console.WriteLine("Mittelwert von arr1: " + Average(arr1));
            Console.WriteLine("Mittelwert von arr2: " + Average(arr2));

            Console.WriteLine("Drücken Sie eine beliebige Tasten zum Beenden.");
            Console.ReadKey();
        }

        static double Average(double[] arr)
        {
            double sum = 0;
            foreach(double number in arr)
            {
                sum += number;
            }
            return sum / arr.Length;
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[] { 1,2,3,4,5,6,7,8,9,10};
            int[] arr1 = new int[] { 10,20,30,40,50,60,70,80,90,100,110};

            Console.WriteLine(avg(arr));
            Console.WriteLine(avg(arr1));

            Console.Read();
        }

        static double avg(int[] arr)
        {
            double val = 0.0;
            foreach(var i in arr)
            {
                val += i;
            }
            return val / arr.Length;
        }
    }

    

}

C#-Code

using System;

namespace PrivateÜbungKonsole
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] feld = {2, 2.5, 3, 3.5, 4};
            Console.WriteLine("Mittelwert: " + Mittelwert(feld));
        }

        static public double Mittelwert(double[] feld)
        {
            double summe = 0;
            for (int i = 0; i < feld.Length; i++)
                summe += feld[i];
            return summe/feld.Length;
        }
    }
}

C#-Code

namespace _2_Methode_Mittelwert
{
    public class Average
    {
        public double Calculation(double[] numbers)
        {
            double average = 0;
            int i;

            for (i = 0; i < numbers.Length; i++)
            {
                average += numbers[i];
            }

            if (i == numbers.Length)
            {
                average = average / i;
            }

            return average;
        }

    }
}

C#-Code

    class Program
    {
        static void Main(string[] args)
        {
            double[] Array1 = new double[] { 1, 3.2, 4.5, 8.2 };
            double[] Array2 = new double[] { 4.5, 8.2 };
            Average foo = new Average();

            Console.WriteLine("Test 1: " + foo.Calculation(Array1));
            Console.WriteLine("Test 2: " + foo.Calculation(Array2));
            Console.ReadKey();
        }
    }

C#-Code

       static void Main(string[] args)
        {            

            double[] mittelwertZahlen;
            double ergebnis1 = Mittelwert(mittelwertZahlen = new double[50]);
            double ergebnis2 = Mittelwert(mittelwertZahlen = new double[100]);
            Console.WriteLine($"Wert1: {ergebnis1}\nWert2: {ergebnis2}");

            Console.ReadKey();

        }

       static double Mittelwert(double[] mittelwertZahlen)
        {
            //anfüllen der arrays
            for (int e = 0; e <= mittelwertZahlen.Length-1; e++)
            {
                Random randomzahl = new Random();
                randomzahl.Next(-200, 9999999);
                for (int s = 0; s < mittelwertZahlen.Length; s++)
                {
                    if (mittelwertZahlen[e] != randomzahl.NextDouble())
                    {
                        mittelwertZahlen[e] = e + 12 * 10 * randomzahl.NextDouble();
                    }
                }
            }
            double ergebnis = 0;
                for (int i = 0; i <= mittelwertZahlen.Length-1; i++)
            {
                ergebnis = ergebnis + mittelwertZahlen[i];
            }
            double mittel = ergebnis / mittelwertZahlen.Length;
                return mittel;
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Uebung2_MittelwertBerechnen
{
    class Program
    {
        static void Main(string[] args)
        {
            string input1;
            string input2;
            double Number1;
            double Number2;
            bool result1 = false;
            bool result2 = false;

            while(result1 == false)
            {
                Console.WriteLine("Geben Sie die erste Zahl ein:");
                input1 = Console.ReadLine();

                if(Double.TryParse(input1, out Number1))
                {
                    result1 = true;
                        while(result2 == false)
                    {
                        Console.WriteLine("Geben Sie die zweite Zahl ein:");
                        input2 = Console.ReadLine();
                        
                        if(Double.TryParse(input2, out Number2))
                        {
                            result2 = true;
                            double Mittelwert;
                            Mittelwert = (Number1 + Number2) / 2;
                            Console.WriteLine("Der Mittelwert der beiden Zahlen ist: " + Mittelwert);
                            Console.ReadLine();
                        }                       
                    }
                }                
            }
        }
    }
}

C#-Code

        private static double mittelwertBerechnen (double[] db)
        {
            return db.Sum() / db.Length;
        }

C#-Code

        public static void GetMiddle(double[] numbers)
        {
            double result = 0;
            foreach (double n in numbers)
            {
                result += n;
            }

            Console.WriteLine($"{result / numbers.Length}");
            Console.Read();
        }

C#-Code

        static void Main(string[] args) {

            Console.WriteLine("Durchschnitt: " + MittelwertBerechnen(1.5, 4.5, 6.7, 14.45));
            Console.WriteLine("Durchschnitt: " + MittelwertBerechnen(5.6, 2.3, 78.45, 13.23, 154.23, 34.78, 12.09));

            Console.ReadLine();
        }

        
        private static double MittelwertBerechnen(params double[] values)
        {
            double sum = 0.0;

            for(int i = 0; i < values.Length; i++)
            {
                sum += values[i];
            }
            return sum / values.Length;
        }

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TrainYourProgrammer2
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] zahlen = new double[] { 5.6, 7.4, 6.9, 0.1, 120.0 };
            double wert = 0;

            for(int i = 0; i <= zahlen.Length - 1; i++)
            {
                wert += zahlen[i];
            }

            wert = wert / zahlen.Length - 1;
            Console.WriteLine(wert);

            Console.ReadLine();
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TrainYourProgrammer2
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] feld1 = new double[] { 1.5, 1.8, 5.9, 13 };
            double[] feld2 = new double[] { 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9 };
            Console.WriteLine(Mittelwert(feld1));
            Console.WriteLine(Mittelwert(feld2));
            Console.ReadLine();
        }

        static double Mittelwert(double[] array)
        {
            double rückgabe;
            double summe = 0;
            for (int i = 0; i < array.Length; i++)
            {
                summe += Convert.ToDouble(array[i]);
            }
            rückgabe = summe / array.Length;
            return rückgabe;
        }
    }
}

C#-Code

using System;
using System.Linq;

namespace Methode_Mittelwert {
    class Program {
        static void Main(string[] args) {
            double[] d = new double[10] { 1.0, 5.0, 64.0, 6465.6, 64646.666, 123.456, 789.123, 456.789, 321.654, 987.321 };
            Console.WriteLine("Mittelwert von folgenden Zahlen");
            foreach(var item in d) {
                Console.WriteLine(item);
            }
            Console.WriteLine("Mittelwert: " + GetAverage(d));
            d = new double[5] { 1.2, 3.4, 5.6, 7.8, 9.1 };
            Console.WriteLine("\nMittelwert von folgenden Zahlen");
            foreach(var item in d) {
                Console.WriteLine(item);
            }
            Console.WriteLine("Mittelwert: " + GetAverage(d));
            Console.ReadLine();
        }

        static double GetAverage(double[] d) {
            return d.Average();
        }
    }
}

C#-Code

static double Mittelwert(double[] zahlen)
        {
            double sum = 0;

            foreach (double zahl in zahlen)
                sum += zahl;

            return sum / zahlen.Length;
        }

C#-Code

static double mittelWert(double[] array)
        {
            double wert = 0.0f;

            for(int i = 0; i < array.Length; i++)
            {
                wert += array[i];
            }
            return wert / array.Length;
        }

         static void Main(string[] args)
        {
            double[] a = new double[] { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0 };
            double[] b = new double[] { 25, 14.7, 4, 7.5, 3.3 };
            
            Console.WriteLine("Der Mittelwert beträgt: " + mittelWert(a));
            Console.WriteLine("Der Mittelwert beträgt: " + mittelWert(b));
            Console.ReadKey();
        }

C#-Code

using System;

public class Class1
{

    public static void Main(String[] args)
    {
        int ammount;
        double summe = 0;
        int anzahl = 0;

        Console.Write("Bitte Anzahl der Werte eingeben:  ");
        ammount = Convert.ToInt32(Console.ReadLine());

        while ( 1 == 1 )
        {
            anzahl += 1;
            Console.Write("write " + anzahl + " number : ");
            summe += Convert.ToDouble(Console.ReadLine());
            if (anzahl == ammount)
            {
                Console.WriteLine("Result :" + (summe / ammount));
                break;
            }

        }

    }
}

C#-Code

using System;
using System.Linq;

namespace mittelwert_2
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] values1 = new double[5] { 0.5, 1.0, 1.25, 5.789, 321.123 };
            double[] values2 = new double[10] { 0.5, 1.0, 1.25, 5.789, 321.123, 9.99, 2.75, -0.5, 0.66, 7.89 };

            Console.WriteLine("Mittelwert: {0:f2}", Program.calcAverage(values1));
            Console.WriteLine("Mittelwert: {0:f2}", Program.calcAverage(values2));

            Console.ReadLine();
        }

        private static double calcAverage(double[] values)
        {
            return values.Sum() / values.Length;
        }
    }
}

C#-Code

namespace Average
{
    class Program
    {
        static void Main(string[] args)
        {
            char choose;
            Console.Write("Do you want to input numbers yourself <y> for yes <n> for no: ");
            choose = Convert.ToChar(Console.ReadLine());
            switch (choose)
            {
                case 'y':
                    UserInputValues();
                    break;
                case 'n':
                    SystemValues();
                    break;
            }
            Console.ReadLine();
        }

        private static double Mittelwert(double[] array)
        {
            double value=0;

            for(int i=0; i<array.Length; i++)
            {
                value = value + array[i];
            }
            value /= array.Length;

            return value;
        }

        private static void UserInputValues()
        {
            bool inputIsValid = false;
            int amount;

            Console.Write("Please enter the amount of numbers you want to create: ");

            try
            {
                while (!inputIsValid)
                {
                    amount = Convert.ToInt32(Console.ReadLine());
                    double[] numbers = new double[amount];
                    for (int i = 0; i <= amount; i++)
                    {
                        if (i == 0)
                        {
                            Console.Write("Please enter a number: ");
                            numbers[i] = Convert.ToDouble(Console.ReadLine());
                        }
                        else if (i < amount)
                        {
                            Console.Write("Please enter another number: ");
                            numbers[i] = Convert.ToDouble(Console.ReadLine());
                        }
                        else if (i == amount)
                        {
                            Console.WriteLine("Mittelwert: " + Mittelwert(numbers));
                            inputIsValid = true;
                        }
                    }
                }
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
                inputIsValid = true;
            }
        }

        private static void SystemValues()
        {
            double[] list1 = { 1, 9, 40, 3, 6, 8, 5, 4 }; // 9.5
            double[] list2 = { 3, 9, 6, 4, 20, 3 }; // 7.5

            Console.WriteLine("Mittelwert: " + Mittelwert(list1));
            Console.WriteLine("Mittelwert: " + Mittelwert(list2));
        }
    }
}

C#-Code

using System;

namespace C_Sharp_Lernen
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Wieviele Werte enthält ihre Liste?");
            int USER_INPUT = Convert.ToInt32(Console.ReadLine());
            double TEMP_WERT = 0;
            double[] USER_LIST = new double[USER_INPUT];   
            for(int i = 0;i<USER_INPUT;i++)
            {
                Console.Write(i+1 + ". ");
                USER_LIST[i] = Convert.ToInt32(Console.ReadLine());
            }

            foreach(double d in USER_LIST)
            {
                TEMP_WERT += d;
            }
            Console.WriteLine("Der Mittelwert beträgt: " + TEMP_WERT/USER_INPUT);
            Console.Read();
        }
    }
}

C#-Code

class Methode_Zum_Ermittelen_Des_Mittelwertes
    {
        static void Main(string[] args)
        {
            double[] MyArray = { 2.23, 3.56, 8.56, 8.98, 78.98, 56.8 };

            double mittelwert = ermittleMittelwert(MyArray);

            Console.WriteLine($"Der Mittelwert des Arrays beträgt: {mittelwert}");
            Console.ReadLine();
        }

        static double ermittleMittelwert(double[] array)
        {
            double result = 0.00;

            foreach(double z in array)
            {
                result += z;
            }

            return result / array.Length;
        }
    }

C#-Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TYP_Aufgabe_2
{
    class Program
    {        
        static double[] Werte1 = new double[4] {2.6,7.6,9.4,10.2 };
        static double[] Werte2 = new double[6] {3.9,4.7,1.2,3.8,4.9,5.7 };

        static void Main(string[] args)
        {
            for (int i = 0; i < 2; i++)
            {
                if (i == 1)
                {
                    Console.WriteLine("Der Mittelwert des {0}. Arrays beträgt {1}!", i + 1, MittelWertErrechnen(Werte1));                    
                }
                else
                {
                    Console.WriteLine("Der Mittelwert des {0}. Arrays beträgt {1}!", i + 1, MittelWertErrechnen(Werte2));
                }
                
            }
            Console.ReadKey();            
        }

        static double MittelWertErrechnen(double[] TestDouble)
        {
            double Summe = 0;
            double MittelWert=0;
            for (int i = 0; i < TestDouble.Length; i++)
            {
                Summe += TestDouble[i];
            }
            MittelWert = Summe / TestDouble.Length;
            return MittelWert;
        }
    }
}

C#-Code

using System;
using System.Linq;

namespace Mittelwert
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] werte = new double[] { 3.5, 7.5, 3 };
            double mittelwert = Average(werte);

            Console.WriteLine(mittelwert);
            Console.ReadLine();
        }

        private static double Average(double[] values)
        {
            double summe = 0;
            foreach (double item in values)
            {
                summe += item;
            }
            return summe / values.Length;
        }
    }
}

C#-Code

class Program
    {
        static double sum;
        static void Main(string[] args)
        {
            double[] input = { 4, 7.5, 6.6, 75 };   //Hier werden beliebig viele double Werte eingefügt
            double mw = Average(input);
            Console.WriteLine(mw);
            Console.ReadKey();
           
        }
        static double Average(double[] arr)
        {
            foreach(double d in arr)
            {
                sum += d;   //Alle Werte werden zusammengerechnet
            }
            return sum / arr.Length;   //Und danach wird der Mittelwert zuückgegeben
        }
    }

C#-Code

using System;
using System.Linq;

namespace ArrayAverage
{
    class Program
    {
        static void Main(string[] args)
        {
            double[] myArray = new double[3] { 2.1, 3.45, 0.1337 };
            double[] myArray1 = new double[7] { 0.55, 4.21, 3.12, 6.66, 8.05, 9.43, 42.11 };

            Console.WriteLine($"Mittelwert von myArray: {Average(myArray)}" +
                $"\nMittelwert von myArray: {Average(myArray1)}");

            Console.ReadLine();
        }

        static double Average(double[] arrays)
        {
            return arrays.Sum() / arrays.Length;
        }
    }
}