c# programozas

Szótár

Szótár vagy Dictinary

Asszociatív (tartalom szerint címzett) adatszerkezet.
Minden eleme két részből áll: kulcs + érték.
A kulcs csak egyszer fordulhat elő!

—————————————-

Az alábbi példában a kulcs a név, a hozzá tartozó érték pedig a darabszám.

//10 elemű string tömb, ismétlődő nevekkel
string[] nevek = new string[10] {“pisti”,”mari”,”juli”,”zoli”,”pisti”,”pisti”,”mari”,”juli”,”zoli”,”zoli” };
//Szótár létrehozása
Dictionary<string, int> nevekSzotar = new Dictionary<string, int>();
for (int i = 0; i < nevek.Length; i++)
{
if (nevekSzotar.ContainsKey(nevek[i]))
{
nevekSzotar[nevek[i]]++;//ha a kulcs név a szótárban van már növeljük értékét +1-l.
}
else
{
nevekSzotar.Add(nevek[i], 1);//ha a kulcs név nincs még a szótárban beletesszük és értékét 1-re állítjuk.
}
}
foreach (var x in nevekSzotar)
{
Console.WriteLine(x.Key + “: ” + x.Value + ” db”);//szótár tartalom kiíratása
}

————————————-

Feladat:Tölts fel egy tömböt véletlen számokkal 100 elem, 1-20 közti számokkal, majd készíts előfordulási

statisztikát a számokról a szótár szerkezet felhasználásával.

 

Adatszerkezetek

  1. Elemi adatok (Egyszerű adatok)
    1. Numerikus
      • Fixpontos: egész, dátum/idő, (decimális)
      • Lebegőpontos: valós
    2. Logikai
    3. Karakter
    4. Felsorolás
  2. Szöveg
  3. Összetett adatok
    1. Heterogén (különféle adatok): struktúra (rekord)
    2. Homogén (azonos típusú adatok)
      •  Nincs kapcsolat az elemek között: Szótár (asszociatív típus)
      •  Van kapcsolat az elemek között: Tömb, Dinamikus tömb, Lista, verem, sor, láncolt lista
      • Gráfok

2. dolgozat (2018. 04. 12. ) Prog. elm

  1. Jellemezd az OOP -t.
  2. Mi a különbség osztály és objektum között?
  3. Mit jelentenek a következő fogalmak?
  • Osztálydiagram:
  • Adattag:
  • Metódus:
  • Tulajdonság:
  • Konstruktor:
  • UML:
  • Láthatósági módosító:
  • Globális változó:
  • Feltételes ciklus:
  • Szelekció:

4. Írd le szintaktikailag helyes kóddal egy osztály deklarációját.

  • Tartalmazzon adattagot, paraméteres konstruktort, metódust visszatérési értékkel és anélkül.
  • Az osztály kezeljen egy dimenziós tömböket, bekért méretűre definiálja a vektort, legyen metódusa a tömb véletlen számokkal való feltöltésére, a tömb elemek kiíratására és az elemek összegének meghatározására.
  • Hozzon létre egy példányt (10 elem), töltse fel 1-99 közötti véletlen számokkal, írassa ki a tömb elemeit és az elemek összegét.

Védett: 2. dolgozat (2018. 02. 23. ) Prog. gyakorlat

Nincs kivonat, mert ez egy védett tartalmú bejegyzés.

Ö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) egy speciális adat szerkezet, ahol különböző típusú adatokat is kezelhetünk.

A példában egy record tartalmaz string, int, összetett(1 dimenziós tömb)és logikai típusú adattagokat.

Az adatszerkezet (struktúra) neve: Versenyzo.

A “Versenyzo” típusú adatsorokat (record) egy listában tároljuk: “versenyzok”.

Végül kiíratjuk a “vesenyzok” lista tartalmát, az adattagokat kettősponttal elválasztva.

forrás string példa: “rettenetesek 1 Vidék SC 12 2 23 21 34 10 14 16 1″

azaz

Név: rettenetesek

Kategória: 1

Egyesület:Vidék Sc

Pontok, 8 forduló eredményei: 12-2-23-21-34-10-14-16

Felnőtt: 1 azaz true

——————————

struct Versenyzo

{
public string Nev; // adattagok
public int Kategoria;
public string Egyesulet;
public int[] Pontok;
public bool Felnott;//felnőtt: 1; ifi: 0

public Versenyzo(string sor)
{

string[] splittomb = sor.Split(‘;’);
Nev = splittomb[0];
Kategoria = Convert.ToInt16( splittomb[1]);
Egyesulet = splittomb[2];
Pontok = new int[8];
for (int i = 0; i < Pontok.Length; i++)

{
Pontok[i] = Convert.ToInt32(splittomb[i + 3]);
}

Felnott=Convert.ToBoole(splittomb[4];

}//konstruktor

static List<Versenyzo> versenyzok = new List<Versenyzo>();
static void Main(string[] args)
{

feladat2();

Console.ReadKey();
}
static void feladat2()
{
foreach (var x in File.ReadAllLines(“fob2016.txt”))
{
versenyzok.Add(new Versenyzo(x));
}//Fájl beolvasása a listába
foreach (var x in versenyzok)
{
Console.WriteLine(x.Nev + “: ” + x.Kategoria + “: ” + x.Egyesulet + “: ” + x.Pontok[0]+ “: ” + x.Felnott[0]);
}//lista tartalom kiíratása
}

Ö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:

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

2018. december
M T W T F S S
« Nov    
 12
3456789
10111213141516
17181920212223
24252627282930
31