Jednorozměrné pole - konzole

Následující zdrojový kód je kompletací předešlých kódů programu JednorozmernePole, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace JednorozmernePole
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Deklarace: 'pocetPrvku' ... rozměr vektoru (počet prvků ve vektoru); 'Max' ... konstantní hodnota 
             * maximální velikosti vektoru; 'minHodnota' ... přípustná minimální hodnota (dolní mez) prvků vektoru; 
             * 'maxHodnota' ... přípustná maximální hodnota (horní mez) prvků vektoru */
 
            // Maximální rozměr vektoru
            const int Max = 10;
 
            // Dolní mez, které může nabýt prvek vektoru
            int minHodnota = 1;
 
            // Horní mez, které může nabýt prvek vektoru
            int maxHodnota = 100;
 
            // Rozměr vektoru je roven maximální možné délce
            int pocetPrvku = Max;
 
            // Zavolání metody s celočíselným návratem pro změnu velikosti vektoru
            pocetPrvku = RozmerPole(pocetPrvku, Max);
 
            // Deklarace vektoru se zadaným rozměrem (počtem prvků)
            int[] pole = new int[pocetPrvku];
 
            // Zavolání metody s celočíselný návratem pro změnu dolní meze, které mohou nabývat prvky vektoru
            minHodnota = DolniMez(minHodnota, maxHodnota);
 
            // Zavolání metody s celočíselným návratem pro změnu horní meze, které mohou nabývat prvky vektoru
            maxHodnota = HorniMez(minHodnota, maxHodnota);
 
            /* Zavolání metody pro plnění vektoru (náhodnými čísly, jednotlivě zadanými hodnotami, 
             * plnění vektoru nulami) */
            PlnitPole(pocetPrvku, minHodnota, maxHodnota, pole);
 
            // Výpis prvků vektoru v řádku, kde jednotlivé prvky jsou odděleny čárkami
            Console.WriteLine("Výpis pole (do řádku): " + PoleJakoText(pocetPrvku, pole));
 
            // Výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce
            Console.WriteLine("Výpis pole (do sloupce): ");
            Console.Write(ZobrazitPole(pocetPrvku, pole));
 
            // Výpis hodnoty minima vektoru, včetně jeho indexu
            Console.WriteLine("Minimum v poli: " + MinimumVPoli(pocetPrvku, pole) + 
                " (index prvku: " + IndexPrvku(MinimumVPoli(pocetPrvku, pole), pole) + ")");
 
            // Výpis hodnoty maxima vektoru, včetně jeho indexu
            Console.WriteLine("Maximum v poli: " + MaximumVPoli(pocetPrvku, pole) + 
                " (index prvku: " + IndexPrvku(MaximumVPoli(pocetPrvku, pole), pole) + ")");
 
            // Výpis průměru všech prvků vektoru
            Console.WriteLine("Průměr prvků pole: " + PrumerPole(pocetPrvku, pole));
 
            // Vzestupné řazení prvků podle metody Bubble Sort
            SeraditPole(pocetPrvku, pole);
 
            // Výpis seřazeného vektoru do řádku
            Console.WriteLine("Seřazené pole (výpis do řádku): " + PoleJakoText(pocetPrvku, pole));
 
            // Výpis seřazeného vektoru do sloupce
            Console.WriteLine("Seřazené pole (výpis do sloupce): ");
            Console.Write(ZobrazitPole(pocetPrvku, pole));
 
            // Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
        #region Nastavení atributů pole
 
        /// <summary>
        /// Metoda s celočíselným návratem - navrací velikost pole (počet prvků vektoru)
        /// </summary>
        /// <param name="n"> aktuální velikost vektoru (počet prvků) </param>
        /// <param name="max"> maximální rozměr vektoru </param>
        /// <returns> Velikost vektoru </returns>
        static int RozmerPole(int n, int max)
        {
            /* Deklarace: 'zmena' ... informace (celé číslo), zda má být provedena změna rozměru 
             * pole; 'novaHodnota' ... nový rozměr vektoru */
            int zmena, novaHodnota;
 
            // Vypsání stávajícího rozměru vektoru
            Console.WriteLine("Počet prvků: {0}", n);
            do
            {
                // Výzva ke změně rozměru vektoru
                Console.Write("Změnit počet prvků vektoru (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty, zda má dojít ke změně
                int.TryParse(Console.ReadLine(), out zmena);
 
                // Pokud načtená hodnota nebyla validní, cyklus zadání je znovu opakován
            }
            while ((zmena < 0) || (zmena > 1));
 
            // Pokud byl zadán index pro změnu ...
            if (zmena == 1)
            {
                // Výzva k zadání rozměru vektoru
                Console.Write("Zadejte počet prvků vektoru (1 - {0}): ", max);
 
                // Načtení rozměru vektoru
                int.TryParse(Console.ReadLine(), out novaHodnota);
 
                // Pokud nová hodnota je větší než maximum, nebo menší než 1 ...
                if ((novaHodnota > max) || (novaHodnota < 1))
                {
                    // Přiřazení maximálního rozměru vektoru do lokální proměnné určující počet prvků vektoru
                    novaHodnota = max;
                }
 
                // Pokud nový rozměr vektoru není stejný jako stávající počet prvků vektoru ...
                if (novaHodnota != n)
                {
                    // Uložení nového rozměru pole do proměnné
                    n = novaHodnota;
                }
 
                // Výpis nového zadaného rozměru vektoru
                Console.WriteLine("Rozměr pole: {0}", n);
            }
 
            // Návrat metody
            return n;
        }
 
        /// <summary>
        /// Metoda s celočíselným návratem - návrat dolní meze pro všechny prvky vektoru
        /// </summary>
        /// <param name="minHodnota"> dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <returns> Dolní mez pro všechny prvky vektoru </returns>
        public static int DolniMez(int minHodnota, int maxHodnota)
        {
            /* Deklarace: 'novaHodnota' ... nová dolní mez prvků vektoru; 'zmena' ... celočíselná 
             * informace, zda má být provedena změna dolní meze prvků ('0'...Ne, '1'...Ano) */
            int novaHodnota, zmena;
 
            // Výpis stávající hodnoty dolní meze
            Console.WriteLine("Dolní mez prvků vektoru: {0}", minHodnota);
            do
            {
                // Výzva ke změně dolní meze
                Console.Write("Změnit dolní mez prvků vektoru (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty do proměnné 'zmena' (informace, zda má dojít ke změně)
                int.TryParse(Console.ReadLine(), out zmena);
 
                // Pokud načtená hodnota není validní, cyklus zadání probíhá znovu
            }
            while (zmena < 0 || zmena > 1);
 
            // Test, zda má proběhnout změna dolní meze prvků vektoru
            if (zmena == 1)
            {
                // Výzva k zadání nové dolní meze prvků vektoru
                Console.Write("Zadejte dolní mez prvků vektoru: ");
 
                // Načtení nové dolní meze prvků vektoru
                int.TryParse(Console.ReadLine(), out novaHodnota);
 
                // Pokud nová hodnota dolní meze je větší než horní mez ...
                if (novaHodnota > maxHodnota)
                {
                    // Přiřazení horní meze do lokální proměnné určující dolní mez (horní a dolní mez budou stejné)
                    novaHodnota = maxHodnota;
                }
 
                // Pokud nová dolní mez vektoru není stejná jako stávající dolní mez prvků vektoru ...
                if (novaHodnota != minHodnota)
                {
                    // Přepsání stávající dolní meze prvků pole novou hodnotou
                    minHodnota = novaHodnota;
                }
 
                // Výpis nové dolní meze pro prvky vektoru
                Console.WriteLine("Dolní mez prvků vektoru: " + minHodnota);
            }
 
            // Návrat metody
            return minHodnota;
        }
 
        /// <summary>
        /// Metoda s celočíselným návratem - návrat horní meze pro všechny prvky vektoru
        /// </summary>
        /// <param name="minHodnota"> stávající horní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <returns> Horní mez pro všechny prvky vektoru </returns>
        static int HorniMez(int minHodnota, int maxHodnota)
        {
            /* Deklarace: 'novaHodnota' ... nová horní mez prvků vektoru; 'zmena' ... celočíselná 
             * informace, zda má být provedena změna horní meze prvků ('0'...Ne, '1'...Ano) */
            int novaHodnota, zmena;
 
            // Výpis stávající hodnoty horní meze
            Console.WriteLine("Horní mez prvků vektoru: {0}", maxHodnota);
            do
            {
                // Výzva ke změně horní meze
                Console.Write("Změnit horní mez prvků vektoru (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty do proměnné 'zmena' (informace, zda má dojít ke změně)
                int.TryParse(Console.ReadLine(), out zmena);
            }
            // Pokud načtená hodnota není validní, cyklus zadání probíhá znovu
            while ((zmena < 0) || (zmena > 1));
 
            // Test, zda má proběhnout změna horní meze prvků vektoru
            if (zmena == 1)
            {
                // Výzva k zadání nové horní meze prvků vektoru
                Console.Write("Zadejte horní mez prvků vektoru: ");
 
                // Načtení nové horní meze prvků vektoru
                int.TryParse(Console.ReadLine(), out novaHodnota);
 
                // Pokud nová hodnota horní meze je menší než horní mez ...
                if (novaHodnota < minHodnota)
                {
                    // Přiřazení dolní meze do lokální proměnné určující horní mez (horní a dolní mez budou stejné)
                    novaHodnota = minHodnota;
                }
 
                // Pokud nová horní mez vektoru není stejná jako stávající horní mez prvků vektoru ...
                if (novaHodnota != maxHodnota)
                {
                    // Přepsání stávající horní meze prvků pole novou hodnotou
                    maxHodnota = novaHodnota;
                }
 
                // Výpis nové horní meze pro prvky vektoru
                Console.WriteLine("Horní mez prvků vektoru: " + maxHodnota);
            }
 
            // Návrat metody
            return maxHodnota;
        }
        #endregion
        
        #region Plnění pole
 
        /// <summary>
        /// Metoda bez návratu - výběr metody plnění vektoru
        /// </summary>
        /// <param name="n"> aktuální rozměr (počet prvků) vektoru </param>
        /// <param name="minHodnota"> dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void PlnitPole(int n, int minHodnota, int maxHodnota, int[] pole)
        {
            /* Deklarace: 'zpusobPlneni' ... způsob plnění vektoru('0'...Náhodně, '1'...Jednotlivě, 
             * '2'...Nulovat) */
            int zpusobPlneni;
 
            do
            {
                // Výzva k zadání způsobu plnění vektoru
                Console.Write("Zvolte způsob plnění vektoru (0...Náhodně, 1...Jednotlivě, 2...Nulovat): ");
 
                // Načtení způsobu plnění
                int.TryParse(Console.ReadLine(), out zpusobPlneni);
            }
 
            // Načtení způsobu plnění proběhne znovu, pokud nebyl zadán validní celočíselný kód způsobu plnění
            while ((zpusobPlneni != 0) && (zpusobPlneni != 1) && (zpusobPlneni != 2));
 
            switch (zpusobPlneni) 
            {
                // Plnění vektoru náhodnými čísly
                case 0:
                    // Zavolání procedury pro plnění vektoru náhodnými čísly
                    NahodnePole(n, minHodnota, maxHodnota, pole);
                    break;
 
                // Plnění vektoru jednotlivými zadanými hodnotami uživatelem
                case 1:
                    // Plnění vektoru jednotlivými uživatelem zadanými čísly
                    PlnitJednotlive(n, minHodnota, maxHodnota, pole);
                    break;
 
                case 2:
                    // Všem prvkům vektoru přiřadíme hodnotu '0'
                    NulovatPole(n, pole);
                    break;
            }
        }
 
 
        /// <summary>
        /// Metoda bez návratu - plnění prvků pole hodnotou nula
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void NulovatPole(int n, int[] pole)
        {
            /* Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku;
             * 'i' ... index (pozice) prvku vektoru */
            for (int i = 0; i < n; i++)
            {
                // Přiřazení nuly 'i'-tému (aktuálně procházenému) prvku
                pole[i] = 0;
            }
        }
 
        /// <summary>
        /// Metoda bez návratu - plnění vektoru náhodnými čísly
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="minHodnota"> dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void NahodnePole(int n, int minHodnota, int maxHodnota, int[] pole)
        {
            /* Deklarace: 'rnd' ... náhodné číslo (generované na základě rovnoměrného rozdělení); 
             * 'i' ... index (pozice) prvku vektoru */
 
            // Deklarace náhodného čísla (objektu) včetně inicializace
            Random rnd = new Random();
 
            // Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku
            for (int i = 0; i < n; i++)
            {
                /* Vygenerování náhodného čísla uloženého do 'rnd' v rozsahu 'minHodnota' až 'maxHodnota'
                 * Přiřazení náhodného čísla do 'i'-tého prvku */
                pole[i] = rnd.Next(minHodnota, maxHodnota + 1);
            }
        }
 
        /// <summary>
        /// Metoda bez návratu - plnění jednotlivých prvků vektoru uživatelem
        /// </summary>
        /// <param name="n"> počet prvků </param>
        /// <param name="minHodnota"> stávající dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> stávající horní mez prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void PlnitJednotlive(int n, int minHodnota, int maxHodnota, int[] pole)
        {
            /* Deklarace: 'index' ... index prvku, který má být naplněn; 'hodnota' ... hodnota 
             * prvku, který má být naplněn; 'plnit' ... informace, zda má zadán (naplněn) 
             * další prvek ('0'...Ano, '1'...Ne) */
            int index, hodnota, plnit;
 
            // Cyklus s podmínkou na konci pro plnění prvků
            do
            {
                // Cyklus s podmínkou na konci pro načtení indexu plněného prvku 
                do
                {
                    // Výzva k zadání indexu prvku, včetně vypsání mezí
                    Console.Write("Zadejte index prvku, který chcete naplnit (0 - {0}): ", 
                        pole.Length-1);
 
                    // Načtení indexu
                    int.TryParse(Console.ReadLine(), out index);
 
                    // Test, zda načtený index je mimo meze ...
                    if ((index < 0) || (index > n-1))
                    {
                        // Výpis o chybě
                        Console.WriteLine("Zadaná hodnota je mimo meze");
                    }
                }
                /* Podmínka cyklu, zda načtený index je mimo meze. Pokud ano, opakovaní 
                 * načtení indexu */
                while ((index < 0) || (index > n-1));
 
                // Cyklus s podmínkou na konci - validace zadané hodnoty zda je hodnota v rozsahu mezí 
                do
                {
                    // Výzva k zadání hodnoty prvku, včetně vypsání dolní a horní meze pro všechny prvky
                    Console.Write("Zadejte hodnotu prvku ({0} - {1}): ", minHodnota.ToString(), 
                        maxHodnota.ToString());
 
                    // Načtení hodnoty
                    int.TryParse(Console.ReadLine(), out hodnota);
 
                    // Test, zda načtená hodnota prvku je mimo meze ...
                    if ((hodnota < minHodnota) || (hodnota > maxHodnota))
                    {
                        // Výpis o chybě
                        Console.WriteLine("Zadaná hodnota je mimo meze");
                    }
                }
                /* Podmínka cyklu, zda načtená hodnota prvku je mimo meze. Pokud ano, opakovaní 
                 * načtení hodnoty */
                while ((hodnota < minHodnota) || (hodnota > maxHodnota));
 
                // Přiřazení hodnoty z lokální proměnné do prvku vektoru na pozici 'index'
                pole[index] = hodnota;
 
                // Zavolání metody pro zobrazení vektoru jako prvky v řádku oddělené čárkou
                Console.WriteLine(PoleJakoText(n, pole));
 
                // Zavolání metody pro zobrazení vektoru jako prvky pod sebou
                Console.WriteLine(ZobrazitPole(n, pole));
 
                // Cyklus s podmínkou na konci - validace informace o tom, zda dále plnit
                do
                {
                    // Výzva, zda mají být plněny další prvky
                    Console.Write("Chcete plnit další prvek (0...Ne, 1...Ano): ");
 
                    // Načtení informace o dalším plnění
                    int.TryParse(Console.ReadLine(), out plnit);
 
                    // Test, zda načtená hodnota (informace o plnění) je mimo meze ...
                    if ((plnit < 0) || (plnit > 1))
                    {
                        // Výpis chyby
                        Console.WriteLine("Zadaná hodnota je mimo meze");
                    }
                }
 
                /* Podmínka cyklu, zda načtená hodnota je mimo meze. Pokud ano, 
                 * opakovaní načtení hodnoty */
                while ((plnit < 0) || (plnit > 1));
            }
 
            /* Podmínka cyklu, zda má být provedeno další načtení prvku. Pokud ano (hodnota '1'), 
             * opakovaní načtení hodnoty */
            while (plnit == 1);
        }
 
        #endregion
 
        #region Zobrazení pole
 
        /// <summary>
        /// Výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> vypisovaný vektor </param>
        /// <returns> Text obsahující prvky ve sloupci </returns>
        static string ZobrazitPole(int n, int[] pole)
        {
            /* Deklarace: 'vystup' ... textový řetězec, kde jednotlivé prvky vektoru jsou 
             * umístěny pod sebou; 'i' ... index prvku ve vektoru */
            string vystup;
 
            // Inicializace - příprava textu  pro výpis v konzole
            vystup = "";
 
            // Pro všechny prvky od počátečního do koncového prvku ...
            for (int i = 0; i < n; i++)
            {
                /* Výpis prvku na novém řádku (návrat na počátek řádku ... znak na pozici '13' 
                 * nový řádek ... znak na pozici '10' v ASCII tabulce); 
                 * 0:D3 ... formátová specifikace, tj. 3 znaky (doplněno vedoucími nulami),
                 * nula znamená bez desetinných míst */
                vystup += string.Format("{0:D3}", pole[i]) + (char)13 + (char)10;
 
                /* Vložení nové řádky do výsledného textu pomocí řídící posloupnosti -
                 * \r ... návrat na počátek řádku; \n ... přechod na nový řádek */
                //vystup += string.Format("{0:D3}", pole[i]) + "\r\n";
 
                // Vložení nové řádky do výsledného textu
                //vystup += string.Format("{0:D3}", pole[i]) + Environment.NewLine;
            }
 
            // Přiřazení výstupního textu návratu metody
            return vystup;
        }
 
        /// <summary>
        /// Výpis prvků vektoru v řádku, kde jednotlivé prvky jsou odděleny čárkami
        /// </summary>
        /// <param name="n"> aktuální velikost (počet prvků) vektoru </param>
        /// <param name="pole"> vektor, který má být vypsán </param>
        /// <returns> Text obsahující prvky v řádku </returns>
        static string PoleJakoText(int n, int[] pole)
        {
            /* Deklarace: 'vystup' ... výstupní textový řetězec obsahující prvky vektoru 
             * oddělené čárkou; 'i' ... index prvku ve vektoru */
            string vystup;
 
            // Inicializace - příprava textu  pro výpis v konzole
            vystup = "";
 
            // Vypsání počátečního prvku do textového řetězce
            vystup += string.Format("{0:D3}", pole[0]);
 
            // Pro všechny prvky od druhého prvku (včetně) do posledního ...
            for (int i = 1; i < n; i++)
            {
                // Výpis prvku do řádku odděleného čárkou
                vystup += string.Format(", {0:D3}", pole[i]);
            }
 
            // Přiřazení textu návratu metody
            return vystup;
        }
 
        #endregion
 
        #region Výpočty s polem
 
        /// <summary>
        /// Návrat hodnoty minima vektoru - nejmenší prvek
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Minimum vektoru </returns>
        static int MinimumVPoli(int n, int[] pole)
        {
            // Deklarace: 'minimum' ... nalezená minimální hodnota ve vektoru; 'i' ... index (pozice) prvku vektoru
            int minimum;
 
            // Hodnotu prvního prvku prohlásíme minimem
            minimum = pole[0];
 
            // Pro všechny prvky od '1' (druhého prvku) do 'n-1'-tého (posledního) prvku
            for (int i = 1; i < n; i++)
            {
                // Pokud je aktuálně procházený prvek menší než minimum ...
                if (pole[i] < minimum)
                {
                    // Uložené aktuálního prvku do minima
                    minimum = pole[i];
                }
            }
 
            // Přiřazení minima návratu metody
            return minimum;
        }
 
        /// <summary>
        /// Návrat hodnoty maxima vektoru - největší prvek
        /// </summary>
        /// <param name="n"> počet prvků pole </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Maximum vektoru </returns>
        public static int MaximumVPoli(int n, int[] pole)
        {
            // Deklarace: 'maximum' ... nalezená maximální hodnota ve vektoru; 'i' ... index (pozice) prvku vektoru
            int maximum;
 
            // První prvek prohlásíme maximem
            maximum = pole[0];
 
            // Pro všechny prvky od '1' (druhého prvku) do 'n-1'-tého (posledního) prvku
            for (int i = 1; i < n; i++)
            {
                // Pokud je aktuálně procházený prvek větší než maximum ...
                if (pole[i] > maximum)
                {
                    // Uložené hodnoty nalezeného prvku do maxima
                    maximum = pole[i];
                }
            }
 
            // Přiřazení maxima návratu metody
            return maximum;
        }
 
        /// <summary>
        /// Metoda s návratem - návrat indexu hledaného prvku vektoru
        /// </summary>
        /// <param name="prvek"> prvek, jehož index má být vyhledán </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Návrat posledního indexu hledaného prvku (prvek nebyl nalezen návrat -1) </returns>
        static int IndexPrvku(int prvek, int[] pole)
        {
            // Deklarace: 'index' ... index nalezeného prvku ve vektoru; 'i' ... index (pozice) prvku vektoru
            int index;
 
            // Inicializace - žádný prvek nenalezen, tj. index = -1
            index = -1;
 
            /* Pro všechny prvky od počátečního prvku do posledního (index zjištěn pomocí návratu funkce 
             * rozměru pole) prvku */
            for (int i = 0; i < pole.Length; i++)
            {
                // Pokud je aktuálně procházený prvek shodný s předaným prvkem ...
                if (pole[i] == prvek)
                {
                    // Přiřazení indexu aktuálního prvku do indexu hledaného prvku 
                    index = i;
                }
            }
            // Přiřazení idnexu prvku do návratu metody
            return index;
        }
 
        /// <summary>
        /// Navrát aritmetického průměru prvků vektoru
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Průměr vektoru </returns>
        static double PrumerPole(int n, int[] pole)
        {
            /* Deklarace: 'prumer' ... průměrná reálná hodnota ze všech prvků vektoru; 
             * 'suma' ... suma hodnot všech prvků vektoru; 'i' ... index (pozice) 
             * prvku vektoru */
            double prumer;
            int suma;
 
            // Inicializace - suma prvků je 0
            suma = 0;
 
            // Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku
            for (int i = 0; i < n; i++)
            {
                // Přičtení dalšího prvku vektoru do sumy
                suma += pole[i];
            }
 
            // Výpočet průměru
            prumer = (double)suma / n;
 
            // Přiřazení vypočteného průměru návratu metody
            return prumer;
        }
 
        #endregion
 
        #region Úprava pole
 
        /// <summary>
        /// Metoda bez návratu - vzestupné řazení prvků pole
        /// </summary>
        /// <param name="n"> počet prvků </param>
        /// <param name="pole"> vektor, který má být setříděn vzestupně </param>
        static void SeraditPole(int n, int[] pole)
        {
            /* Deklarace: 'pom' ... pomocná proměnná pro dočasné uložení prvku; 'b' ... logická proměnná 
             * obsahující informaci, zda došlo k prohození některých sousedních prvků; 'i' ... index (pozice) 
             * prvku vektoru */
            int pom;
            bool b;
 
            do
            {
                // Nedošlo k prohození sousedních prvků
                b = false;
 
                // Pro všechny prvky od počátečního do předposledního prvku
                for (int i = 0; i < n - 1; i++)
                {
                    // Pokud je hodnota sousedícího prvku větší než hodnota aktuálně testovaného prvku
                    if (pole[i] > pole[i + 1])
                    {
                        // Ulož hodnotu aktuálního prvku do pomocné proměnné
                        pom = pole[i];
 
                        // Ulož hodnotu sousedícího prvku do aktuálního prvku
                        pole[i] = pole[i + 1];
 
                        // Ulož hodnotu z pomocné proměnné do sousedícího prvku
                        pole[i + 1] = pom;
 
                        // Došlo k prohození sousedních prvků
                        b = true;
                    }
                }
                
            }
 
            // Testování, zda došlo k prohození některých sousedních prvků
            while (b == true);
        }
 
        #endregion
    }
}

Kód 1: Program JednorozmernePole - deklarace hlavní statické metody Main včetně deklarací dalších metod