c# programozas

Összetett adatszerkezetek (Dinamikus tömbök)

Dinamikus méretű tömb

Az elemszám dinamikus,nem kell előre megadni mint a statikus tömb esetében.

Kezelése:

Capacity: Az elemek számát olvashatjuk illetve írhatjuk elı.
Count:      Az elemek számát olvashatjuk ki. Csak olvasható tulajdonság.
Item:        A megadott indexű elemet lehet írni vagy olvasni.

Főbb függvényei:

Add:                   Hozzáad egy objektumot a lista végéhez.
BinarySearch:  Rendezett listában a bináris keresés algoritmusával megkeresi az
elemet
Clear:                 Minden elemet töröl a listából.
CopyTo:             Átmásolja az ArrayList-át egy egydimenziós tömbbe.
IndexOf:            A megadott elem első előfordulásának indexét adja vissza.
Insert:                Beszúr egy elemet az ArrayListbe a megadott indexhez.
Sort:                   Rendezi az elemeket az ArrayListben.

Példa:

————————-

using System.Collections; //szükséges névtér

ArrayList dinamikustomb = new ArrayList(); //dinamikus tömb deklarációja
int adat=0;
do
{
          if (adat != 0)
{
dinamikustomb.Add(adat);// elem hozzáadása a tömbhöz
}
}
while (adat != 0);
————————-

Feladatok

  1. Készíts programot, ami segítségével:
    • számok tölthetőek fel 0 végjelig.
    • listázd ki a bevitt számokat,
    • adj hozzá új elemeket,
    • listázd az új adathalmazt,
    • rendezd az adatokat növekvő sorrendbe,
    • listázd az új adathalmazt,
    • írasd ki az adatok összegét és átlagát.
  2. Készíts programot ami neveket és hozzájuk tartozó számokat, pl. testmagasság kér be. megoldás: Futási kép||| Kód
    • táblázatos formában listázzuk az adatokat
    • rendezzük az adatokat név szerint növekvő sorrendbe majd listázzunk
    • rendezzük az adatokat magasság szerint növekvő sorrendbe majd listázzunk
  3. Egy egész számokat tartalmazó tömböt töltsünk fel billentyűzetről oly módon,
    hogy a program kezelője addig írhat be számokat, amíg azok összege el nem éri az előre megadott értéket (például 100)!
    A program a bevitel közben folyamatosan figyelje az összeghatárt, illetve mindig írja ki,
    hogy hányadik számnál tart a bevitel, hol tart az összeg, mennyi van még hátra az értékhatárig!
    A program a bevitel végén írja vissza az adatokat a képernyőre, a számokat egymás mellé írva,
    vesszővel elválasztva, majd adja meg a számok átlagát!
  4. Egy egész számokat tartalmazó tönböt töltsünk fel billentyűzetről oly módon, hogy a listába nem kerülhet be ugyanazon szám többször is!
    Ha a program kezelője olyan számot írna be, amely már volt, akkor a program ezt jelezze ki!
    A bevitelt a kezelő akkor fejezheti be, ha sikerült neki egymás után háromszor is olyan értéket beírni,
    amely még nem szerepelt korábban (amit a program elfogad). A program a bevitel végén írja vissza az adatokat a képernyőre,
    a számokat egymás mellé írva, vesszővel elválasztva, majd adja meg a számok átlagát!

Összetett adatszerkezetek (Struktúra)

A struktúra (record) a tömbökhöz hasonló adat szerkezet, azzal az eltéréssel, hogy itt különböző típusú adatokat is kezelhetünk.

——————————

namespace struktura
{
class Program
{
struct Dolgozo
{
public string nev;
public bool hazas;
public int fizetes;

//public Dolgozo(string _nev, bool _hazas, int _fizetes)
//{
//    this.nev = _nev;
//    this.hazas = _hazas;
//    this.fizetes = _fizetes;
//}
}
static Dolgozo[] dolgozoTomb = new Dolgozo[10];
static void Main(string[] args)
{
dolgozoTomb[0].nev = “Pisti”; dolgozoTomb[0].hazas = true; dolgozoTomb[0].fizetes = 120000;
dolgozoTomb[1].nev = “Lali”; dolgozoTomb[1].hazas = true; dolgozoTomb[1].fizetes = 220000;
dolgozoTomb[2].nev = “Zoli”; dolgozoTomb[2].hazas = true; dolgozoTomb[2].fizetes = 320000;
dolgozoTomb[3].nev = “Juli”; dolgozoTomb[3].hazas = false; dolgozoTomb[3].fizetes = 130000;
//for (int i = 0; i < 10; i++)
//{
//    dolgozoTomb[i].nev = Console.ReadLine();
//    dolgozoTomb[i].hazas = Convert.ToBoolean(Console.ReadLine());
//    dolgozoTomb[i].fizetes = Convert.ToInt32(Console.ReadLine());
//}
for (int i = 0; i < 4; i++)
{
Console.WriteLine(dolgozoTomb[i].nev + ”   “ + dolgozoTomb[i].hazas + ”  “ + dolgozoTomb[i].fizetes);
}
dolgozoTomb.OrderBy(Dolgozo )
Console.ReadKey();
}
}
}

Összetett adatszerkezetek (Sztringek)

Sztring: Karakterlánc, másképpen szöveg.

A sztring kezelésének lényege, hogy a szöveg karaktereit sorban, sorszám szerint elérhetően tároljuk.

Például:
string strSzoveg = “Kelkáposzta”;//tároljuk a “Kelkáposzta” szót
Az egyes karakterek számozása 0-val kezdődik, tehát a “K” a 0., az “e” az 1., ….
Így, a
Console.Writeline(strSzoveg[2])
Kifejezés az “l” betűt adja.

A sztringek kezelésére sok függvény áll rendelkezésre, lekédezhetjük a hosszát, karakter, szövegrészletet kereshetünk benne, cserélhetünk sztring részleteket, stb. A mellékelt példákban a legfontosabb függvények előfordulnak.

Sztring kezelési példák:

————————

string strSzoveg = “Kelkáposzta”;
string strSzoveg2;
Console.WriteLine(“Karaktercsere, k–X”);
Console.WriteLine(strSzoveg);
strSzoveg2=strSzoveg. Replace(“k”, “X”);
Console.Write(strSzoveg2);
Console.WriteLine(“\n****************”);
Console.WriteLine(“Karakter törlés adott helyről, 3-tól 2 db karakter”);
Console.WriteLine(strSzoveg);
strSzoveg2 = strSzoveg.Remove(3, 2);
Console.Write(strSzoveg2);

————————

string strSzoveg = “123456789″;
string strSzoveg2 = “12344456789″;
Console.WriteLine(strSzoveg);
for (int i = 1; i < strSzoveg .Length ;i++ )//string mint vektor
Console.Write(strSzoveg[i]);
Console.WriteLine();
int iEredmeny = strSzoveg.CompareTo(strSzoveg2);//Összehasonlítás
Console.WriteLine(iEredmeny);
Console.Write(“Adj meg egy rövid szöveget, amit beszúrok egy stringbe!: “);
string strBeszur = Console.ReadLine();
strSzoveg =strSzoveg .Insert (1,strBeszur );//beszúrás
Console.WriteLine(strSzoveg);
Console.WriteLine(“Most szöveget keresünk szövegben!”);
string strSzovega = “Boci Boci Tarka, Se Füle se Farka, oda megyünk lakni, ahol tejet kapni!”;
string strSzovegb;
Console.Write(“Kérem a keresendő szövegrészletet!”);//keresés szövegben
strSzovegb= (Console .ReadLine ());
strSzovega = strSzovega.ToUpper();
Console.Write(strSzovega);
strSzovegb = strSzovegb.ToUpper();
if (strSzovega .IndexOf (strSzovegb )>-1)
Console .WriteLine (“Ez benne van!!!!”);
else
Console .WriteLine (“Nincs ilyen részlete a szövegnek”);
Console.WriteLine(“Trimmeljük a szöveget, elejéről és a végéről is levágunk szövegrészletet!”);
char chrElso = Convert.ToChar(strSzovega[0]);
Console .WriteLine (strSzovega .TrimStart (chrElso ));

Console.Write(“Karakter keresése!”);
char[] keres = new[] {‘B’};
int iDarab = strSzovega.IndexOfAny(keres);
Console.WriteLine(iDarab);

————————

/*Kérj be 2 sztringet, állapítsd meg,
* hogy része-e a második az elsőnek,
* s ha igen, hanyadik pozíción kezdődik benne!
*/
Console.WriteLine(“Kérem az első stringet!”);
string strSzoveg1=Console .ReadLine ();
string strSzöveg1Upper = strSzoveg1.ToUpper();
strSzöveg1Upper = strSzöveg1Upper.Replace(” “, “”);
Console.WriteLine(“Kérem a második stringet!”);
string strSzoveg2 = Console.ReadLine();
string strSzöveg2Upper = strSzoveg2.ToUpper();
strSzöveg2Upper = strSzöveg2Upper.Replace(” “, “”);
if (strSzöveg1Upper.IndexOf(strSzöveg2Upper) > -1)
Console.WriteLine(“Szerepel benne”);
else
Console.WriteLine(“Nem szerepel benne!”);
Console.ReadKey();

————————

Feladatok:

  1. Kérj be tetszőleges szöveget, majd írasd ki a hosszát.
  2. Kérj be tetszőleges szöveget, majd mindek karakterét cseréld nagybetűsre.
  3. Kérj be tetszőleges szöveget, majd írasd ki visszafelé.
  4. Kérj be tetszőleges szöveget, majd írasd ki úgy, hogy  minden karaktere egymás alatt legyen.
  5. Írjon programot, mely megszámolja, hogy az inputként érkező mondatban hány darab ”a” betű van!
  6. Az előző programot alakítsa át úgy, hogy a számlálandó betűt is a felhasználó adja meg!
  7. Az input szövegből távolítsa el a szóközöket!
  8. Olvasson be egy mondatot és egy szót! Mondja meg, hogy a szó szerepel-e a mondatban!
  9. A beolvasott mondat kisbetűit alakítsa nagybetűsre, a nagybetűs karaktereket pedig kisbetűsre!
  10. Kérj be két szót, majd döntsd el, hogy ugyanazok-e?
  11. A beolvasott mondatról döntse el, hogy az visszafelé is ugyanazt jelenti-e!
    (Az ”Indul a görög aludni”, vagy a ”Géza kék az ég” visszafelé olvasva is ugyanazt jelenti.) Ügyeljen a mondatvégi írásjelekre, mivel azok a mondat elején nem szerepelnek.
  12. Írj programot ami beolvas egy nevet, és megadja a monogramját (a név két szóból álljon, egy szóközzel elválasztva)
  13. Írj programot ami beolvas egy nevet, és megadja a monogramját (a név tetszőleges számú szóból állhat, egy szóközzel elválasztva), valamint kezeli a dopla betűket is. ( CS,DZ,GY,LY,NY,SZ,TY,ZS)

Tartalom

Műveletek adatokkal

Operátorok

Amikor programozunk, utasításokat adunk a számítógépnek. Ezek az utasítások kifejezésekből állnak, a kifejezések pedig operátorokból és operandusokból, illetve ezek kombinációjából jönnek létre. Az operandus általában az adat, az operátor pedig a műveleti jel.

Utasítás = kifejezések valamint adatok és operátorok kombinációja

pl.:
Ez egy utasítás: Console.WriteLine(“Az eredmény : “+ (bekertszam1/5) );//a processzor végre tudja hajtani!!
Ez egy kifejezés: (bekertszam1/5)
Ez egy operátor; “+”
Ez egy operandus : bekertszam1
Ez egy adat: 5

Precedencia

Precedencia = Műveleti sorrend.

A C# nyelv precedencia szerint 14 kategóriába sorolja az operátorokat (a kisebb sorszámút fogja a fordító hamarabb kiértékelni):
1. Zárójel, metódushívás
2. Pozitív és negatív operátorok (x = -5), logika- és bináris tagadás, postfix, prefix inkrementáló és dekrementáló operátorok, explicit típuskonverzió
3. Szorzás, maradékos és maradék nélküli osztás
4. Összeadás, kivonás
5. Bit-eltoló (>> és <<) operátorok
6. Kisebb (vagy egyenlő), nagyobb (vagy egyenlő), as, is
7. Egyenlő és nem egyenlő operátorok
8. Logikai ÉS
9. Logikai XOR
10. Logikai VAGY
11. Feltételes ÉS
12. Feltételes VAGY
13. Feltételes operátor ( ? : )
14. Értékadó operátor, illetve a “rövid formában” használt operátorok (pl: x +=y)

pl.:

2+3*5 = 17
(2+3)*5 = 25

Asszociativitas: (balról-jobbra)

4 / 2 * 6 = 12

EGYSZERŰ ADATTÍPUSOK JELLEMZŐ MŰVELETEI:

Logikai: NOT, AND, OR, XOR

Valós: +, -, *, /, =, <, >, <>, <=, >=

Egész: +, -, *, =, <, >, <>, <=, >=, / – az eredményt a gép kerekíti, % (maradékos osztás maradéka – pl. 5%2=1, 4%2=0)

String: + (összekapcsolás), <> (a két string nem egyenlő), a betűk ABC sorrendje szerint: <, >, <=, >=

Karakter: a betűk ABC sorrendje szerint: <, >, <>, <=, >=


Típuskonverzió: Adatok átalakítása ( például karaktert számmá)
A felhasználói input kezelésére lehetőséget biztosítanak a Console.Read() ,és a Console.ReadLine()metódusok.
Mindkettő esetében adatokat olvasunk be a billentyőzetről, s ha kiegészítjük a két metódust a Convert osztály konverziós függvényeivel, nemcsak string típusú adatokat, hanem szám típusú, vagy logikai értékeket is beolvashatunk a felhasználótól.

Néhány konverziós függvény a Convert osztályból: 

Convert.ToInt16( );
Convert.ToInt32( );
Convert.ToByte( );
Convert.ToString( );
Convert.ToDateTime( );
stb.

Mi történik az alábbi minta programban?

            Console.WriteLine(“Kérem az átalakítandó számot: “);
string strSzam = Console.ReadLine();
Console.WriteLine(Convert.ToString(Convert.ToInt32(strSzam, 10), 2));
Console.WriteLine(“Kérem a megjelenítendő karakter ASCII kódját: “);
int iSzam = Convert.ToInt16(Console.ReadLine());
Console.WriteLine(Convert.ToChar(iSzam));
for (int i = 0; i < 256; i++)
{
Console.Write(“\t” + i + “\t” + Convert.ToChar(i) + “\n”);
}
Console.ReadKey();

Tartalom

Változók

Változó: Megcímzett, névvel ellátott memóriaterület a számítógép RAM-jában.
Konstans: Állandó, nem változtatható érték.
Azonosító: Olyan jelsorozat, amellyel a változó tartalmára hivatkozhatunk és megváltoztathatjuk azt.
Értékadás: Az a művelet, melynek során a változó értéke megváltozik. Jele C#: „ = ” – egyenlő.
Kezdőérték: A változó és a konstans induló értéke
Deklaráció: Az algoritmus azon pontja, ahol a változót először elhelyezzük (típust adunk neki).
Definiálás, inícializálás : Értékadó művelet.
Kifejezés:
Műveletek:

Változók:

Fogalma: A változók olyan névvel ellátott memóriaterületek, amelyekben típustól függő értékeket tárolhatunk. Ezt a memóriaterületet számunkra a fordító (compiler) foglalja le, amelyre a program törzsében a változó azonosítójával hivatkozhatunk.
Minden változót, használat előtt deklarálni kell.

Jellemzői:

  1. Neve (azonosítója): Csak betűvel (az angol ABC szerint) és aláhúzásjellel kezdődhet, és betűvel, számmal vagy aláhúzásjellel folytatódhat. Hossza legalább 1 karakter. Kis- és nagybetű általában nem különböző (a C-ben igen).
  2. Típusa:
    • Logikai, szám (egész, valós), szöveg, karakter, stb.
    • Azonos típusok összehasonlíthatóak egymással.
    • A típus meghatározza, hogy milyen műveletek végezhetők vele.
    • Meghatározza a méretét (memóriában)
  3. Értéke: Egy a megadott típusban elhelyezkedő elem. Pl.
    • logikai (TRUE és FALSE lehet, hossza: 1 bit)
    • egész (-végtelen és +végtelen közötti egész szám)
    • valós (-végtelen és +végtelen közötti tört vagy egész szám),
    • string (’SzöVeG’ – maximum 255 karakter hosszúságú szöveg lehet, de lehet akár 1, akár 0 karakter hosszúságú is – a C-ben nincs valódi string, így nem csak 255 karakternyi, hanem bármilyen hosszúságú szöveget egy „0” karakter zárja),
    • karakter (’X’ – lehet speciális jel, számjegy, betű vagy üres karakter)
  4. Értelmezett műveletek

Kifejezés:

Változók literálok, műveleti jelek kombinációja.

pl.: int iSzam= iBe + 10;

literál: konkrét, kódba begépelt érték (pl. fent a 10)

Típusok:

  • Elemi (egyszerű) típusok

    • Egész
    • Valós
    • Karakter
    • Logikai
    • Mutató
  • Összetett típusok

    • Tömb
      • Egy dimenziós (vektor)
      • Két dimenziós (Mátrix vagy táblázat)
      • Több dimenziós
    • Karakterlánc
    • Rekord
    • Állomány(fájl)

Tartalom

Szintaktika

C# nyelv alap szintaktikája:

  • Az utasítások végén pontosvessző  van: …………………………………………..” ; “
  • A függvények paramétereit görbe zárójelek között adjuk meg : …………“( )”
  • A program egységeit (osztályok, metódusok, stb.)
    blokkokkal jelöljük ki, a kapcsos zárójelek  segítségével:…………………. “{  }”
  • A tömbök jelölésére szögletes zárójeleket alkalmazunk:………………….. “] ]”
  • A sztringeket idézőjelek kell zárni, a karaktereket pedig
    aposztrófok közé: Console.WriteLine(” Adatok: “); illetve char betu=’Q’;
  • A kis- és nagybetűk érzékenység, int x; és int X;
    nem helyettesíti egymást, illetve a Console.Clear() és Console.clear()
    közül a második szintaktikai hibás is.

Foglalt szavak:

abstract; default; foreach; object; Sizeof; unsafe; as; delegate; goto; operator; stackalloc; ushort;
base; do; If; out; Static; using; bool; double implicit override String virtual break else In
params Struct volatile byte enum int private Switch void case event interface protected
This while catch explicit internal public Throw char extern Is readonly True checked false
lock ref Try class finally long return Typeof const fixed namespace sbyte Uint continue float
new sealed Ulong decimal for null short unchecked

Megjegyzések:(kommentek)

  • // Megjegyzés
  • /* Megjegyzés*/

IntelliSense technológia, ikonok

Névterek, osztályok :

Névtér.Osztály: pl. using System;

Tartalom

File kezelés


 A “File” osztály fontosabb függvényei…

using System.IO; // Fájlkezeléshez szükséges névtér

File.ReadAllText()—————————-Fájl beolvasása string változóbsa

File.ReadAllLines()—————————Fájl beolvasása, soronként vektorba

File.WriteAllText()—————————-String írása fájlba (Fájlt létrehoz vagy létezőt felülír)

File.WriteAllLines()—————————String tömb fájlba írása (Fájlt létrehoz vagy létezőt felülír)

File.AppendAllText()————————–Stringet fűz fájlhoz (Fájlt létrehoz vagy létezőhöz hozzáfűz)

File.AppendAllLines()————————-String tömb fájlhoz fűzése (Fájlt létrehoz vagy létezőhöz hozzáfűz)

File.Copy()————————————–Fájl másolása

File.Delete()————————————-Fájl törlése

File.Exists()————————————–Fájl létezésének ellenőrzése


 

Szövegfájl beolvasása változóba:

string fileTartalom = File.ReadAllText(“adatok.txt”, Encoding.Default);

Console.WriteLine(fileTartalom);

!!! Encoding.Default: Ékezetes karakterek helyes megjelenítése


 

Szövegfájl beolvasása soronként vektorba:

string[] fajlTomb = File.ReadAllLines (“adatok.txt”,Encoding.Default);
foreach (var x in fajlTomb )
{
Console.WriteLine(x);
}


String írása fájlba (Fájlt létrehoz vagy létezőt felülír)

File.WriteAllText(“adatok2.txt”, “1. sor”);


String tömb fájlba írása (Fájlt létrehoz vagy létezőt felülír)

string[] fajlTomb = new string[10];
for (int i = 0; i < 10; i++)
{
fajlTomb[i] = Convert.ToString(i);
}
File.WriteAllLines(“adatok3.txt”, fajlTomb);


Stringet fűz fájlhoz (Fájlt létrehoz vagy létezőhöz hozzáfűz):

File.AppendAllText(“adatok.txt”,“Új név!”+Environment .NewLine ,Encoding.Default);

!!! +Environment .NewLine: a hozzáfűzés új sorba kerül.


String tömb fájlhoz fűzése (Fájlt létrehoz vagy létezőhöz hozzáfűz):

string[] fajlTomb = new string[10];
for (int i = 0; i < 10; i++)
{
fajlTomb[i] = Convert.ToString(10-i);
}
File.AppendAllLines(“adatok4.txt”, fajlTomb);


Fájl másolása

File.Copy(“adatok.txt”, “adatokMasolat.txt”);


Fájl törlése:

File.Delete(“adatokMasolat.txt”);


Fájl létezésének ellenőrzése:

if (File.Exists(“adatok.txt”))
{
Console.WriteLine(“Fájl létezik! “);
}
else
{
Console.WriteLine(“Fájl NEM létezik! “);
}


Fájl adott elemének és hosszának lekérdezése:

string[] data = File.ReadAllLines(“text.txt”);
foreach (string x in data)
{
Console.WriteLine(x);
}
Console.WriteLine(“2. sor: “+data [2]);
Console.WriteLine(“Hossz: ” + data.Length );


Feladatok 1:

  1. Készíts programot, amely kiírja egy előre elkészített fájl sorait .
  2. Készíts programot, amely az előző fájlhoz további sorokat fűz hozzá.
  3. Készíts programot, amely kiírja az előző fájl sorait megszámozva.
  4. Készíts programot, ami neveket kér be és ezeket fájlban tárolja, majd az adat bevitel végén kiírja az így elkészített fájl sorait .
  5. Készítsd el az előző program menü vezérelt változatát.(Menüpontok: Adatbevitel, Mentés, Fájl kiíratása, Fájl törlése)
  6. Készíts programot, amely egy fájlba beleírja az első N természetes szám valódi osztóit, minden sorba egy számot:
    pl.:
    10: 2 5
    11:
    12: 2 3 4 6
  7. Adott egy fájl, minden sorában három szám: egy háromszög oldalainak hosszai. Készíts programot, amely megadja a legnagyobb kerületű háromszöget (a sorszámát és az adatait).

Feladatok 2:

  1. Készíts programot, amely átmásolja egy fájlnak azon sorait, amelyek több mint egy szóból állnak, egy másik fájlba.
  2. Készíts programot, amely átmásolja egy fájlnak minden ‘a’ betűvel kezdődőszavát egy másik fájlba.
  3. Adott egy szöveges fájl, minden sorában egy (tetszőleges hosszú) számsorral. Készíts programot, amely megadja, hogy melyik sorban legnagyobb a számok minimuma.
  4. Készítsünk programot, ami létrehoz egy menüt:
    1., Névsor listázása
    2., Új név hozzáadása
    3., Név törlése
    0., Kilépés
    Tároljuk a nevet, születési évet és a nemet. Új név hozzáadásakor a rendszer az adatot azonnal kiírja fájlba. Törlés esetén a módosított névsor legyen a fájlban.
  5. Készítsünk programot, amely beolvas egy szöveges állományt, majd egy másik állományba kiírja a beolvasott szöveget csupa nagybetűkkel.
  6. Készítsünk programot, amely beolvas egy szöveges állományt, majd a beolvasott szöveget kiírja egy másik állományba úgy, hogy mindegyik karaktere után tesz egy szóközt.

Tartalom

Összetett adatszerkezetek (Tömbök)

 Tömbök

  • A tömb egy összetett adatstruktúra
  • Tetszőleges számú, 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 = vektor!
    Kétdimenziós tömb = Táblázat (mátrix)!
  • Vannak olyan tömbök is melyek elemszáma nincs előre meghatározva, ezek a dinamikus tömbök.

Deklaráció:

Egydimenziós tömb

  • int[] iTomb; iTomb = new int[15];
  • int[] iTomb = new int[15];
  • string[] strSzoveg = new string[15]; // 15 elemű string tömb
  • double[] dTomb = new double[12]; // 12 elemű valós tömb
  • bool[] bTomb = new bool[23]; // 23 elemű logikai tömb
  • int[] iTomb = new int[3] {3,4,5};
  • string[] strSzoveg = new string[3] {“első”,”második”,”harmadik”};

Két dimenziós tömb (mátrix)

  • int[,] matrix = new int[3, 3];
  • int[,] matrix = new int[,]
    {
    {12, 23, 2},
    {13, 67, 52},
    {45, 55, 1}
    };

Fontosabb tulajdonságok és metódusok, programozási tételek:

  • index
  • hossz: length()
  • rendezés: sort()
  • maximum: max()
  • minimum: min()
  • Eldöntés
  • Kiválogatás

Feladatok (1 dimenziós tömb-vektor):

  1. feladat:Deklarálj egy int típusú tízelemű tömböt! Töltsd fel 1-től 10-ig számokkal! Írasd ki a tömb elemeit!
  2. feladat: Deklarálj egy int típusú tízelemű tömböt! Töltsd fel 10-től 1-ig számokkal! Írasd ki a tömb elemeit!
  3. feladat:Deklarálj egy int típusú tízelemű tömböt! Töltsd fel 2-vel kezdődően páros számokkal! Írasd ki a tömb elemeit!
  4. feladat: Deklarálj egy int típusú tízelemű tömböt!Töltsd fel 1-gyel kezdődően páratlan számokkal! Írasd ki a tömb elemeit!
  5. feladat:Deklarálj egy int típusú tízelemű tömböt!Töltsd fel minden elemét azzal a számmal, amit a felhasználótól kérsz be! Írasd ki a tömb elemeit!
  6. feladat: Deklarálj egy int típusú tízelemű tömböt! Töltsd fel azzal a számmal kezdődően, amit a felhasználótól kérsz be! Írasd ki a tömb elemeit!
  7. feladat:Deklarálj egy int típusú tízelemű tömböt!Töltsd fel azzal a számmal kezdődően, amit a felhasználótól kérsz be! Ügyelj arra, hogy csak az 5-tel osztható számokat használd!(Ha a bekért szám nem osztható 5-tel, akkor a program újra kérje be a számot!) Írasd ki a tömb elemeit!
  8. feladat: Deklarálj egy int típusú tízelemű tömböt! Töltsd fel azzal a számmal kezdődően, amit a felhasználótól kérsz be! Ügyelj arra, hogy csak az 5-tel vagy 6-tal osztható számokat használd!(Ha a bekért szám nem osztható 5-tel vagy 6-tal, akkor a program újra kérje be a számot!) Írasd ki a tömb elemeit!
  9. feladat:Deklarálj egy int típusú tízelemű tömböt! Töltsd fel azzal a számmal kezdődően, amit a felhasználótól kérsz be! Ügyelj arra, hogy csak az 5-tel és 6-tal osztható számokat használd! (Ha a bekért szám nem osztható 5-tel és 6-tal, akkor a program újra kérje be a számot!) Írasd ki a tömb elemeit!
  10. feladat: Az első kilenc feladatot valósítsd meg menüszerkezettel! A menü egy-egy részfeladat végrehajtódása után újra jelenjen meg! A menü tartalmazzon „Kilépés” opciót!
  11. Olvassunk be egész számokat 0 végjelig egy maximum 100 elemű tömbbe (a tömböt 100 eleműre deklaráljuk, de csak az elejéből használjunk annyi elemet, amennyit a felhasználó a nulla végjelig beír).
    - Írjuk ki a számokat a beolvasás sorrendjében.
    - Írjuk ki az elemek közül a legkisebbet és a legnagyobbat, tömbindexükkel együtt.
    - Írjuk ki az elemeket fordított sorrendben.


  12. Olvassunk be egész számokat egy 20 elemű tömbbe, majd kérjünk be egy egész számot. Keressük meg a tömbben az első ilyen egész számot, majd írjuk ki a tömbindexét. Ha a tömbben nincs ilyen szám, írjuk ki, hogy a beolvasott szám nincs a tömbben
  13. Állítsunk elő egy 50 elemű tömböt véletlen egész számokból (0-tól 9-ig terjedő számok legyenek).
    - Írjuk ki a kigenerált tömböt a képernyőre.
    - Számítsuk ki az elemek összegét és számtani középértékét.
    - Olvassunk be egy 0 és 9 közötti egész számot, majd határozzuk meg, hogy a tömbben ez a szám hányszor fordul elő.
  14.    Állítsunk elő egy 30 elemű tömböt véletlen egész számokból (0-tól 99-ig).
    - Írjuk ki a kigenerált tömböt a képernyőre.
    - Olvassunk be egy egész számot. Határozzuk meg, hogy a tömbben melyik számok vannak a legközelebb ehhez a beolvasott számhoz, majd írjuk ki az összes ilyen számot a tömbből a tömbindexükkel együtt. (A két szám közti különbség meghatározásához használjuk az abszolút érték funkciót, pl. abs(x–y) )
  15. Állítsunk elő egy 150 elemű tömböt véletlen egész számokból –999-től 999-ig. Rendezzük ezt a tömböt nagyság szerint növekvő sorrendben, majd írjuk ki a képernyőre.     A rendezésre a következő rendezési algoritmust használjuk (rendezés a legkisebb elem kiválasztásával):
    - kiválasztjuk a tömb 1.-150. elemei közül a legkisebbet, ezt kicseréljük a tömb 1. elemével (így a legkisebb szám a tömbben az első helyre került),
    - kiválasztjuk a tömb 2.-150. elemei közül a legkisebbet, ezt kicseréljük a tömb 2. elemével,
    - kiválasztjuk a tömb 3.-150. elemei közül a legkisebbet, ezt kicseréljük a tömb 3. elemével,
    - végül kiválasztjuk a tömb 149.-150. elemei közül a legkisebbet, ezt kicseréljük a tömb 149. elemével.

Feladatok (2 dimenziós tömb-Mátrix)

Egyszerű feladatok:

  1. Olvassunk be egy kétdimenziós tömböt, írjuk ki  és számítsuk ki az elemeinek az összegét.
  2. Hozzunk létre egy olyan kétdimenziós tömböt amelynek minden eleme egyenlő a saját indexeinek a szorzatával. Írjuk ki a tömböt.
  3. Határozzunk meg egy kétdimenziós tömb legnagyobb elemét. . Írjuk ki a tömböt.
  4. Határozzátok meg egy kétdimenziós tömb minden sorának az összegét. . Írjuk ki a tömböt.
  5. Határozzátok meg egy kétdimenziós tömb  minden sorának a maximumát. . Írjuk ki a tömböt.
  6. Számítsuk ki egy egész számokat tartalmazó kétdimenziós tömb azon páros elemeinek az összegét melynek mindkét indexe páros. Írjuk ki a tömböt.
  7. Készíts programot ami táblázatos formában elkészíti a szorzótáblát!
  8. Adott egy10x15-es (2 dimenziós) egészekből álló tömb.
    Töltsd fel az elemeket 1-500 közötti véletlen számokkal, majd írasd ki a tömb elemeit, 10 sorban, 15 oszlopban.
    Az egyes oszlopok 4 karakter szélesek legyenek. Számítsd ki az elemek átlagát.
    Írasd ki az átlagot és azokat az elemeket, amelyek nagyobbak az átlagnál.
  9. Adott egy 10×10-es (2 dimenziós) egészekből álló tömb.
    Töltsd fel az elemeket: 1. sor: 1-től 10, 2. sor:11-20…egészen 100-ig majd írasd ki a tömb elemeit, 10 sorban, 10 oszlopban.
    Az egyes oszlopok 3 karakter szélesek legyenek. Tükrözd a tömböt a függőleges felező vonalára. Így is írasd ki a tömböt.
  10. Tükrözd az előző feladat tömbjét növekvő illetve csökkenő átlóra

Gondolkodtató feladatok:

  1. Felderítő repüléseket végzünk egy tengeri terület felett. Párhuzamos útvonalakkal pásztázzuk a területet, mérjük a felszín tengerszint feletti magasságát. Ott tenger van, ahol a mérés eredménye 0, szárazföld felett az eredmény >0. Határozzuk meg, hány sziget van ezen a tengerszakaszon!
  2. Az előző feladat alapján határozzuk meg
    1. Összesen hány sziget van?
    2. Adjuk meg azt a szigetet, amelyiknek az átlagos tengerszint feletti magassága a legnagyobb!
    3. Melyik a legnagyobb területű sziget sziget?
    4. Állapítsuk meg hogy hány egyforma szélességű sziget van!
  3. Oldjuk meg az előző feladatot úgy, hogy a szigetek függőlegesen is kapcsolódhatnak.
     Itt 10 sziget van!
  4. Egy nyilvántartásban a személyekről négy adatot tartanak nyilván: magasság, szemszín, hajszín, életkor. Döntsük el, hogy van-e két olyan személy, akiket ez a nyilvántartás nem különböztet meg.
  5. Egy színház pénztárának nyilvántartása tartalmazza, hogy egy adott előadásra mely helyekre keltek már el jegyek. B(i,j) tömbelem az i. sor j. helyét jelenti a baloldalon, J(i,,j) ugyanezt a jobboldalon. A tömbelem értéke 1, ha az adott helyre szóló jegy már elkelt, 0 ha még szabad. Írjunk programot mely keres két szomszédos szabad helyet az adott előadásra.

Tartalom

C# programozás

  1. Szintaktika
  2. Változók
  3. Műveletek adatokkal
  4. Ciklus — Elágazás + egyszerű menü
  5. Összetett adattípusok (Tömbök)
  6. Összetett adattípusok (Dinamikus tömbök)
  7. Összetett adattípusok (Sztringek)
  8. Összetett adattípusok (Struktúra)
  9. Fájlkezelés

Tankönyvek!

Programozás: iteráció-szelekció (Ciklus-elágazás)

Ciklusok (Iteráció):

  • Számlálós ciklus ……….(FOR)
  • Elöltesztelős ciklus ……(WHILE)
  • Hátultesztelős ciklus….(DO-WHILE).

 Elágazások (Szelekció):

  • Feltételes utasítás: …….(IF)
  • Elágazás: ………………….(IF-ELSE)
  • Többszörös elágazás: …(SWITCH-CASE)

 

Ciklus példák:

———————

Előírt lépésszámú ciklus (FOR):

        for(int i = ; i < 10 ; ++i)
{
Console.WriteLine(“X == {0}”, i);
}
Console.ReadKey(true);

———————

Elöltesztelő ciklus (WHILE):

         int i = 0; //kezd$érték
while(i < 10) //ciklusfeltétel
{
Console.WriteLine(“I == {0}”, i);
++i; //ciklusváltozó növelése
}

———————

Hátultesztelő ciklus (DO-WHILE):

        int i = 0;
do
{
Console.WriteLine(“i értéke: {0}”, i); ++i;
}
while (i < 10);

 


 

Elágazás példák:

———————

Feltételes utasítás:

if (adat % 2 == 0)

{
Console.WriteLine(” adat változó tartalma páros szám!”);
}

———————

Elágazás:

 if (adat % 2 == 0)

{
Console.WriteLine(” adat változó tartalma páros szám!”);
}
else
{
Console.WriteLine(” adat változó tartalma páratlan szám!”);

}

———————

Többszörös elágazás:

SWITCH-CASE:

switch(x)
{
case 2: utasítások; break;
.
.
.
case 7: utasítások; break;
case 8: utasítások; break;
.
.
default: utasítások; break;


 

Gyakorló feladatok: Ciklus és elágazás használata

    1. 0-9 ig a számok egymás alá “for” ciklussal
    2. 0-9 ig a számok egymás alá “while” ciklussal
    3. 0-9 ig a számok egymás alá “do-while” ciklussal
    4. Írj programot ami kiírat 10 csillagot egy sorban, egymás alá is.
    5. Írj programot ami csillagokból négyszöget rajzol ki.
    6. Írj programot ami csillagokból derékszögű háromszöget (bal, jobb dőlésű), és egyenlő szárú háromszöget is rajzol.
    7. Írj programot “do-while” ciklus felhasználásával ami bekér egy számot 10 és 50 között,
      más értéket nem fogad el.
    8. Írj programot “do-while” ciklus felhasználásával ami bekér egy számot 10 és 50 között,
      más értéket nem fogad el, betű nem adható meg.
    9. Old meg a fenti feladatot “while” ciklus felhasználásával.
    10. Írj programot ami számokat kér be végjelig (“Q”), majd a végjel megadása után a számok összegét kiírja.
    11. Készíts programot, ami kiírja 1-10-ig egymás alá a számokat és mellé
      a szám értékének megfelelő számú * karaktert tesz.
    12. Készíts programot, ami, elöl tesztelős ciklussal összeadja a páratlan számokat 11-től 89-ig.
      A végén kiírja az eredményt.
    13. Készíts programot, ami, hátul tesztelős ciklussal összeadja a páratlan számokat 11-től 89-ig.
      A végén kiírja az eredményt.
    14. Olvass be egy pozitív egészet. Add össze 1-től a beolvasott számig az egészeket.
      A program írja ki az összeget és a számok átlagát.
    15. Írj programot ami a bekért osztályzat(1-5) alapján kiírja a minősítést. (elégtelen, elégséges, közepes, jó, jeles)
    16. Írj programot ami a bekért osztályzat(1-5) alapján kiírja a minősítést. (elégtelen, elégséges, közepes, jó, jeles)
    17. Olvassunk be egész számokat, 0 végjelig (amíg 0 nem érkezik).
      Számoljuk meg hány pozitív és hány negatív szám érkezett.
    18. Számoljuk meg, hogy egy begépelt szövegben hány “e” betű van?(for és if)
    19. Listázd ki 0-100 között a 3-al osztható számokat.(for és if)
    20. Írj programot, ami eldönti egy számról, hogy prím szám-e?
    21. Olvass be 3 valós számot. Döntsd el, hogy a 3 szám lehet-e egy háromszög 3 oldala.
    22. Döntsd el egy (x,y) koordinátákkal megadott pontról, hogy melyik síknegyedbe esik.
    23. Kérdezzen be a program két számot, és írja ki a köztük lévő relációt szöveges formában!
    24. Írjunk programot, mely bekér egy számot, és eldönti, hogy osztható-e 3-l és 4-l.
    25. Írjunk programot, mely bekér egy számot, és eldönti, hogy osztható-e 3-l és 4-l vagy 9-el.
    26. Írasd ki a számokat 1-től 100-ig egymás alá oldalanként. Egy oldalon 25 sor legyen. Oldalanként billentyűleütésre várjon, majd képernyőtörlés után az új oldal jelenjen meg.
    27. Készítsünk programot, amely bekéri a víz hőmérsékletét, majd eldönti, hogy az milyen halmazállapotú. A halmazállapot lehet folyékony, gőz, vagy jég.
    28. Írjon egy programot, ami leosztályoz egy maximálisan 100 pontos dolgozatot az 50, 65, 80, 90 ponthatárok szerint! A határérték a jobb jegyhez tartozik. Ha a pontszám negatív vagy száznál nagyobb, akkor a program írja ki, hogy hibás az adat! Használj switch szerkezetet.
    29. Készítsünk programot, amely beolvassa egy diák igazolatlan hiányzásainak számát. Ennek megfelelően írassuk ki a magatartás jegyét. Tíz igazolatlan hiányzás elérésekor (vagy ha ezt túlhaladtuk) kérjük be a tanuló születési dátumát és írjuk ki az igazolatlan hiányzásait (amennyiben az érték több mint tíz). Készítsünk kategóriákat az igazolatlan hiányzások száma alapján. Az első kategória figyelmeztetést, a második osztályfőnöki intőt, a harmadik igazgatói megrovást, a negyedik kategória pedig felfüggesztést von maga után. A büntetés mértékét szintén jelezzük a felhasználó felé.

 

Készíts menüt:

do
{
Console.WriteLine(“Válaszz az alábbiak közül:”);
Console.WriteLine(“\t1 — Kutyák”);
Console.WriteLine(“\t2 — Macskák”);
Console.WriteLine(“\t3 — Nyulak”);
Console.WriteLine(“\t4 — Halak”);
Console.Write(“A választott szám + ENTER! (Kilépés: 0): “);
string strValasztas = Console.ReadLine();
int iEzkell;
try
{
iEzkell = int.Parse(strValasztas);
}
catch (FormatException)
{
Console.WriteLine(“\r\nNa…?\n”);
continue;
}
Console.WriteLine(“A választásod “ + iEzkell);
switch (iEzkell)
{
case 0:
rendben = true;
break;
case 1Console.WriteLine(“kutya”);
break;
case 2Console.WriteLine(“macska”);
break;
case 3Console.WriteLine(“nyúl”);
break;
case 4Console.WriteLine(“hal”);
break;
default:
Console.WriteLine(“Ilyen számot nem választhatsz!: {0}\n”, iEzkell);
continue;
}
Console.WriteLine();
}
while (!rendben );
Console.WriteLine(“\nViszlát!”);

 

Tartalom

2018. január
M T W T F S S
« Dec    
1234567
891011121314
15161718192021
22232425262728
293031