C# tömbök

A tömb az az adattípus, amikor egy adott típusú változóból egy sorozatot, vagy vektort, mátrixot készítünk. A tömb egy összetett homogén adatstruktúra, melynek tetszőleges, de előre meghatározott számú eleme van. Az elemek típusa azonos. A tömb lehet egy vagy többdimenziós, a dimenzió száma nem korlátozott. Az egydimenziós tömböket vektoroknak hívjuk.
Általános szintaxis: Típus[] tömbnév = new Típus[hossz];

public static void Main()
{
int[] szamok = new int[5] {1, 3, 6, 3, 2}; // létrehozunk egy tömböt és utána megadjuk az elemeit
int[] szamok2;
szamok2 = new int[] {3, 6, 1, 6, 8, 3}; // az elemek számából magától kiszámolja, hogy hány elemű...

string[] karakterLanc = new string[3] {"egy", "ketto", "harom"};

Console.WriteLine("A szamok tömb 5. elemének értéke: {0}", szamok[4]);
Console.WriteLine("A szamok2 tömb 3. elemének értéke: {0}", szamok2[2]);
// a tömbök indexelése 0-tól kezdődik, így a 4. indexű eleme a tömb 5. eleme

// ciklus, mely végig halad a tömb elemein
for( int i = 0; i < karakterLanc.Length; i++ ) Console.WriteLine(karakterLanc[i]);
Console.ReadKey();
}

public static void Main()

{

int[] szamok = new int[5] {1, 3, 6, 3, 2}; // létrehozunk egy tömböt és utána megadjuk az elemeit

int[] szamok2;

szamok2 = new int[] {3, 6, 1, 6, 8, 3}; // az elemek számából magától kiszámolja, hogy hány elemű...

string[] karakterLanc = new string[3] {"egy", "ketto", "harom"};

Console.WriteLine("A szamok tömb 5. elemének értéke: {0}", szamok[4]);

Console.WriteLine("A szamok2 tömb 3. elemének értéke: {0}", szamok2[2]);

// a tömbök indexelése 0-tól kezdődik, így a 4. indexű eleme a tömb 5. eleme

// ciklus, mely végig halad a tömb elemein

for( int i = 0; i < karakterLanc.Length; i++ ) Console.WriteLine(karakterLanc[i]);

Console.ReadKey();

}

A tömbök elemeinek sorszámozása 0-tól kezdődik, az utolsó elem száma pedig elemek száma-1.
Tehát a szamok tömb elemei: 0. elem az 5, az utolsó elem pedig a szamok[4] amelynek értéke 2
Fontos megjegyezni, hogy a tömb statikus. Ha egyszer beállítottuk a méretét, nem lehet megváltoztatni. Azt viszont gond nélkül megtehetjük, hogy újra lefoglaljuk neki a helyet, de ekkor a benne tárolt adatok elvesznek (kivéve ha lementettük őket).

Tömb elemeinek kiíratása:

For ciklussal:

for (int i=0; i<szamok.Length;i++)
{ 
Console.WriteLine("A szamok tömb{0}.-ik eleme: {1}", i, szamok[i]);
}

for (int i=0; i<szamok.Length;i++)

{

Console.WriteLine("A szamok tömb{0}.-ik eleme: {1}", i, szamok[i]);

}

Foreach ciklussal

foreach (int i in szamok)
{
Console.WriteLine("A szamok tömb elemei: {0}", i);
}

foreach (int i in szamok)

{

Console.WriteLine("A szamok tömb elemei: {0}", i);

}

Példa 1

Nézzünk egy példa tömböt. Töltsünk fel egy 10 elemű tömböt 0-100 közötti véletlen számokkal! Rendezzük növekvő sorrendbe!
A tömb elemeinek növekvő sorba rendezése az Array.Sort(tömbneve) metódussal történeik. Ha szeretnénk fordított sorrendben kiíratni őket, akkor elöször rendezzük növekvőbe, majd az Array.Reverse(tömbneve) metódussal megkapjuk a fordított sorrendet!

int[] veletlenszomok = new int[10]; //10 elemből áll
Random elem = new Random();
for (int i = 0; i < veletlenszomok.Length; i++)
  {
   veletlenszomok[i] = elem.Next(0, 100); //veletlenszám tárolása
  }
foreach (int item in veletlenszomok)//tömb elemeinek kiírása foreach ciklussal
  {
   Console.Write(" {0}", item);//szóköz az elemek között
  }
Console.WriteLine();
Console.WriteLine("Rendezve:");
Array.Sort(veletlenszomok);
foreach (int item in veletlenszomok)
 {
  Console.Write(" {0}", item);
 }
Console.ReadKey();

int[] veletlenszomok = new int[10]; //10 elemből áll

Random elem = new Random();

for (int i = 0; i < veletlenszomok.Length; i++)

{

veletlenszomok[i] = elem.Next(0, 100); //veletlenszám tárolása

}

foreach (int item in veletlenszomok)//tömb elemeinek kiírása foreach ciklussal

{

Console.Write(" {0}", item);//szóköz az elemek között

}

Console.WriteLine();

Console.WriteLine("Rendezve:");

Array.Sort(veletlenszomok);

foreach (int item in veletlenszomok)

{

Console.Write(" {0}", item);

}

Console.ReadKey();

Példa 2:

Nézzünk egy másik példát. Állítsunk elő 50 db egész számot -100 és 100 között! Írassuk ki őket 5 sorba! Írjuk ki a pozitív páros számokat is! Ha nincs egy sem, akkor ezt: „Nincs pozitív páros szám.” Itt a feladat második része miatt használunk tömböt, hogy meg tudjuk vizsgálni, van-e közöttük pozitív páros szám.

{
int[] tomb = new int[50]; //50 elemű tömb
int i = 0;
bool van = false; //ez jelzi, találtunk-e + egész számot
Random vsz = new Random();
Console.WriteLine("A 50 db szám:");
Console.WriteLine();
for (i=0; i<=49; i++)
{ 
  tomb[i] = vsz.Next(-100,101);
  if (i % 10 == 9) //mivel 0-tól számozza a tömb elemeit, a 10. elem a 9-es tömbelem
    Console.WriteLine("{0, 6}",tomb[i]);
  else
    Console.Write("{0, 6}", tomb[i]);
}
Console.WriteLine();
for (i=0; i<=49; i++) //végigmegyünk mind az 50 elemen
{
  if (tomb[i]%2==0 && tomb[i]>0)
   {
   if (van == false) Console.WriteLine("A pozitív páros számaink: ");
   Console.Write("{0,4}", tomb[i]);
   van = true;
   }
}
if (van == false) //ha egyet sem talált
   Console.WriteLine("A számok között nincs pozitív páros szám!");
   Console.ReadKey();
}

{

int[] tomb = new int[50]; //50 elemű tömb

int i = 0;

bool van = false; //ez jelzi, találtunk-e + egész számot

Random vsz = new Random();

Console.WriteLine("A 50 db szám:");

Console.WriteLine();

for (i=0; i<=49; i++)

{

tomb[i] = vsz.Next(-100,101);

if (i % 10 == 9) //mivel 0-tól számozza a tömb elemeit, a 10. elem a 9-es tömbelem

Console.WriteLine("{0, 6}",tomb[i]);

else

Console.Write("{0, 6}", tomb[i]);

}

Console.WriteLine();

for (i=0; i<=49; i++) //végigmegyünk mind az 50 elemen

{

if (tomb[i]%2==0 && tomb[i]>0)

{

if (van == false) Console.WriteLine("A pozitív páros számaink: ");

Console.Write("{0,4}", tomb[i]);

van = true;

}

if (van == false) //ha egyet sem talált

Console.WriteLine("A számok között nincs pozitív páros szám!");

Console.ReadKey();

}

 

Két vagy többdimenziós tömbök

Nézzünk egy 2 dimenziós tömböt:
int [ , ] szamok2d = new int[ 1 , 2 ];
string [ , ] szoveg = new string [10, 9];

Vesszővel választjuk el a dimenziók számát. A többdimenziós tömbök elemeinek feltöltését egymásba ágyazott ciklusokkal valósítjuk meg.

Hozzunk létre egy 3×3-as „mátrixot”, töltsük fel véletlen számokkal. A többdimenziós tömböknél a tömb nagyságát a Tömb.GetLength(dimenzio száma) függvénnyel kérdezzük le. A tömb elemeinek feltöltéséhez több egymásba ágyazott ciklust használunk.

using System;
class Program
{
static public void Main()
{
int[,] matrix = new int[3, 3];
Random r = new Random();
for (int i = 0; i < matrix.GetLength(0); ++i)// sorok
{
for (int j = 0; j < matrix.GetLength(1); ++j)// oszlopok
{
matrix[i, j] = r.Next(1,20);
Console.Write(matrix[i, j]+"\t");
}
Console.WriteLine();
}
Console.ReadKey();
}
}

A következő példában egy 3×3-mas tömböt töltünk fel „kézzel”, majd kiíratjuk a tömb elemeit 3×3-as formában.

namespace matrix_feltolt
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Tömb elemeinek feltöltése...");
            int[,] tomb = new int[3, 3];
            int i, j;
            for (i = 0; i < 3; i++)
                for (j = 0; j < 3; j++)
                {
                    Console.Write("Kérem a {0}. sor {1}. oszlop elemét: ", i, j);
                    tomb[i, j] = int.Parse(Console.ReadLine());
                }
            Console.WriteLine("Az eredeti mátrix: ");
            for (i = 0; i < 3; i++)
            {
                for (j = 0; j < 3; j++)
                Console.Write("{0} ", tomb[i, j]);
                Console.WriteLine();
            }
        }
    }
}

Egy halgazdaság próbafogást rendez, 5 halat fognak ki, és vizsgálják a súlyukat és méretüket.
Az egyszerűség kedvéért dkg és cm mértékegységet használnak.
A program feladatai:mennyi a halak összsúlya?
– Mennyi a legkisebb súly? Milyen fajta hal?
– Mennyi a legnagyobb súly? Milyen fajta hal?

using System;
namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {//hal fajtája, tömege, hossza 5sor 3 oszlop
            string[,] halak = new string[5, 3] {
            {"csuka","100","40"},
            {"ponty","510","75"},
            {"harcsa","2250","88"},
            {"ponty","2450","62"},
            {"törpeharcsa","25","24"},
            };
            /*
            Console.WriteLine("{0} hal tömege: {1}dkg hossza: {2}cm",halak[0,0], halak[0,1], halak[0,2]);
            Console.WriteLine("{0} hal tömege: {1}dkg hossza: {2}cm", halak[1, 0], halak[1, 1], halak[1, 2]);
            Console.WriteLine("{0} hal tömege: {1}dkg hossza: {2}cm", halak[2, 0], halak[2, 1], halak[2, 2]);
            */
            //Halak adatai
            for (int i = 0; i < halak.GetLength(0); i++)
            {
                for (int j = 0; j < halak.GetLength(1); j++)
                { Console.Write("{0} ", halak[i, j]); }
                Console.WriteLine();
            }
            //A halak össztömege
            //Legnehezebb hal tömegének mentése
            int maxsuly = 0; int minsuly = 1000;
            int ossztomeg = 0; string maxsuly_index=""; string minsuly_index="";
            for (int i = 0; i < halak.GetLength(0); i++)
                
                {
                    ossztomeg += Convert.ToInt32(halak[i, 1]);
                if (Convert.ToInt32(halak[i, 1]) > maxsuly)
                {
                    maxsuly = Convert.ToInt32(halak[i, 1]);
                    maxsuly_index = halak[i, 0];
                }
                if (Convert.ToInt32(halak[i, 1]) < minsuly)
                {
                    minsuly = Convert.ToInt32(halak[i, 1]);
                    minsuly_index = halak[i, 0];
                }
            }
            Console.WriteLine("össztömeg: {0} dkg",ossztomeg);
            Console.WriteLine("legnehezebb hal:{0} súlya: {1} dkg",maxsuly_index,maxsuly);
            Console.WriteLine("legkönnyebb hal:{0} súlya: {1} dkg", minsuly_index, minsuly);
        }
    }
}

Feladat: Töltsünk fel egy 10 elemű tömböt 1-20 közötti véletlenszámokkal, úgy, hogy ne ismétlődjenek a tömbben a számok!

namespace tomb_ism_nelkul
{
    class Program
    {
        static void Main(string[] args)
        {
            Random vsz = new Random();
            int[] tomb= new int[10];
            bool vanmar; //van-e már ilyen eleme a tömbnek?
            int ujelem=0;
            for (int i = 0; i <tomb.Length; i++)
            {                
                do                  
                {
                    vanmar = false;
                    ujelem = vsz.Next(1, 20);                    
                    for (int j = 0; j < tomb.Length; j++)
                        if (tomb[j] == ujelem)
                        {
                            vanmar = true;
                        }
                }
                while (vanmar);
                tomb[i] = ujelem;
            }
            Console.WriteLine();
            foreach (int item in tomb)
                Console.Write("{0} ",item);
        }
    }
}

Feladat: Készítsünk egy órarendet, amit egy kétdimenziós tömb tárol. Írassuk ki a tömb összes elemét! Írassuk ki csak 1db óra adatát! Az átláthatóbb adatok miatt a tömbbe beírtam a napok neveit is.

using System;
namespace szept20_orarend
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Órarend");
            string[,] orarend = new string[5, 5]
            {
                {"hétfő","info","ének","rajz","úszás"},
                {"kedd","úszás","tech","biosz","matek"},
                {"szerda","magyar","földrajz","töri","info"},
                {"csütörtök","ofő","magyar","matek","angol"},
                {"péntek","matek","tesi","rajz","angol"}
            };
            //kiíratás, összes adat
            for (int i = 0; i < orarend.GetLength(0); i++)
            {
                for (int j = 0; j < orarend.GetLength(1); j++)
                {
                    Console.Write("{0} ", orarend[i, j]);
                }
                Console.WriteLine();
            }
            //kiíratás 1 adat, szerda 4.óra
            //a tömbök elemei 0 sorszámmal kezdődnek!
            Console.WriteLine("{0}",orarend[2,4]);
        }
    }
}

Feladat: Totó
Készítsünk programot, amely totó tippeket sorsol! A feladatot 2 tömb segítségével oldjuk meg! Az egyik tömb tartalmazza az elemeket (1,2,x) a másikat pedig töltsük fel véletlenszerűen az első tömb elemeivel!

using System;
namespace okt11_toto_tombok
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("TOTÓ tippek...");
            string[] elemek = new string[3] {"1","2","x"};
            string[] toto = new string[14];
            Random vsz = new Random();
            
            for (int i=0; i<toto.Length; i++)
            {
                toto[i] = elemek[vsz.Next(0, 3)];
            }
            foreach (string i in toto)
                Console.Write("{0} ",i);
        }
    }
}

Feladat: min,max, megszámlálás, átlag gyakorlása.:
Állítson elő véletlenszerűen 40 számot a [-20, 20] tartományból!

Állapítsa meg pozitív vagy negatív számból van-e több? A választ
és a darabszámokat írja a képernyőre!
Hányszor fordult elő a 7-es szám?
Van-e a számok között 0?
Adja meg a legkisebb szám indexét!
Adja meg a negatív számok átlagát!
Adja meg melyik a legkisebb, és a legnagyobb szám!
Melyik volt a pozitív számok közül a legkisebb?
Melyik volt a negatív számok közül a legnagyobb?
-Írassa ki növekvő sorrendben a számokat!
-Írassa ki csökkenő sorrendben a számokat!

using System;
namespace gyakorlas1018
{
    class Program
    {
        static void Main(string[] args)
        {
            int min = 20; int max = -20; int poz = 0; int neg = 0; int hetes = 0;
            int nulla = 0; int minind = 0; int minpoz = 20; int maxmin = -20;
            int negativok = 0;
            Random vsz = new Random();
            int[] tomb = new int[40];
            for (int i = 0; i < tomb.Length; i++)
            {
                tomb[i] = vsz.Next(-20, 21);
                if (min > tomb[i]) { min = tomb[i]; minind = i; }
                if (max < tomb[i]) max = tomb[i];
                if (tomb[i] > 0) poz++;
                if (tomb[i] < 0) { neg++; negativok = negativok + tomb[i]; }
                if (tomb[i] == 7) hetes++;
                if (tomb[i] == 0) nulla++;
                if (tomb[i] > 0 && tomb[i] < minpoz) minpoz = tomb[i];
                if (tomb[i] < 0 && tomb[i] > maxmin) maxmin = tomb[i];
            }
            int se = 0;
            foreach (int i in tomb)
            {
                se++;
                if (se % 20 == 0) Console.WriteLine();
                Console.Write("{0} ", i);
            }
            Console.WriteLine("poz: {0} db negatív: {1} db", poz, neg);
            if (poz > neg) Console.WriteLine("Több a pozitív szám!");
            else if (neg > poz) Console.WriteLine("Több a negatív szám!");
            else Console.WriteLine("Egyenlő");
            if (hetes == 0) Console.WriteLine("Nincs hetes szám!");
            else Console.WriteLine("Hetesek: {0} db", hetes);
            if (nulla == 0) Console.WriteLine("Nincs 0!");
            else Console.WriteLine("Nullák: {0} db", nulla);
            Console.WriteLine("min: {0} indexe: {2},max: {1}", min, max, minind);
            Console.WriteLine("Negatív számok átlaga: {0}",negativok/neg);
            Console.WriteLine("Legkisebb pozitív szám: {0}", minpoz);
            Console.WriteLine("Legnagyobb negatív szám: {0}", maxmin);
            Array.Sort(tomb);
            Console.WriteLine("Növekvő sorrendben:");
            se = 0;
            foreach (int i in tomb)
            {
                se++;
                if (se % 20 == 0) Console.WriteLine();
                Console.Write("{0} ", i);
            }
            
            Array.Reverse(tomb);
            Console.WriteLine("Csökkenő sorrendben:");
            se = 0;
            foreach (int i in tomb)
            {
                se++;
                if (se % 20 == 0) Console.WriteLine();
                Console.Write("{0} ", i);
            }
        }
    }
}

2D tömb elemeinek elforgatása 90 fokkal:

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

namespace matrix_rotate
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

            int n = matrix.GetLength(0);            
            int[,] elforgatottMatrix = new int[n, n];

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    elforgatottMatrix[j, n - 1 - i] = matrix[i, j];
                }
            }
            Console.WriteLine("Eredeti 2D tömb");
            // Kiírás a konzolra
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(matrix[i, j] + " ");
                }
                Console.WriteLine();

            }
            Console.WriteLine("Elforgatott tömb");
            // Kiírás a konzolra
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(elforgatottMatrix[i, j] + " ");
                }
                Console.WriteLine();
                
            }

            
            Console.ReadLine();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace matrix_rotate

{

class Program

{

static void Main(string[] args)

{

int[,] matrix = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

int n = matrix.GetLength(0);

int[,] elforgatottMatrix = new int[n, n];

for (int i = 0; i < n; i++)

{

for (int j = 0; j < n; j++)

{

elforgatottMatrix[j, n - 1 - i] = matrix[i, j];

}

Console.WriteLine("Eredeti 2D tömb");

// Kiírás a konzolra

for (int i = 0; i < n; i++)

{

for (int j = 0; j < n; j++)

{

Console.Write(matrix[i, j] + " ");

}

Console.WriteLine();

}

Console.WriteLine("Elforgatott tömb");

// Kiírás a konzolra

for (int i = 0; i < n; i++)

{

for (int j = 0; j < n; j++)

{

Console.Write(elforgatottMatrix[i, j] + " ");

}

Console.WriteLine();

}

Console.ReadLine();

}

Kategóriák

Friss bejegyzések

WS2022 – WDS

Playwright teszt