Egyetemi feladatok - rootsite.hu

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

namespace Feladatok
{
    /*
    Coded by Metts - rootsite.hu
FELADAT:
      A feladatokban mindenütt egész (esetleg valós) elemű tömbökkel dolgozunk, ne bonyolítsuk a kezdést a sztringkezeléssel is!
Ahol nem jeleztük, ott oldja meg a feladatot úgy (is), hogy a tevékenységet egy függvény végezze el!
Fordítva, amíg nem ismerjük a függvényeket, addig oldjuk meg a feladatot anélkül (pl. tömb maximális eleme)!

Írassa ki a számok összegét 1-től n-ig, ahol n=1..20! Végezze el a feladatot egymásba ágyazott ciklusokkal és összegző segédfüggvénnyel is!
Írassa ki n! értékét 1-től n-ig, ahol n=1..20. Végezze el a feladatot egymásba ágyazott ciklusokkal és faktoriális segédfüggvénnyel is!
Írjon egy-egy függvényt, amely három egész paramétert kap, és visszaadja az összeget/szorzatot/átlagot/minimumot/maximumot!
Számolja össze, hogy egy adott tömbben hány adott tulajdonságú elem van (pl. pozitív, páros, pozitív páros)!
Döntse el, hogy egy adott tömbben van-e adott tulajdonságú elem!
Ellenőrizze, hogy egy adott tömbben minden elem adott tulajdonságú-e!
Keresse meg egy tömben a legkisebb/legnagyobb indexű, adott tulajdonságú elemet! Adja meg ennek az indexét!
Valósítsa meg az előző feladatokat egy függvény segítségével!
Írjon egy-egy olyan függvényt, amely visszaadja a paraméterül kapott tömb elemeinek összegét/szorzatát/átlagát/pozitív elemeinek átlagát/átlag feletti elemek számát!
Tároljuk egy egész változóban a t tömbben lévő értékes elemek számát. Írjunk olyan függvényt, amely betesz egy adott értéket a tömbbe. Írjunk olyat is, amely kivesz egy adott indexű elemet, és a helyére rakja az utolsó értékes elemet!
Valósítsuk meg a lineáris keresést rendezetlen tömbben! Az első megfelelő elem indexét adja vissza a függvény!
Valósítsuk meg a lineáris keresést rendezett tömbben! Az első megfelelő elem indexét adja vissza a függvény!
Írjon egy olyan függvényt, amely visszadja egy tömb legnagyobb/legkisebb elemét!
Írjon egy olyan függvényt, amely visszadja egy tömb legnagyobb/legkisebb elemének indexét!
Írjon egy olyan függvényt, amely visszadja, hogy egy tömb legnagyobb/legkisebb elemétből hány darab van!
Valósítsa meg a bináris keresést!
Valósítsa meg az egész tömbök rendezését kiválasztásos rendezéssel!
Írjon egy olyan függvényt, amely visszaadja egy tömb másolatát! Tesztelje, hogy a visszaadott érték tényleg másolat!
Döntse el egy függvény, hogy egy adott tömb elemeinek halmaza részhalmaza-e egy másik tömb elemeiének!

     */
    class Program
    {
        static void Main(string[] args)
        {
            #region Tomb feltoltés (nem feladat)
                int[] tomb = new int[21];
                for (int i = 0; i < tomb.Length; i++)
                {
                    tomb[i] = i;
                }

                int[] szamok = new int[3];
                szamok[0] = 10;  //10
                szamok[1] = 20;  // 13
                szamok[2] = 5; // 5
            #endregion

            #region 1.Feladat Írassa ki a számok összegét 1-től n-ig, ahol n=1..20!
                // Végezze el a feladatot egymásba ágyazott ciklusokkal és összegző segédfüggvénnyel is!
                int osszeg = 0;
                for (int i = 1; i < tomb.Length; i++)
                {
                    osszeg = osszeg + i;
                }
                Console.WriteLine("\n1.Feladat (ciklussal): \n Az összeg: "+osszeg);
            #endregion

                #region 2.Feladat Írassa ki n! értékét 1-től n-ig, ahol n=1..20.
                // Végezze el a feladatot egymásba ágyazott ciklusokkal és faktoriális segédfüggvénnyel is!
                Console.WriteLine("\n2.Feladat:");
                Console.Write(" ");
                for (int i = 1; i < tomb.Length; i++)
                {
                    Console.Write(tomb[i] + ",");
                }
            #endregion

            #region 3.Feladat Írjon egy-egy függvényt, amely három egész paramétert kap,
                // és visszaadja az összeget/szorzatot/átlagot/minimumot/maximumot!
                Console.WriteLine("\n\n3.Feladat: ");
                Console.WriteLine(" Összeg : {0}", function_osszeg(szamok));
                Console.WriteLine(" Szorzat: {0}", function_szorzat(szamok));
                Console.WriteLine(" Átlag  : {0}", function_atlag(szamok));
                Console.WriteLine(" Minimum: {0}", function_minimum(szamok));
                Console.WriteLine(" Maximum: {0}", function_maximum(szamok));
            #endregion

            #region 4.Feladat   Számolja össze, hogy egy adott tömbben hány adott tulajdonságú elem van (pl. pozitív, páros, pozitív páros)!
                Console.WriteLine("\n4.Feladat: ");
                function_elemek_szama(szamok);
            #endregion

            #region 5.Feladat  Döntse el, hogy egy adott tömbben van-e adott tulajdonságú elem!
                Console.WriteLine("\n5.Feladat: ");
                int elem = 10;
                if(function_van_e_elem(szamok, elem))
                    Console.WriteLine(" Van benne: {0}", elem);
                else
                    Console.WriteLine(" Nincs benne");
            #endregion

            #region 6.Feladat  Ellenőrizze, hogy egy adott tömbben minden elem adott tulajdonságú-e!
                Console.WriteLine("\n6.Feladat: ");
             //VICC FELADAT :P
            #endregion

            #region 7.Feladat  Keresse meg egy tömben a legkisebb/legnagyobb indexű, adott tulajdonságú elemet! Adja meg ennek az indexét!
                Console.WriteLine("\n7.Feladat: ");
                int min_index = 0;
                int max_index = 0;
                int min = szamok[0];
                int max = szamok[0];
                for (int i = 0; i < szamok.Length; i++)
                {
                    if (min > szamok[i])
                    {
                        min = szamok[i];
                        min_index = i;
                    }

                    if (max < szamok[i])
                    {
                        max = szamok[i];
                        max_index = i;
                    }
                }

                Console.WriteLine(" Legkisebb index: {0}\n Legnagyobb index: {1}", min_index, max_index);
            #endregion

            #region 8.Feladat  Függvénnyel
                Console.WriteLine("\n8.Feladat függvénnyel: ");
                function_min_max_elem(szamok);
            #endregion
            Console.Read();
        }

        static void function_min_max_elem(int[] szamok)
        {
            int min_index = 0;
            int max_index = 0;
            int min = szamok[0];
            int max = szamok[0];
            for (int i = 0; i < szamok.Length; i++)
            {
                if (min > szamok[i])
                {
                    min = szamok[i];
                    min_index = i;
                }

                if (max < szamok[i])
                {
                    max = szamok[i];
                    max_index = i;
                }
            }

            Console.WriteLine(" Legkisebb index: {0}\n Legnagyobb index: {1}", min_index, max_index);
        }

        static bool function_van_e_elem(int[] tomb, int elem)
        {
            for (int i = 0; i < tomb.Length; i++)
            {
                if (tomb[i] == elem)
                    return true;
                else
                    return false;
            }

            return false;
        }

        static void function_elemek_szama(int[] tomb)
        {
            int pozitivok = 0;
            int pozitiv_parosok = 0;
            int parosok = 0;
            for (int i = 0; i < tomb.Length; i++)
            {
                if (tomb[i] > 0)
                {
                    if (tomb[i] % 2 == 0)
                        pozitiv_parosok++;
                    else
                        pozitivok++;
                }

                if (tomb[i] % 2 == 0)
                    parosok++;
            }

            Console.WriteLine(" Pozitívok        : " + pozitivok);
            Console.WriteLine(" Párosok          : " + parosok);
            Console.WriteLine(" Pozitívok Párosok: " + pozitiv_parosok);
        }

        static int function_osszeg(int[] tomb)
        {
            int eredmeny = 0;
            for (int i = 0; i < tomb.Length; i++)
            {
                eredmeny = eredmeny + tomb[i];
            }
            return eredmeny;
        }

        static int function_szorzat(int[] tomb)
        {
            int eredmeny = 1;
            for (int i = 0; i < tomb.Length; i++)
            {
                eredmeny = eredmeny * tomb[i];
            }
            return eredmeny;
        }

        static double function_atlag(int[] tomb)
        {
            double eredmeny = 0;
            for (int i = 0; i < tomb.Length; i++)
            {
                eredmeny = eredmeny + tomb[i];
            }
            return eredmeny / tomb.Length;
        }

        static int function_minimum(int[] tomb)
        {
            int min = tomb[0];
            for (int i = 0; i < tomb.Length; i++)
            {
                if (min > tomb[i])
                {
                    min = tomb[i];
                }
            }
            return min;
        }

        static int function_maximum(int[] tomb)
        {
            int max = tomb[0];
            for (int i = 0; i < tomb.Length; i++)
            {
                if (max < tomb[i])
                {
                    max = tomb[i];
                }
            }
            return max;
        }
    }
}