C-Sharp programozás alapjai

Nagyon hasonlít a javahoz!

Alapismeretek

A C# programozási nyelv 2002-ben jelent meg a Microsoft cég Visual Studio.Net programcsomagjával. Egy modern objektumorientált nyelv, a C++ utódjaként tekinthető. Kifejezetten a .Net keretrendszerhez fejlesztették ki. A C# programnyelven írt alkalmazások csak olyan operációs rendszer alatt futtathatók, amelyek támogatják a .NET keretrendszert. A .NET keretrendszer a programfejlesztésben fordítási idejű szolgáltatásokat ad, a kész alkalmazások számára pedig futási időben ad támogatást. A Windows XP operációs rendszerhez külön fel kell telepíteni. (Ez a fejlesztőkörnyezet telepítésekor megtörténik, de ha a kész programot más gépen szeretnénk futtatni, gondoskodni kell róla, hogy az idegen gépen is működjön a .NET)

A C# néhány jellemzője:

• Egy sorba több utasítás is írható, az utasítások lezáró jele a pontosvessző (;).
• Minden változót deklarálni kell.
• Változók, függvények, osztályok elnevezésében ékezetes karaktereket is lehet használni, kis és nagybetűk különbözőnek számítanak.
• Minden utasítás helyére összetett utasítás is írható. ({ és } zárójelek közé írt utasítások)
• Függvények definíciói nem ágyazhatók egymásba. Rekurzió megengedett. (Egy függvény meghívhatja önmagát.)
• A program végrehajtása a Main függvénnyel kezdődik.

A programban használt neveknek betűvel vagy _ jellel kell kezdődni, ezután tetszőleges betű és szám variáció jöhet. (A nevek hossza általában 32 lehet.)

Nem megengedett nevek:

abstract	as	base	bool	break	byte	case	catch
char	checked	class	const	continue	decimal	default	delegate
do	double	else	enum	event	explicit	extern	false
finaly	fixed	float	for	foreach	goto	if	implicit
in	int	interface	internal	is	lock	long	namespace
new	null	object	operator	out	override	params	private
protected	public	readonly	ref	return	sbyte	sealed	short
stackalloc	static	string	struct	switch	this	throw	true
try	typeof	uint	ulong	unchecked	unsafe	ushort	using
virtual	void	while

A programkódban megjegyzést /* és */ jelek között helyezhetünk el, hossza több sor is lehet. // után írhatunk a sor végéig tartó rövid megjegyzést.
Egy C# program több modulból (fájlból) állhat, ezeknek azonos a szerkezete. Egy modul tartalmaz más modulokra történő hivatkozásokat (using) és osztálydeklarációkat (class). Egy osztályon belül változókat és függvényeket deklarálhatunk.
A using kulcsszót a program elején arra használjuk, hogy megadjuk milyen beépített könyvtári elemeket, névteret, osztályt használunk a programban, és így rövidebb jelöléssel hivatkozhatunk ezek különféle szolgáltatásaira.
A névtér (namespace) egy olyan logikai egység, amelyen belül az azonosítóknak egyedinek kell lenniük. Nem kötelező a névtér definiálása, ekkor az úgynevezett név nélküli névtér része lesz amit írunk. Minden programban fogjuk használni a készen kapott System névteret, amely számos fontos szolgáltatást nyújt. Például a C# nyelvben nem alaputasítás a billentyűzetről történő beolvasás, vagy a képernyőre történő kiírás, ezeket a System névtér Console osztálya biztosítja.
A segédletben példaként szereplő kódok egy modulban elférnek, szerkezetük a következő:

  using ...;

  ...

  namespace névtérnév

  {

     class osztálynév

                {

                              változók definiciói;

                               függvények definiciói;

                }

                ...

  }

Rövid magyarázat:
Definiálunk egy üdvözlet osztályt, ebben egyetlen függvényt, a Main függvényt, amivel a program végrehajtása elkezdődik. A static jelölés azt jelenti, hogy a Main függvény már fordítási időben létrejön, a void pedig azt, hogy a függvény nem ad vissza értéket.
Mint azt már korábban említettem, a C# nyelvben nem alaputasítás a beolvasó és a kiíró utasítás, ezeket a System névtér részeként megvalósított könyvtári szolgáltatások nyújtják.
A using System; sor jelzi, hogy a programfejlesző könyezettel készen kapott System névtér azonosítóit használjuk a programunkban, nevezetesen a System névtér Console osztályának WriteLine függvényét. Ennek a névtérnek a szolgáltatásaira nagyon gyakran lesz szükségünk.

A C# alaptípusai

A változóknak kötelező megadni a típusát, ennek legegyszerűbb formája:
típus változónév;
pl.:

char c;	// a c változó karakter típusú
int kicsi, nagy;	// a kicsi változó és a nagy változó egész típusú
float g=59.71F;	// a g valós típusú változó 59.71 kezdőértékkel

A változók lehetnek külsők, azaz függvényen kívüliek, vagy belsők, azaz függvényen belüliek. A függvényen kívüli változók osztályon belüliek lehetnek. A belső változók élettartama a blokkban való tartózkodás idejére korlátozódik. Ha a blokk végrehajtása befejeződött, megszünnek létezni.
A static szó használatával lehet statikus élettartamú külső változókat definiálni, számukra a fordító foglal helyet a memóriában, élettartamuk megegyezik az egész program élattartamával.
Állandók megadása:
const típus név=érték;
pl.:

const int pici=1;

Ha a programban az állandóként definiált változó értékét meg akarjuk változtatni, a fordító hibát jelez.

Elemi típusok

char

Karakter típus (2 byte hosszú). Unikód kódolást használ, a változó értékét aposztróf (') között adjuk meg.
pl.:

char c='A';

A backslash (\) karakter speciális jelentéssel bír. A segítségével használható úgynevezett escape szekvenciák a következők:

\a	a 7-es kódú csipogás
\b	backspace, előző karakter törlése
\f	formfeed, soremelés karakter
\r	kocsi vissza karakter
\n	új sor karakter (soremelés+kocsi vissza)
\t	tabulátor karakter
\v	függőleges tabulátor
\\	backslash karakter
\'	aposztróf
\"	idézőjel
\?	kérdőjel
\uXY	XY unikódú karakter, X és Y 16-os számrendszerbeli kétjegyű számok

string

Karaktersorozat (szöveg), a System.String osztálynak megfelelő típus. Szövegek esetén a + és a += szövegösszefűzést végző operátorok. A [] operátor a szöveg adott indexű karakterét jelöli, az indexelés 0-val indul. A @ karakter kiküszöböli a szövegen belüli érzékeny karakterek hatását. Ilyen például a backslash (\) karakter.
Pl.

char c='\u0092';	// c = a 92-es kódú (\) karakterrel
string s="citrom";
string n=s+"héj";	// n=citromhéj
s+="fű";	//s=citromfű
char c1=s[2];	// c1=t
char c2="szia"[1];	// c2=z
string f="c:\\szov\\olv.txt";
string fájl=@"c:\szov\olv.txt";	// f és fájl értéke a c:\szov\olv.txt szöveg

 

A szöveg típusú változók Length tulajdonsága megadja a szöveg karaktereinek számát.
pl.:

string s="dinnye"; int i=s.Length;

//i=6

A string típus hasznos függvényei:

CompareTo(string)

Két szöveg összehasonlítását végzi. Ha azonos a két szöveg, az eredmény 0. Szövegeknél a rendezettséget (Unicode) kód szerinti sorrend képviseli.
Pl.:

  string kilenc="9", ezer="1000"; a="alma", b="almafa";

  if (kilenc.CompareTo(ezer)>0)

     Console.Writeline("Szövegek esetén más a rendezettség, mint számoknál!");

  if (a.CompareTo(b)<0)

     Console.WriteLine("Rövidebb szöveg megelőzi a hosszabb, ugyanolyan kezdetű szöveget!")

A példában mindkét feltétel teljesül, és a kiírások megjelennek a képernyőn.

Equals(string)

Szövegegyenlőséget vizsgál, használható helyette a == operátor is.

IndexOf(string)

Többféle módon használható. Megadja, hogy a szövegben melyik indexnél található a paraméterként megadott szöveg. Ha nem található meg benne, akkor -1 lesz a visszaadott érték.
Pl.:

   int k="mentőcsónak".IndexOf("só");    // k értéke 6

Insert(int, string)

A második paraméterül megadott szöveget, az első paraméterként megadott indextől kezdve beszúrja a szövegbe.
Pl.:

  string s="kulcs alatt";

  string s1=s.Insert(5," a lábtörlő");   // kulcs a lábtörlő alatt

Ha szövegkezelő függvényekkel az eredeti szöveget akarjuk változtatni, akkor a System.Text névtér StringBuilder osztályát használjuk.
Pl.:

  StringBuilder s =  new StreamBuilder("erdő mellett");

  s.Insert(4," a város");   // erdő a város mellett

ToLower()

A nagybetűket kicsire cseréli a szövegben.
Pl.:

string s = "veGYes";

Console.WriteLine(s.ToLower());    // az eredmény vegyes

ToUpper()

A kisbetűket nagyra cseréli a szövegben.
Pl.:

string s = "veGYes";

Console.WriteLine(s.ToUpper());    // az eredmény VEGYES

Split(char[])

Darabokra tördeli a szöveget meghatározott karakterek mentén.
Pl.:

string[] darabok = new string[4];

string s = "kutya;macska;kacsa;liba";

darabok = s.Split(';'); // darabok[0]="kutya", darabok[1]="macska", ....

foreach (string x in darabok)

  Console.WriteLine(x); // kiírja a darabok tömb elemeit

char[] vág ={ '2', '3', '4' };  // a vágás helyét kijelölő karakterek,

s="ci2ca4madár4hal3béka";

darabok = s.Split(vág); // darabok[0]="ci", darabok[1]="ca", darabok[2]="madár" ....

Replace(...)

Szövegrészeket, illetve karaktereket lehet vele lecserélni .
Pl.:

string szöveg = "Itt egy virág, ott egy virág.";

Console.WriteLine(szöveg.Replace("virág","bokor"));  // a kiírás: Itt egy bokor, ott egy bokor. 

string név = "Zita";

Console.WriteLine(név.Replace('Z', 'R'));  // a kiírás: Rita

Contains(string)

Megadja, hogy egy adott karaktersorozat szerepel-e a szövegben, vagy nem.

StartsWith(...), EndsWith(...)

Megadják, hogy a szöveg az adott karaktersorozattal kezdődik, illetve végződik-e. A függvények visszatérési értéke a megfelelő logikai érték.
Pl.:

string s = "Esik az eső, ázik a mező";

if (s.StartsWith("Esik") && s.EndsWith("ző"))   // mindkét feltétel igaz és a kiírás megtörténik

    Console.WriteLine("Hurrá!"); 

Szám típusok

int (uint)	egész (előjel nélküli egész) típus (4 byte)
long (ulong)	hosszú egész (előjel nélküli) hosszú egész (8 byte)
short (ushort)	rövid (előjel nélküli) egész (2 byte)
sbyte (byte)	előjeles (előjel nélküli) byte
float	valós (4 byte)
double	dupla pontosságú valós (8 byte)

void

Típus nélküli típus, olyan függvénynek a típusa, amely nem ad vissza értéket.

bool

Logikai típus, helyfoglalása 1 byte, értéke true (igaz) vagy false (hamis) lehet.

A típusok közötti konverziót segítik a Convert osztály megfelelő függvényei, pl Convert.ToInt32(szöveg), Convert.ToDouble(szöveg), ezek a zárójelben megadott szöveget int illetve double típusúvá konvertálják. (Ugyanezt teszi az int.Parse(szöveg), illetve a double.Parse(szöveg).) Számokat szövegként minden további nélkül használhatunk, például szöveghez hozzáfűzhetjük őket, mert minden számtípusnak van egy beépített ToString függvénye, amely ilyenkor automatikusan meghívódik. Grafikus alkalmazások a beírt adatokat szövegként kezelik, ha számolni akarunk velük, akkor először konvertálni kell őket.

Összetett típusok

Tömb (sorozat)

Azonos típusú adatokat tartalmaz, az egyes elemekre index segítségével hivatkozunk. A tömbök indexelése 0-val kezdődik. A tömbök definíciója:
típus[] név;
A típus tetszőleges, az elemszámot nem kell megadni. Egy tömb típusú változó inicializálása a new operátorral történik, ekkor kell az elemszámot meghatározni.
Pl.:

int[] számok;
számok = new int[10];	//10 egész számot tartalmazó tömb

Kezdőértékeket { és }között vesszővel elválasztva adhatunk meg. A Length tulajdonság a tömb elemszámát adja. Használhatunk többdimenziós tömböket, valamint tömbökből álló tömböt, a kettőt keverhetjük is. A Rank tulajdonság a tömb dimenziószámát adja.
Pl.:

int[,] matrix = new int[5,6];	// 5 soros 6 oszlopos tömb, egészeket tartalmaz
matrix[1,2]=13;	//az 1. sor 2.oszlopbeli eleme 13-at kap értékül
int [][,] m;	//m egy olyan tömb, melynek minden eleme egy kétdimenziós tömb.

Struktúra

Lehetővé teszi, hogy különböző jellegű összetartozó adatokat egy egységként kezeljünk. Definíciója a következő formában történik:
struct név {
 hozzáférés típus mezőnevek;
 ....
 hozzáférés függvénydefiníció;
};
A hivatkozás egy mezőre változónév.mezőnév alakban történik. A hozzáférés private (csak struktúrán belülről érhető el), public (szabadon elérhető) és internal (programon belülről elérhető) lehet. Az adatmezőknek nem adhatunk a definiálás pillanatában kezdőértéket. Alapértelmezett beállítás a private.
Pl.:

struct diák

{

public string név;

public int kor;

}

diák[] diákok = new diák[5];

diákok[0].név="Ági";

diákok[0].kor=17;

Műveletek, operátorok, kifejezések

A nyelv számunkra fontos operátorai a prioritásnak megfelelő sorrendben a következők:

Egyoperandusú operátorok:

new a futás közbeni, azaz dinamikus helyfoglalás operátora. Az operandusa határozza meg, hogy milyen típusú objektumnak foglal helyet. Sikeres helyfoglalás eredménye a lefoglalt memória címe, sikertelené pedig a null mutató.
Pl.:

x=new int[3];

//3 egészet tartalmazó x nevű tömb számára foglal helyet a memóriában

A .NET keretrendszer automatikusan elvégzi a lefoglalt memóriaterület felszabadítását, ha a programnak már nincs rá szüksége.

-	aritmetikai negálás
!	logikai negálás
~	bitenkénti negálás
++, --	eggyel növelés, ill. csökkentés

Pl.:

j=++i;	// i=i+1; j=i; tömören írva
j=i++;	// j=i; i=i+1; tömören írva
double x=6.1;
int i =(int) x;	// i=6

Az egyoperandusú operátorok és az értékadás operátora esetén jobbról balra történik a végrehajtás, egyébként azonos precedenciájú operátoroknál balról jobbra.

Háromoperandusú operátor

Valójában egy logikai elágazás utasítás, a tömörebb írásmódot szolgálja. Alakja:
kif1 ? kif2 : kif3
Ha kif1 értéke igaz (nem 0), akkor az egész kifejezés értéke kif2, különben kif3.
Pl.:

x=a>b?a+2:b+2;	// ennek eredménye megegyezik az alábbi kód eredményével
if (a>b) x=a+2; else x=b+2;

Kétoperandusú operátorok

*	szorzás
/	osztás
%	maradékképzés, a maradékképzés operandusai egészek.

Mindig igaz: (a/b)*b+a%b=a

+	összeadás, szöveg esetén összefűzés
-	kivonás
<<	bitenkénti balra léptetés
<, >	kisebb, nagyobb relációs operátorok
<=, >=	kisebb vagy egyenlő, nagyobb vagy egyenlő operátorok
==, !=	egyenlő, nem egyenlő relációs operátorok
&	bitenkénti és
^	bitenkénti kizáró vagy
|	bitenkénti vagy
&&	logikai és
||	logikai vagy

Kétoperandusú értékadó operátorok

= értékadás operátora.
Az értékadás során a bal oldal megkapja a jobb oldali kifejezés értékét(, és egyben ez lesz a kifejezés értéke is).
További értékadó operátorok, amelyek a hatékonyabb, tömörebb programkódot eredményeznek:
+=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=
A kif1 valamelyik_operátor_az_előző_sorból kif2 kifejezés megfelel a kif1 = kif1 op kif2 kifejezésnek, ahol op az egyenlőségjel előtti operátor.
Ha matematikai számításokra van szükség, akkor a System névtér Math osztálya segít, pl.:

Math.Sqrt(x)	x négyzetgyöke
Math.Abs(x)	x abszolút értéke
Math.Round(x)	kerekítés a matematikai szabályok szerint
Math.Ceiling(x)	felfelé kerekítés
Math.Floor(x)	lefelé kerekítés
Math.Power(x,y)	hatványozás, x az alap, y a kitevő
Math.PI	3.14159265358979323846

Gyakran van szükség véletlen számokra. A System névtér Random osztálya biztosítja a pszeudo-véletlenszámok generálásának lehetőségét.
Pl.:

Random x=new Random();	// x véletlenszám objektum (a rendszeridőből generálva)
Random x1=new Random(10);	// x1 véletlenszám objektum (a 10 értékből kiindulva)
int i=x.Next();	// véletlen egész szám 0 és MaxInt között, 0 lehet, MaxInt nem // MaxInt a legnagyobb egész számot jelöli
int i1=x.Next(100);	// véletlen egész szám 0 és 100 között, 0 lehet 100 nem
int i2=x.Next(100,200);	// véletlen egész szám 100 és 200 között, 100 lehet 200 nem
double a=x.NextDouble();	// véletlen valós szám 0 és 1 között, 0 lehet 1 nem

Utasítások

A program végrehajtása során az operációs rendszer a Main függvénynek adja át vezérlést, a Main-ben leírt utasítások "működnek" egymás után, ezután visszakapja a vezérlést az operációs rendszer.
Utasításfajták:

• összetett utasítás
• egyszerű utasítás
• elágazás utasítás
• ciklus utasítás
• ugró utasítás

Összetett utasítás

Az összetett utasítás { } zárójelek közé írt utasításokból áll, szokták blokknak is nevezni. Blokkon belül változók is deklarálhatók, ezek a blokkon belül "élnek". Blokkokat tetszőlegesen egymásba lehet ágyazni.

Egyszerű utasítás

Az utasítás alakja:
kifejezés;
Speciális esete az üres utasítás, amikor a kifejezés elmarad.
Pl.:

i++;           // i értékét eggyel növeli

a=b+2;

a+=3;          // a értéke 3-mal nő

lnko(a,b);     // lnko nevű függvény hívása a és b paraméterekkel

Elágazás utasítás

Egyik fajtája:
if (kifejezés) utasítás;
if (kifejezés) utasítás1; else utasítás2;
A kifejezés igaz értéke esetén a kifejezés utáni utasítás hajtódik végre. Ha a kifejezés értéke hamis, akkor az első esetben az if utáni utasítás, a második esetben az else utáni utasítás kerül végrehajtásra. Ha több if utasítás van egymásba ágyazva, akkor az else ág a legutóbbi else nélküli if utasításhoz tartozik. Ha a második változatban az igaz ágon összetett utasítás szerepel, akkor nem szabad utána pontosvesszőt tenni, mert az az if lezárását jelentené.
Pl.:

if (a==5) Console.WriteLine(" Az a változónak 5 az értéke");  // ha a értéke 5, a kiírás megtörténik, künönben semmi hatása nincs

if (a>b) a++; else b++;    // ha a nagyobb mint b, akkor a értéke nő eggyel, különben b értéke nő eggyel

if (x>y)

{

               a=x+2;

               b=y+3;

}    // itt nem lehet ; mert van else ág

else

{

               a=y+2;

               b=x+3;

}

Másik fajtája a többirányú elágazás, ennek alakja:

switch (kifejezés)

{

               case érték1: utasítás1;

               case érték2: utasítás2;

                  ...

               default: utasítás;

}

A switch utáni kifejezés egész, vagy szöveg értékű lehet. Ha a kifejezés értéke a case után megadott értékkel nem egyezik, akkor a következő case vizsgálata következik. Ha a kifejezés értéke megegyezik a case utáni értékkel, akkor az ez utáni utasítás végrehajtódik. A default ág akkor kerül végrehajtásra, ha egyik case utáni értékkel sem egyezett meg a kifejezés értéke. Minden ágat kötelező valamilyen vezérlésátadással befejezni. Erre leggyakrabban a break utasítást használjuk. A case után csak egyetlen érték szerepelhet.
Pl.:

switch (körzetszám)

{

  case 20:

    Console.WriteLine("Pannon");

    break;

  case 30:

    Console.WriteLine("TeleCom");

    break;

  default:

    Console.WriteLine("Egyéb");

    break;

}

Ciklus utasítás

A C#-ban négy fajta ciklus utasítás van, ezek a while, a do, a for és a foreach.
A while utasítás formája:
while (kifejezés) utasítás;
Először a kifejezés értékelődik ki, ha igaz az értéke, akkor az utasítás (ciklusmag) végrehajtódik, majd a kifejezés újból kiértékelődik, ha igaz az értéke, akkor az utasítás újból végrehajtódik, ez az ismétlődés mindaddig folytatódik, amig a kifejezés értéke hamissá nem válik. Ezt a ciklus utasítást szokás elöltesztelő ciklusnak nevezni. Ennél a ciklusfajtánál előfordulhat, hogy az utasítás egyszer sem hajtódik végre.
Pl.:

   int a=7;

   while (a < 200)

   {

    Console.WriteLine(a);

    a += 3;

   }

//az eredmény egy számtani sorozat 7-tel kezdve 3-as lépésközzel 199-ig.

A do utasítás formája:
do utasítás; while (kifejezés);
Az utasítás (ciklusmag) végrehajtása után értékeli ki a kifejezést, és ha igaz az értéke, újból végrehajtja az utasítást, majd újból kiértékeli a kifejezést, és így tovább. A do ciklust szokták hátultesztelő ciklusnak nevezni. Itt az utasítás egyszer biztosan végrehajtódik. Pl.:

  string s;

  do

  {

               Console.WriteLine("Gépelj valamit!");

               s=Console.ReadLine();

  }

  while      (s=="");

//addig ismétlődik, amíg a felhasználó be nem gépel valamit.  "" jelöli az üres szöveget.  

A for utasítás formája:
for (kifejezés1; kifejezés2; kifejezés3) utasítás;
Ez egyenértékű a következő alakkal

kifejezés1;

while (kifejezés2)

{

               utasítás;

               kifejezés3;

}

Mindegyik kifejezés elmaradhat, de a pontosvesszők nem.
Pl.:

for (a=7; a < 200; a += 3;)

               Console.WriteLine(a);

//az eredmény a már említett számtani sorozat 7-tel kezdve 3-as lépésközzel 199-ig.

for (; ; ;)

// nem csinál semmit, de azt a végtelenségig, végtelen ciklus.

A foreach utasítás formája:
foreach (azonosító in sorozat) utasítás;
Az azonosító egyenként felveszi értékül a sorozat elemeit.
Pl.:

//egy nemnegatív 100-nál kisebb számokból álló t sorozatban megszámoljuk hány egy-, illetve kétjegyű szám van.

int[] t = new int[] { 1, 3, 7, 11, 5, 88, 55, 22, 12};

int egyjegyű = 0, kétjegyű=0;

foreach (int x in t)

{

  if (x<10)

      egyjegyű++;

  else

      kétjegyű++;

}

Console.WriteLine("A t sorozatban {0} egyjegyű és {1} kétjegyű szám van.", egyjegyű, kétjegyű);

Ugró utasítások

A break utasítás formája:
break;
Hatására befejeződik a legbelső while, for vagy switch utasítás végrehajtása. A programvégrehajtás a következő utasítással folytatódik. A switch utasításban a nem kívánt case ágak végrehajtását lehet vele elkerülni.
A continue utasítás formája:
continue;
Hatására a legbelső while, for, do ciklus vezérlő kifejezései, feltételei kerülnek kiértékelésre. A ciklus a ciklusmag további részét átugorja, és a következő ismételt ciklusmag-végrehajtásba kezd bele, vagy kilép, ha a vezérlőfeltételek úgy kívánják.
A return utasítás hatására a vezérlés visszatér a függvényből. Formája:
return;
return kifejezés;
return (kifejezés);

Input/Output a C#-ban

Adatok beolvasását és kiírását beépített könyvtári szolgáltatások biztosítják számunkra. Console alkalmazások készítésekor a billentyűzetről történő beolvasást és a képernyőre történő kiírást a System névtér a Console osztálya teszi lehetővé. A fájlból való olvasást, illetve fájlba történő írást a System.IO névtér osztályainak felhasználásával érjük el. A leírásban csak szöveges fájlok kezelésével foglalkozunk. Érdemes megjegyezni, hogy tizedes törtek beolvasásakor tizedes vesszőként a Windows beállításaiban megadott karaktert kell használni.
Számunkra a követkesző függvények fontosak:
Read() egy karaktert olvas, és a beolvasott karakter kódját, mint egész számot adja eredményül.
ReadLine() egy sort olvas be, az eredmény a beolvasott adat, mint szöveg.
Write() kiírja a paraméterül kapott adatokat.
WriteLine() ugyancsak kiírja a paraméterül kapott adatokat, majd új sort kezd.

Adatbeolvasás a billentyűzetről, adatkiírás a képernyőre

Leggyakrabban a Console.ReadLine() függvényt használjuk. A billentyűzetről történő adatbevitelt mindig az Enter leütésével kell lezárni. Ha a beolvasott adatot nem szövegként akarjuk kezelni, gondoskodni kell a megfelelő átkonvertálásról. Ha egy sorban több adat szerepel valamilyen elválasztó karakterrel, akkor a beolvasás után megfelelően szétdaraboljuk az elválasztó karakterek mentén a sort.
Console alkalmazások esetén a programablak becsukódását lehet megakadályozni a Console.ReadKey() függvénnyel, ez valamilyen billentyű leütését érzékeli és addig várakoztat, amíg ez meg nem történik.
Kiírásra a Console.Write(), illetve a Console.WriteLine() függvényeket használjuk, a zárójelben a kiírandó adatokat kell megadni. Ha a Write() függvényt alkalmazzuk, akkor a rákövetkező kiírás folytatólagosan történik, ha a WriteLine() függvényt, akkor a rákövetkező kiírás mindig új sorba kerül. A kiírás tagolására, valamint speciális jelek megjelenítésére az escape szekvenciákat használjuk.
A C# alaptípusai
A változóknak kötelező megadni a típusát, ennek legegyszerűbb formája:
típus változónév;
pl.:
char c;  // a c változó karakter típusú
int kicsi, nagy;  // a kicsi változó és a nagy változó egész típusú
float g=59.71F;            // a g valós típusú változó 59.71 kezdőértékkel
A változók lehetnek külsők, azaz függvényen kívüliek, vagy belsők, azaz függvényen belüliek. A függvényen kívüli változók osztályon belüliek lehetnek. A belső változók élettartama a blokkban való tartózkodás idejére korlátozódik. Ha a blokk végrehajtása befejeződött, megszünnek létezni.

A static szó használatával lehet statikus élettartamú külső változókat definiálni, számukra a fordító foglal helyet a memóriában, élettartamuk megegyezik az egész program élattartamával.

Állandók megadása:
const típus név=érték;
pl.:

const int pici=1;
Ha a programban az állandóként definiált változó értékét meg akarjuk változtatni, a fordító hibát jelez.

Elemi típusok
char
Karakter típus (2 byte hosszú). Unikód kódolást használ, a változó értékét aposztróf (') között adjuk meg.
pl.:

char c='A';
A backslash (\) karakter speciális jelentéssel bír. A segítségével használható úgynevezett escape szekvenciák a következők:

\a         a 7-es kódú csipogás
\b         backspace, előző karakter törlése
\f          formfeed, soremelés karakter
\r          kocsi vissza karakter
\n         új sor karakter (soremelés+kocsi vissza)
\t          tabulátor karakter
\v         függőleges tabulátor
\\          backslash karakter
\'          aposztróf
\"          idézőjel
\?         kérdőjel
\uXY    XY unikódú karakter, X és Y 16-os számrendszerbeli kétjegyű számok
string
Karaktersorozat (szöveg), a System.String osztálynak megfelelő típus. Szövegek esetén a + és a += szövegösszefűzést végző operátorok. A [] operátor a szöveg adott indexű karakterét jelöli, az indexelés 0-val indul. A @ karakter kiküszöböli a szövegen belüli érzékeny karakterek hatását. Ilyen például a backslash (\) karakter.
Pl.

char c='\u0092';           // c = a 92-es kódú (\) karakterrel
string s="citrom";         
string n=s+"héj";           // n=citromhéj
s+="fű";           //s=citromfű
char c1=s[2];   // c1=t
char c2="szia"[1];        // c2=z
string f="c:\\szov\\olv.txt";        
string fájl=@"c:\szov\olv.txt";    // f és fájl értéke a c:\szov\olv.txt szöveg

A szöveg típusú változók Length tulajdonsága megadja a szöveg karaktereinek számát.
pl.:

string s="dinnye"; int i=s.Length;           //i=6
A string típus hasznos függvényei:
CompareTo(string)
Két szöveg összehasonlítását végzi. Ha azonos a két szöveg, az eredmény 0. Szövegeknél a rendezettséget (Unicode) kód szerinti sorrend képviseli.
Pl.:

  string kilenc="9", ezer="1000"; a="alma", b="almafa";
  if (kilenc.CompareTo(ezer)>0)
     Console.Writeline("Szövegek esetén más a rendezettség, mint számoknál!");
  if (a.CompareTo(b)<0)
     Console.WriteLine("Rövidebb szöveg megelőzi a hosszabb, ugyanolyan kezdetű szöveget!")
A példában mindkét feltétel teljesül, és a kiírások megjelennek a képernyőn.

Equals(string)
Szövegegyenlőséget vizsgál, használható helyette a == operátor is.

IndexOf(string)
Többféle módon használható. Megadja, hogy a szövegben melyik indexnél található a paraméterként megadott szöveg. Ha nem található meg benne, akkor -1 lesz a visszaadott érték.
Pl.:

   int k="mentőcsónak".IndexOf("só");    // k értéke 6
Insert(int, string)
A második paraméterül megadott szöveget, az első paraméterként megadott indextől kezdve beszúrja a szövegbe.
Pl.:

  string s="kulcs alatt";
  string s1=s.Insert(5," a lábtörlő");   // kulcs a lábtörlő alatt
Ha szövegkezelő függvényekkel az eredeti szöveget akarjuk változtatni, akkor a System.Text névtér StringBuilder osztályát használjuk.
Pl.:
  StringBuilder s =  new StreamBuilder("erdő mellett");
  s.Insert(4," a város");   // erdő a város mellett
ToLower()
A nagybetűket kicsire cseréli a szövegben.
Pl.:

string s = "veGYes";
Console.WriteLine(s.ToLower());    // az eredmény vegyes
ToUpper()
A kisbetűket nagyra cseréli a szövegben.
Pl.:

string s = "veGYes";
Console.WriteLine(s.ToUpper());    // az eredmény VEGYES
Split(char[])
Darabokra tördeli a szöveget meghatározott karakterek mentén.
Pl.:

string[] darabok = new string[4];
string s = "kutya;macska;kacsa;liba";
darabok = s.Split(';'); // darabok[0]="kutya", darabok[1]="macska", ....
foreach (string x in darabok)
  Console.WriteLine(x); // kiírja a darabok tömb elemeit
char[] vág ={ '2', '3', '4' };  // a vágás helyét kijelölő karakterek,
s="ci2ca4madár4hal3béka";
darabok = s.Split(vág); // darabok[0]="ci", darabok[1]="ca", darabok[2]="madár" ....

Replace(...)
Szövegrészeket, illetve karaktereket lehet vele lecserélni .
Pl.:

string szöveg = "Itt egy virág, ott egy virág.";
Console.WriteLine(szöveg.Replace("virág","bokor"));  // a kiírás: Itt egy bokor, ott egy bokor.
string név = "Zita";
Console.WriteLine(név.Replace('Z', 'R'));  // a kiírás: Rita
Contains(string)
Megadja, hogy egy adott karaktersorozat szerepel-e a szövegben, vagy nem.

StartsWith(...), EndsWith(...)
Megadják, hogy a szöveg az adott karaktersorozattal kezdődik, illetve végződik-e. A függvények visszatérési értéke a megfelelő logikai érték.
Pl.:

string s = "Esik az eső, ázik a mező";
if (s.StartsWith("Esik") && s.EndsWith("ző"))   // mindkét feltétel igaz és a kiírás megtörténik
    Console.WriteLine("Hurrá!");
Szám típusok
int (uint)           egész (előjel nélküli egész) típus (4 byte)
long (ulong)      hosszú egész (előjel nélküli) hosszú egész (8 byte)
short (ushort)   rövid (előjel nélküli) egész (2 byte)
sbyte (byte)      előjeles (előjel nélküli) byte
float     valós (4 byte)
double  dupla pontosságú valós (8 byte)
void
Típus nélküli típus, olyan függvénynek a típusa, amely nem ad vissza értéket.
bool
Logikai típus, helyfoglalása 1 byte, értéke true (igaz) vagy false (hamis) lehet.
A típusok közötti konverziót segítik a Convert osztály megfelelő függvényei, pl Convert.ToInt32(szöveg), Convert.ToDouble(szöveg), ezek a zárójelben megadott szöveget int illetve double típusúvá konvertálják. (Ugyanezt teszi az int.Parse(szöveg), illetve a double.Parse(szöveg).) Számokat szövegként minden további nélkül használhatunk, például szöveghez hozzáfűzhetjük őket, mert minden számtípusnak van egy beépített ToString függvénye, amely ilyenkor automatikusan meghívódik. Grafikus alkalmazások a beírt adatokat szövegként kezelik, ha számolni akarunk velük, akkor először konvertálni kell őket.

1. példa: Beolvassuk egy egész, egy valós és egy szöveg típusú változó értékét a billentyűzetről, a három adat egyenként kerül beolvasásra:

  int egész;

  double valós;

  string szöveg;

  Console.Write("Az egész változó értéke: ");

  egész = Convert.ToInt32(Console.ReadLine());    // a beolvasott adatot 32 bites egésszé konvertáljuk

  Console.Write("A valós változó értéke: ");

  valós = Convert.ToDouble(Console.ReadLine());  // dupla pontosságú valós számmá konvertáljuk a beolvasott adatot 

  Console.Write("A szöveg változó értéke: ");

  szöveg = Console.ReadLine();

2. példa: Beolvasunk 5 valós számot úgy, hogy a számokat egy sorba írjuk, egy szóközzel elválasztva egymástól. Egyetlen ReadLine() hívással olvassuk be az adatokat, a beolvasott szövegként kezelt sort a szóközök mentén darabokra törjük, és a darabokat számmá konvertáljuk.

double[] valós5 = new double[5];

string[] darabok = new string[5];

string sor; 

char[] elválasztó =new char[]{' '};

Console.WriteLine("Írj 5 valós számot egymás után egy szóközzel elválasztva!");

sor = Console.ReadLine();

darabok = sor.Split(elválasztó);

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

{

               valós5[i] = Convert.ToDouble(darabok[i]);

               Console.WriteLine(valós5[i]);

}

  

A Write(szöveg, adat, ...) illetve WriteLine(szöveg, adat, ...) módon paraméterezett kiírásokkal előre formázott megjelenést érhetünk el. A szövegben kapcsos zárójelek közé írt sorszámmal, és a formázást meghatározó karaktersorozattal jelezzük, a kiírandó adatok helyét és formátumát a következő alakban:
{sorszám[, szélesség][:forma]}
A [] közötti részek elhagyhatók. A sorszám azt jelöli, hogy a szöveg után felsorolt adatok közül hányadikat kell kiírni. Itt is 0-val kezdődik a sorszámozás. A szélesség, ha van, a teljes szélességet határozza meg. Ha pozitív, akkor jobbra, ha negatív, akkorbalra igazítva jeleníti meg az adatot a szélességen belül. Ha az adat rövidebb a megadott szélességnél, akkor szóközökkel tölti fel a szabadon maradt helyet. A kettőspont utáni rész, ha van, a kiírandó adat típusát és formáját szabályozza. A következő karaktereket használja:

c	pénznembeli kijelzés
e	tudományos kijelzés
x	hexadecimális forma
0	mindig megjelenítendő helyiérték
#	csak akkor jeleníti meg, ha van ott érték
.	a tizedes vessző helye

Pl.:

int i = 310, k = 256;

float g = 9.81F;

Console.WriteLine("Az i változó értéke: {0}\nA k változó éréke: {1}", i, k);

 // A 310 a {0}, a 256 a {1} helyére kerül, \n új sort kezd

Console.WriteLine("A számla értéke: {0:c}", i);  // 310,00 Ft

Console.WriteLine("16-os számrendszerben k értéke: {0,6:x}", k);

// 6 karakter széles 16-os számrenszerbeli kijelzés (   100)

Console.WriteLine("A g változó értéke: {0,10:00.000}", g);

// 10 karakter széles kijelzés 3 tizedes jeggyel (    09,810)

Console.WriteLine("A g változó értéke:{0:0.00e+0}", g); // 9,81e+0

Szövegfájlok használata

Ahhoz hogy szöveges fájlokkal kapcsolatos műveleteket tudjunk végezni, a System.IO névtér StreamReader illetve StreamWriter osztályaira van szükségünk. Ha egy szövegfájból adatokat akarunk beolvasni, akkor egy StreamReader típusú objektumot hozunk létre, ha adatokat szeretnénk írni egy fájlba, akkor StreamWriter típusú objektumot használunk.
3. példa: Létrehozunk a készülő programunk könyvtárában egy szöveg.txt nevű szövegfájlt. Beleírunk két sort aztán a fájl tartalmát soronként kiírjuk a képernyőre. Végül hozzáírunk a már létező fájhoz még egy sort.

string név = "szöveg.txt";

StreamWriter ki = new StreamWriter(név);

// létrehoz egy szöveg.txt fájlt a program könyvtárában, ha már van ilyen, akkor fölülírásra nyitja meg.

ki.Write("Ez az első sor eleje");

ki.WriteLine(", itt jön az első sor folytatása és vége.");

ki.WriteLine("Ez itt új sorba kerül.");

ki.Close();

StreamReader be = new StreamReader(név);

string sor;

do

{

   sor = be.ReadLine();

   Console.WriteLine(sor);

}

while (!be.EndOfStream);

be.Close();

ki = new StreamWriter(név, true);

// megnyitja a már létező szöveg.txt fájlt, a kiírás hozzáfűződik a korábbi tartalomhoz.

ki.WriteLine("Hozzáírunk a már létező fájlhoz egy újabb sort.");

ki.Close();

Fájlokat elérési úttal együtt is megadhatunk, a string típusnál leírt módon. A File.Exists() függvény megadja, hogy egy fájl létezik-e, vagy sem.

Függvények

Függvények használatával összetett programot részekre lehet tagolni, átláthatóbb kódot lehet írni. Egy függvényt egyszer le kell írni, azaz megadni, hogy milyen típusú értéket ad vissza, milyen paramétereket használ, milyen típusú saját változói vannak, milyen utasításokat hajt végre. Ennek módja:

  visszaadott_érték_típusa függvénynév(argumentumok_ha_vannak)

  {

                 változók deklarációja;

                 utasítások;

  }

Függvénynek paraméterként kétféle módon adhatunk adatokat: érték szerint illetve cím (más elnevezéssel referencia) szerint. Érték szerinti paraméterátadás esetén a függvény az adat értékének másolatával dolgozik, cím szerinti paraméterátadás esetén a függvény az adat címét kapja meg. Ha érték szerint átadott adatot változtatunk egy függvényben, a függvényből kilépve az adaton nem látszik a változás, ha cím szerint átadott adatot változtatunk egy függvényben, akkor a változás a függvényből kilépve is megmarad. Érték szerinti paraméternek nincs külön jelzése, cím szerint átadni kívánt paraméter elé a ref szócskát kell beszúrni. A ref szócskát híváskor is ki kell írni. a kerek zárójeleket akkor is ki kell tenni a függvénynév után, ha nincsenek paraméterei.
A függvénynév előtti típusjelzés a függvény visszatérési értékének típusát határozza meg. A visszatérési értéket a return utasítás után írt kifejezés értéke adja. Ha nincs szükség visszatérési értékre, akkor a void jelzést használjuk és a return utasítást nem követi kifejezés.
Példáinkban szerepel még a típusjelzés előtt a static jelölés, ez a függvények statikus voltát jelzi. Egyszerű, egyetlen osztályból álló programokban csak statikus függvényeket lehet használni.
1. példa - érték szerinti paraméterátadás:

class Program

{

   static void változtat(int a) // Itt kezdődik a függvényleírás, itt TILOS a ;

   {

      ...

      a = 100;

      return; // Itt ér véget a függvényleírás

   }

   static void Main(string[] args)

   {

      int x = 5; 

      változtat(x);

 // Az előző sor hívja meg a függvényt, azaz hajtja végre a függvény utasításait a megadott x paraméter értékével

      Console.WriteLine(x);  // 5 lesz a kiírás eredménye 

      Console.ReadKey();

   }

}

2. példa - referencia szerinti paraméterátadás

class Program

{

   static void változtat(ref int a)

   {

      ...

      a = 100;

      return;

   }

   static void Main(string[] args)

   {

      int x = 5; 

      változtat(ref x);

      Console.WriteLine(x);  // 100 lesz a kiírás eredménye 

      Console.ReadKey();

   }

}

Ha egy függvénynek több eredményt kell adnia, akkor eredményváltozókat használhatunk, ezeket az eléjük írt out szócska jelzi. Az out jelzőt híváskor is ki kell írni. Az eredmény paramétereknek a függvényből történő kilépéskor értékkel kell rendelkezni.
3. példa: A leírt hányados_maradék függvény két pozitív egészet vár paraméterül, ha mindkét paraméter pozitív akkor 1-et ad visszatérési értékül, különben -1-et. Pozitív paraméterek esetén kiszámolja a két szám egészosztással képzett hányadosát és maradékát és ezt két eredmény paraméterben adja vissza.

class Program

{

    static void Main(string[] args)

    {

      int x = 13, y = 3, z, v;

      if (hányados_maradék(x,y, out z, out v) == 1)

          Console.WriteLine("{0} és {1} egész hányadosa: {2}, a maradék: {3}", x, y, z, v);

      else

          Console.WriteLine("A hányados_maradék függvény pozitív paraméterekkel működik!");

      Console.ReadKey();

    }

    static int hányados_maradék(int a, int b, out int h, out int m)

    {

      h = 0;

      m = 0;

      if ((a <= 0) || (b <= 0))

         return -1;

      h = a / b;

      m = a % b;

      return 1;

    }

}

Tömbök paraméterként természetesen cím szerint kerülnek átadásra.
4. példa: A tömb_összeg függvény egy paraméterként megkapott egész számokból álló tömb elemeinek összegét számolja ki.

class Program

{

    static void Main(string[] args)

    {

      int[] sorozat ={ 1, 5, -7, 10 };

      Console.WriteLine(tömb_összeg(sorozat)); // 9 lesz a kiírt szám 

      Console.ReadKey();

    }

}

    static int tömb_összeg(int[] tömb)

    {

      int összeg = 0;

      foreach (int x in tömb)

      összeg += x;

      return összeg;

    }

}

Függvényleírásokat nem ágyazhatunk egymásba, de egy függvény meghívhatja önmagát. Az ilyen függvényeket rekurzív függvényeknek nevezik.
5. példa: Pozitív egész kitevőjű hatványozás megvalósítása rekurzív függvénnyel. (Feltételezzük, hogy a felhasználó olyan paramétereket ad meg, hogy a hatványozás során nem lép ki a függvény az dupla pontossággal ábrázolható számok köréből, és a megadott kitevő nem negatív.)

class Program

{

    static void Main(string[] args)

    {

                  Console.WriteLine(hatvány(2.5, 4)); // 39,0625 

            Console.ReadKey();

               }

               static double hatvány(double alap, int kitevő)

    {

      if (kitevő > 0)

         return alap*hatvány(alap, kitevő - 1);

         // az előző sorban hívja a függvény önmagát ugyanazzal az alappal és eggyel kisebb kitevővel                      

      else

         return 1;

    }

}

A main függvény paramétere egy arg nevű szövegtömb. Ritkán használjuk, a programnév után szóközökkel elválasztott adatok lesznek az arg elemei szövegként értelmezve.
6. példa: Egy olyan programot írunk, amely a program neve után írt számokat kilistázza a képernyőre és kiszámítja az összegüket. Ha az előállított program neve összead, a könyvtárában kiadott összead 2,3 4,5 6,6 parancs kilistázza soronként a beírt három számot, és a következő sorba kiírja az összegüket, ami 13,4. (Érdemes megjegyezni, hogy ha a program kódjába írunk tizedes törtet, akkor a pont a tizedes elválasztó jel, egyébként beolvasott vagy kiírt adatoknál a vessző.)

static void Main(string[] args)

{

   double osszeg=0;

   foreach (string x in args)

   {

      Console.WriteLine(x);

      osszeg += Convert.ToDouble(x);

   }

   Console.WriteLine("A beírt számok összege: " + osszeg+

                     "\n\nA kilépéshez nyomjon le egy billentyűt!");

   Console.ReadKey();

}

Egyszerű példa-programok

• Két szám legnagyobb közös osztója és legkisebb közös többszöröse
• Másodfokú egyenlet megoldása
• Az első 10000 prímszám előállítása és szövegfájlba írása
• lottósorsolás

Két szám legnagyobb közös osztója és legkisebb közös többszöröse

A program az Euklideszi algoritmust használja. Az algoritmus addig vonja ki a nagyobb számból a kisebb számot, amíg egyenlők nem lesznek. Az így kapott érték a két szám legnagyobb közös osztója.

int a, b, x, y;

Console.WriteLine("Írj be légy szíves 2 egész számot, kiírom a legnagyobb közös osztóját\nEgyik szám: ");

a = Int32.Parse(Console.ReadLine());

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

b = Int32.Parse(Console.ReadLine());

x=a;

y=b;

while (a != b)

{

   if (a > b)

      a = a - b;

   else

      b = b - a;

}

Console.WriteLine("A legnagyobb közös osztó: {0}\nA legkisebb közös többszörös: {1}",

                  a, x*y/a);

Console.ReadKey();

Másodfokú egyenlet megoldása

A következő programrész másodfokú egyenlet gyökeit keresi. Tovább lehet fejleszteni. Nincs megoldva benne az az eset, ha a másodfokú tag együtthatója 0. Az eredménykiírás formátumán is lehet javítani.

double a, b, c;



Console.WriteLine("   2\na x + b x + c = 0 egyenlet gyökeinek meghatározása\n");

Console.Write("a: ");

a = Convert.ToDouble(Console.ReadLine());

Console.Write("b: ");

b = Convert.ToDouble(Console.ReadLine());

Console.Write("c: ");

c = Convert.ToDouble(Console.ReadLine());

double d = Math.Pow(b,2) - 4 * a * c, gyök1, gyök2;

if (d < 0)

   Console.WriteLine("Nincs valós gyök.");

else

{

  if (d == 0)

  {

     gyök1 = -b / (2 * a);

     Console.WriteLine("Egy valós gyök van, értéke: {0}", gyök1);

  }

  else

  {

     gyök1 = (-b + Math.Sqrt(d)) / (2 * a);

     gyök2 = (-b - Math.Sqrt(d)) / (2 * a);

     Console.WriteLine("Két valós gyök van, értékük: {0} és {1}", gyök1, gyök2);

  }

}

Console.Write("A kilépéshez üss le egy billentyűt!");

Console.ReadKey();

Az első 10000 prímszám előállítása és szövegfájlba írása

A megoldás során a 2-es számot beírjuk elsőnek a prímek.txt nevű szövegfájlba. Ez a fájl a kész program könyvtárában jön létre. 3-tól kezdve végigvizsgáljuk a páratlan számokat, hogy van-e valódi osztójuk. Az osztó keresni csak a szám négyzetgyökéig érdemes. Ha nem találunk a számhoz osztót, akkor beírjuk mint soronkövetkező prímet a szövegfájlba.

StreamWriter prímek = new StreamWriter("prímek.txt");

prímek.WriteLine("2");

int szám=3, h=1, osztó;

const int db = 10000;

while(h<db)

{

  osztó=3;

  bool prím=true;

  while ((Math.Pow(osztó,2) <= szám) && prím)

  {

    if ((szám % osztó) == 0)

       prím = false;

    osztó += 2;

  }

  if (prím)

  {

     primek.WriteLine(szám);

     h++;

  }

  szám += 2;

}

prímek.Close();

Lottósorsolás

5 egész számot sorsolunk 1 és 90 között, és sorba rendezve kiíratjuk. A lottószámok előállításához a véletlen szám generátort használjuk. A generátor paraméter nélküli híváskor a rendszeridőt veszi alapul. A "húzás" során arra is kell figyelni, hogy ha olyan számot kapunk, ami már szerepel az eddig előállítottak között, akkor újat kell helyette generálni. Az öt lottószámot egy külön függvény rendezi sorba a buborék módszerrel.

int[]lotto_számok = new int[5];

int k;

Random kalap = new Random();

lotto_számok[0]=kalap.Next(1,91);

int húzások_száma = 1;

do

{

   lotto_számok[húzások_száma] = kalap.Next(1, 91);

   k=0;

   while (lotto_számok[k]!=lotto_számok[húzások_száma])

   k++;

   if (k == húzások_száma)

   húzások_száma++;

} while (húzások_száma<5);

rendezés(lotto_számok);

Console.Write("A kihúzott számok:");

foreach(int szám in lotto_számok)

Console.Write("\t"+szám);

Console.Write("\n\nA kilépéshez üss le egy billentyűt!");

Console.ReadKey();

A rendezés függvénye:

static void rendezés(int[] s)

        {

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

            {

                for (int j = 0; j < s.Length - i - 1; j++)

                {

                    int csere;

                    if (s[j + 1] < s[j])

                    {

                        csere = s[j];

                        s[j] = s[j + 1];

                        s[j + 1] = csere;

                    }

                }

            }

            return;

        }

Egyszerű példa-programok

Két szám legnagyobb közös osztója és legkisebb közös többszöröse

A program az Euklideszi algoritmust használja. Az algoritmus addig vonja ki a nagyobb számból a kisebb számot, amíg egyenlők nem lesznek. Az így kapott érték a két szám legnagyobb közös osztója.

int a, b, x, y;

Console.WriteLine("Írj be légy szíves 2 egész számot, kiírom a legnagyobb közös osztóját\nEgyik szám: ");

a = Int32.Parse(Console.ReadLine());

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

b = Int32.Parse(Console.ReadLine());

x=a;

y=b;

while (a != b)

{

   if (a > b)

      a = a - b;

   else

      b = b - a;

}

Console.WriteLine("A legnagyobb közös osztó: {0}\nA legkisebb közös többszörös: {1}",

                  a, x*y/a);

Console.ReadKey();

Másodfokú egyenlet megoldása

A következő programrész másodfokú egyenlet gyökeit keresi. Tovább lehet fejleszteni. Nincs megoldva benne az az eset, ha a másodfokú tag együtthatója 0. Az eredménykiírás formátumán is lehet javítani.

double a, b, c;



Console.WriteLine("   2\na x + b x + c = 0 egyenlet gyökeinek meghatározása\n");

Console.Write("a: ");

a = Convert.ToDouble(Console.ReadLine());

Console.Write("b: ");

b = Convert.ToDouble(Console.ReadLine());

Console.Write("c: ");

c = Convert.ToDouble(Console.ReadLine());

double d = Math.Pow(b,2) - 4 * a * c, gyök1, gyök2;

if (d < 0)

   Console.WriteLine("Nincs valós gyök.");

else

{

  if (d == 0)

  {

     gyök1 = -b / (2 * a);

     Console.WriteLine("Egy valós gyök van, értéke: {0}", gyök1);

  }

  else

  {

     gyök1 = (-b + Math.Sqrt(d)) / (2 * a);

     gyök2 = (-b - Math.Sqrt(d)) / (2 * a);

     Console.WriteLine("Két valós gyök van, értékük: {0} és {1}", gyök1, gyök2);

  }

}

Console.Write("A kilépéshez üss le egy billentyűt!");

Console.ReadKey();

Az első 10000 prímszám előállítása és szövegfájlba írása

A megoldás során a 2-es számot beírjuk elsőnek a prímek.txt nevű szövegfájlba. Ez a fájl a kész program könyvtárában jön létre. 3-tól kezdve végigvizsgáljuk a páratlan számokat, hogy van-e valódi osztójuk. Az osztó keresni csak a szám négyzetgyökéig érdemes. Ha nem találunk a számhoz osztót, akkor beírjuk mint soronkövetkező prímet a szövegfájlba.

StreamWriter prímek = new StreamWriter("prímek.txt");

prímek.WriteLine("2");

int szám=3, h=1, osztó;

const int db = 10000;

while(h<db)

{

  osztó=3;

  bool prím=true;

  while ((Math.Pow(osztó,2) <= szám) && prím)

  {

    if ((szám % osztó) == 0)

       prím = false;

    osztó += 2;

  }

  if (prím)

  {

     primek.WriteLine(szám);

     h++;

  }

  szám += 2;

}

prímek.Close();

Lottósorsolás

5 egész számot sorsolunk 1 és 90 között, és sorba rendezve kiíratjuk. A lottószámok előállításához a véletlen szám generátort használjuk. A generátor paraméter nélküli híváskor a rendszeridőt veszi alapul. A "húzás" során arra is kell figyelni, hogy ha olyan számot kapunk, ami már szerepel az eddig előállítottak között, akkor újat kell helyette generálni. Az öt lottószámot egy külön függvény rendezi sorba a buborék módszerrel.

int[]lotto_számok = new int[5];

int k;

Random kalap = new Random();

lotto_számok[0]=kalap.Next(1,91);

int húzások_száma = 1;

do

{

   lotto_számok[húzások_száma] = kalap.Next(1, 91);

   k=0;

   while (lotto_számok[k]!=lotto_számok[húzások_száma])

   k++;

   if (k == húzások_száma)

   húzások_száma++;

} while (húzások_száma<5);

rendezés(lotto_számok);

Console.Write("A kihúzott számok:");

foreach(int szám in lotto_számok)

Console.Write("\t"+szám);

Console.Write("\n\nA kilépéshez üss le egy billentyűt!");

Console.ReadKey();

A rendezés függvénye:

static void rendezés(int[] s)

        {

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

            {

                for (int j = 0; j < s.Length - i - 1; j++)

                {

                    int csere;

                    if (s[j + 1] < s[j])

                    {

                        csere = s[j];

                        s[j] = s[j + 1];

                        s[j + 1] = csere;

                    }

                }

            }

            return;

        }

Lexikális elemek
Lexikális elemek a kódban talalhátó szám, szöveg konstansok és megjegyzések.

    Konstansok
        Egész konstansok Hexadecimális konstans Egész konstans Oktális konstans
        Lebegőpontos konstansok Lebegőpontos konstans
        Logikai konstansok Logikai igaz konstans: true Logikai hamis konstans: false
    Megjegyzések Egysoros megjegyzés: // Többsoros megjegyzés: /* */


Típusok és változók
Típusok és változók szorosan összefüggnek mivelhogy a változók a programunk legfontosabb elemei amelyekben tároljuk az adatokat, számításaink részeredményeit. Típusok pedig a változókban tárolható adatot adják meg.

    Egyszerű adattípusok - Egyszerű adattípusok amik lehetnek számok, karakterek vagy logikai típusok. Egy értek tárolására alkalmasak.
        Logikai Logikai típus: bool
        Számok - Számok tárolására szolgáló típusok.
            Egész - Egész számok tárolására szolgáló típusok.
                Előjel nélküli - Előjel nélküli egész számok tárolására szolgáló típusok.
                8bites előjel nélkuli egész: byte, UInt8 16bites előjel nélkuli egész: ushort, UInt16 32bites előjel nélkuli egész: uint, UInt32 64bites előjel nélkuli egész: ulong, UInt64
                Előjeles - Előjeles egész számok tárolására szolgáló típusok.
                8bites egész: sbyte, Int8 16bites egész: short, Int16 32bites egész: int, Int32 64bites egész: long, Int64
            Lebegőpontos 32bites lebegőpontos: float 64bites lebegőpontos: double
    Típuskonverzió - Típuskonverzió segítségével megváltoztathatjuk mar letező típusok típusát. Lehet explicit vagy automatikus konverzió.
        Explicit - Explicit konverzió segítségével megadhatjuk hogy pontosan milyen típussal szeretnénk dolgozni. Ennek köszönhetően átírhatjuk az automatikus konverziót is.
        8bites egészre 8bites előjel nélkuli egészre 16bites egészre 16bites előjel nélkuli egészre 32bites egészre 32bites előjel nélkuli egészre 64bites egészre 64bites előjel nélkuli egészre 32bites lebegőpontosra 64bites lebegőpontosra Logikai típusra
    Valtozók - Változó adatok tárolására szolgál. Különböző helyeken deklarálható és különböző helyeken használható. Élettartalma szerint is megkülönboztethető: vannak lokális globális vagy statikus változók. Többek között Lehet használni struktúrában vagy funkcióban.
    Változó deklarácio Változó használat
        Automatikus változó - Automatikus változó szinte akárhol deklarálható, érvényessége az adott pozíciótól általában az aktuális blokk végéig van.
        Automatikus változó deklaraciója


Program szerkezete

    Utasítások Utasítások a programkód egy lépését adják meg.
    Kifejezések Kifejezések olyan kód részletek amelyek valami műveletet végeznek és a művelet eredményét
C# - Utasítások
Utasítások a programkód egy lépését adják meg.
Utasítások

Kifejezés utasítás Kifejezés utasítás végrehajtása a kifejezésnek, elvégzi a teljes kiértékelést és aztán a következő utasítással...
Hátultesztelő ciklus Feltétel tesztelése a ciklus végén történik. Ennek következtében a ciklus legalabb egyszer végre lesz hajtva. ...
Elöltesztelő ciklus Feltétel tesztelése a ciklus elején történik. Minden egyes ismétlés előtt leteszteli hogy teljesült-e a feltét...
Feltételes utasítás Programunk futtatását feltételekhez köthetjük. A feltételes utasítás segítségével két irányba terelhetjük a fo...
Összetett utasítás - Blokk Összetett utasítás más néven blok. Több utasítás összekötésére szolgál, végeredményben egy utasításba sűrít eg...
automatikus változó deklaraciója Valtozó deklarálása a változó létrehozására szolgál.
növelés utasitás Növelés utasitás egy matematikai művelet ami egy adott szám 1-el növelésére szolgáll.
Csökkentés utasítás Csökkentés utasítás egy matematikai művelet amely segítségével egy számot 1-el csökkenthetünk.
C# - Kifejezések
Kifejezések olyan kód részletek amelyek valami műveletet végeznek és a művelet eredményét adják vissza, vagypedig valami értéket reprezentálnak.
Kifejezések

Aritmetikai operátorok Matematikai műveletek elvégzésére szolgálnak. A következő alap műveletek találhatók az aritmetikai operátorok ...
Logikai operátorok Három-négy logikai művelet áll rendelkezésünkre, hogy pontosan menyi az függ a konkrét programozási nyelvtől a...
Bitműveleti operátorok Több bitművelet áll rendelkezésünkre, a bitműveletek segitségével egész számok bitjeit állíthatjuk be vagy épp...
Összehasonlító operátorok Összehasonlító operátorok fő felhasználási területe a feltételes utasítások irányítása. Ezeknek köszönhetően d...
Zárójel Zárójel használatával megváltoztathatjuk a kiértékelési sorrendet, maskép fogalmazva felül tudjuk írni az oper...
Explicit típus konverziók Explicit konverzió segítségével megadhatjuk hogy pontosan milyen típussal szeretnénk dolgozni. Ennek köszönhet...
Érték visszaadó konstansok



Operátorok
Operátorok valamilyen műveletet végeznek el az operandusok közöt, ez a művelet lehet matematikai, logikai vagy bitenkénti.
Zárójel: ( )

    Aritmetikai - Matematikai műveletek elvégzésére szolgálnak. A következő alap műveletek találhatók az aritmetikai operátorok között:
    Összeadás: + Kivonás: - Szorzás: * Osztás: / Egész osztás: / Maradékképzés: % Negatív előjel: -
    Logikai - Három-négy logikai művelet áll rendelkezésünkre, hogy pontosan menyi az függ a konkrét programozási nyelvtől amit használlunk. Ezek a múveletek segítségével bármely logikai feladatot/feltételt meg tudunk oldani. Ilyen logikai feltételek például a érték hasonlítások összekapcsolása bizonyos szabály szerint, érték tesztelések. A logikai műveleteket elsősorban feltételes utasítások végrehajtásánál használjuk.
    Logikai és: && Logikai vagy: || Logikai negáció: !
    Bitműveleti - Több bitművelet áll rendelkezésünkre, a bitműveletek segitségével egész számok bitjeit állíthatjuk be vagy épp lekérdezhetjük.
    Biteltoló balra: << Biteltoló jobbra: >> Bitenkénti ÉS: & Bitenkénti VAGY: | Bitenkénti 1-es komplemens: ~ Bitenkénti kizáró VAGY: ^
    Összehasonlító - Összehasonlító operátorok fő felhasználási területe a feltételes utasítások irányítása. Ezeknek köszönhetően dönthetjük el hogy egy elágazás milyen irányba haladjon tovább vagy például egy ciklus még mennyi iterációt végezzen el.
    Kisebb mint: < Nagyobb mint: > Kisebb vagy egyenlő mint: <= Nagyobb vagy egyenlő mint: >= Egyenlő: == Nem egyenlő: !=
    Értékadó Értékadás: =


Utasítások
Utasítások a program megírásának fő elemei. Általában érvényes egy sor utasítás egy sor programnak felel meg. Utasítások fő csoportja: ciklusok, programelágazások és vezérlésátadások.
Kifejezés utasítás: ; Összetett utasítás - Blokk: { }

    Ciklusok Hátultesztelő ciklus: do while
C# - Hátultesztelő ciklus: do while
Feltétel tesztelése a ciklus végén történik. Ennek következtében a ciklus legalabb egyszer végre lesz hajtva. Minden egyes ismétlés után leteszteli hogy teljesült-e a feltétel. ha a megadott feltétel igaz akkor folytatódik a ciklus futása ha nem akkor befejeződik.
do while
Leírás

do statement while (condition);

Használt kulcsszavak: do while
Bemenet

    statement - Utasítások
    condition - Logikai érték Feltétel lehet akármilyen kifejezés

Megjegyzés: Itt használható utasítások:
Megszakító utasítás Következő iteráció elindítása

Plusz egy kis példa hogy mi minden helyzetben lehet használni a Hátultesztelő ciklus műveletet:

i=10;
do --i; while ( i > 0);
do {
  i++;
  if (i==5)
    break;
} while ( i <10);


Elöltesztelő ciklus: while

C# - Elöltesztelő ciklus: while
Feltétel tesztelése a ciklus elején történik. Minden egyes ismétlés előtt leteszteli hogy teljesült-e a feltétel. Az első végrehajtás előtt is történik tesztelés, ezért ez a ciklus használata kitűnő olyan helyzetekben ahol megeshet hogy egyszer se kell végrehajtani a ciklust.
while
Leírás

while (condition) statement

Használt kulcsszavak: while
Bemenet

    condition - Logikai érték Feltétel lehet akármilyen kifejezés
    statement - Utasítások

Megjegyzés: Itt használható utasítások:
Megszakító utasítás Következő iteráció elindítása
Példaprogramok
C#
Elöltesztelő ciklus lehetséges használata:

i=0;
while (i<10) ++i;
x =0;
while (i<20)
{
 i= i+2;
 if (i==16)
 {
    continue;
 }
 x++;
}


    Feltételes utasítás Feltételes utasítás: if, if else

C# - Feltételes utasítás: if, if else
Programunk futtatását feltételekhez köthetjük. A feltételes utasítás segítségével két irányba terelhetjük a folyamatot. Ha teljesül a feltétel akkor az első irányba folytatódik a program futása ha nem akkor a második irányba. Az irányok alatt egy utasítás vagypedig egy blokk végrehajtását értem.
if, if else
Leírás

if (condition) statement1

if (condition) statement1 else statement2

Használt kulcsszavak: if else
Bemenet

    condition - Logikai érték Feltétel lehet akármilyen kifejezés
    statement1 - Utasítások
    statement2 - Utasítások

Példaprogramok
C#
Feltételes utasítás lehetséges használata:

if (i > 10)
{
i =10;            i = i - 1;   i++;
}
if (i < 10) i = 10; else i=1;


    Ugró utasítások Megszakító utasítás: break

C# - Megszakító utasítás: break
Ciklus futásának azonnali megszakítására szolgál. Meghívását követően a ciklus után következő kód kerül végrehajtásra.
break
Leírás

break ;

Használt kulcsszavak: break
Megjegyzés: Következő helyeken használható:
Hátultesztelő ciklus Elöltesztelő ciklus
Példaprogramok
C#
Plusz egy kis példa hogy mi minden helyzetben lehet használni a Megszakító utasítás műveletet:

i=10;
do --i; while ( i > 0);
do {
  i++;
  if (i==5)
    break;
} while ( i <10);

Következő iteráció elindítása: continue
C# - Következő iteráció elindítása: continue
Ez az utasítás a következő iteráció elindítására szolgál. Ez azt jelenti ha meghívjuk akkor megszakítsuk a ciklus futását és a következő iterációval folytatódik a ciklus.
continue
Leírás

continue ;

Használt kulcsszavak: continue
Megjegyzés: Következő helyeken használható:
Hátultesztelő ciklus Elöltesztelő ciklus
Példaprogramok
C#
Következő iteráció elindítása lehetséges használata:

i=0;
while (i<10) ++i;
x =0;
while (i<20)
{
 i= i+2;
 if (i==16)
 {
    continue;
 }
 x++;
}


    Növelés csökkentés Növelés utasitás:
C# - Növelés utasitás: ++
Növelés utasitás egy matematikai művelet ami egy adott szám 1-el növelésére szolgáll.
++
Leírás

++ var ;


Bemenet

    var - Érték felvevő

Példaprogramok
C#
Növelés utasitás lehetséges használata:

i=0;
while (i<10) ++i;
x =0;
while (i<20)
{
 i= i+2;
 if (i==16)
 {
    continue;
 }
 x++;
}


 ++ Csökkentés utasítás: --
C# - Csökkentés utasítás: --
Csökkentés utasítás egy matematikai művelet amely segítségével egy számot 1-el csökkenthetünk.
--
Leírás

-- var ;


Bemenet

    var - Érték felvevő

Példaprogramok
C#
Plusz egy kis példa hogy mi minden helyzetben lehet használni a Csökkentés utasítás műveletet:

i=10;
do --i; while ( i > 0);
do {
  i++;
  if (i==5)
    break;
} while ( i <10);

Függvények

A függvény rokon fogalom az eljárással – egy apró különbséggel. A függvény egy olyan eljárás, amely olyan részfeladatot old meg, melynek pontosan egy végeredménye is van – egy érték.

Amennyiben az a részfeladat, hogy egy értékekkel már feltöltött tömb eleminek összegét kell kiszámítani, a végeredmény egyetlen számérték. Amennyiben ezt eljárás segítségével oldjuk meg, úgy a végeredményt egy megosztott változóba kell elhelyezni. Ez sokszor nem túl szerencsés megoldás, mert a függvény kötődik ezen megosztott változó nevéhez. Amennyiben egy másik programba szeretnénk ezt függvényt áthelyezni, úgy vele együtt kell mozgatni a megosztott változót is.

Az ilyen jellegű feladatokat megoldó alprogramokat függvények formájában írjuk meg.

Amennyiben függvényt akarunk írni, két fontos dolgot kell szem előtt tartanunk:

    A függvényeknél rögzíteni kell, hogy milyen típusú értéket adnak majd vissza. Ezt a függvény neve előtt kell feltüntetni (a ’void’ helyett).

    A függvények ezek után kötelesek minden esetben egy ilyen típusú értéket vissza is adni! A függvény visszatérési értékét a ’return’ kulcsszó után írt kifejezésben kell feltüntetni.

Pl:

static int OsszegSzamitas()

{

int sum=0;

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

sum = sum + tomb[i];

return sum;

}

A fenti részben e függvény egy egész számot fog visszaadni, ezt jelöljük a típusnévvel: int. A függvény saját változót használ fel segédváltozóként (sum) a számítás során, majd a függvény végén a return sum–al jelöli, hogy a sum változóban szereplő értéket (ami int típusú) adja vissza, mint visszatérési értéket.

A függvények meghívása hasonlóan történik, mint az eljárások hívása. Csak mivel a függvény vissza is ad egy értéket, ezért gondoskodni kell róla, hogy ezen értéket a függvényt meghívó programrész fogadja, feldolgozza.

static void Main(string[] args)

{

Feltoltes();

Kiiras();

int osszesen=OsszegSzamitas();

Console.WriteLine("A tomb elemek osszege={0}",osszesen);

}

Itt a meghívó ponton az OsszegSzamitas() függvény által visszaadott értéket a meghívó rögtön eltárolja egy ’osszesen’ nevű változóba, melyből később ki tudja írni a képernyőre ezen értéket.

Ebben a formában a program már nem kell, hogy megosszon ’osszeg’ változót, hiszen az ’OsszegSzamitas()’ már nem ilyen módon közli az eredményt a Main() függvénnyel, hanem egyszerűen visszaadja azt.

class PeldaProgram

{

static int[] tomb=new int[10];

//................................................................

static void Main(string[] args)

{

Feltoltes();

Kiiras();

int osszesen=OsszegSzamitas();

Console.WriteLine("A tomb elemek osszege={0}",osszesen);

}

//................................................................

static int OsszegSzamitas()

{

int sum=0;

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

sum = sum + tomb[i];

return sum;

}

//................................................................

}

A 11. fejezetben felsorolt eljárások legnagyobb részét át lehet írni függvényekre. Vegyük például a maximális elem értékének meghatározását.

static int MaximalisElemErteke()

{

int max=tomb[0];

for(int i=1;i<tomb.Length;i++)

if (tomb[i]>max) max=tomb[i];

return max;

}

E függvény a megosztott ’tomb’ elemei közül keresi ki a legnagyobb elem értékét. Meghívása az alábbi módon történhet meg:

int maxElemErteke = MaximalisElemErteke();

Console.WriteLine("A tomb legnagyobb elemének értéke={0}",

maxElemErteke);

Amennyiben azt szeretnénk ellenőrízni, hogy egy adott érték szerepel-e egy – értékekkel már feltöltött – tömb elemei között, akkor az alábbi függvényt írhatnánk meg:

static bool Szerepel_E()

{

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

if (tomb[i]==keresett_elem) return true;

return false;

}

A fenti függvényben kihasználjuk azt, hogy a ’return’ kulcsszó hatására a függvény azonnal megszakítja a futását, és visszatér a hívás helyére. Amennyiben az egyenlőség teljesül, úgy a keresett érték szerepel a tömbben, ezért a ciklus további futtatása már felesleges – megvan a keresett válasz. A ’return false’ utasításra már csak akkor jut el a függvény, ha az egyenlőség egyszer sem teljesült. Ekkor a kérdésre a válasz a false érték.

A fenti függvény meghívása a következő módon történhet:

bool valasz = Szerepel_E();

if (valasz)Console.WriteLine("Nem szerepel a tömbben");

else Console.WriteLine("Szerepel a tömbben");

Más módja, hogy a függvény visszatérési értékét rögtön az ’if’ feltételében használjuk fel:

if (Szerepel_E())Console.WriteLine("Nem szerepel a tömbben");

else Console.WriteLine("Szerepel a tömbben");

A függvények ennél bonyolultabb értékeket is visszaadhatnak:

static int[] Feltoltes()

{

int[] t = new int[10];

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

{

Console.Write("A tomb {0}. eleme=",i);

string strErtek=Console.ReadLine();

t[i] = Int32.Parse( strErtek );

}

return t;

}

A fenti függvény létrehoz egy int-ekből álló, 10 elemű tömböt a memóriában, feltölti elemekkel a billentyűzetről, majd visszaadja a feltöltött tömböt az őt meghívónak:

int tomb[] = Feltoltes();

Amennyiben a feltöltött tömböt egy megosztott változóba szeretnénk tárolni, akkor azt az alábbi módon kell megoldani:

class PeldaProgram

{

static int[] tomb;

//................................................................

static void Main(string[] args)

{

tomb = Feltoltes();

Kiiras();

...

}

...

}

Ekkor a ’tomb’ változót először csak deklaráltuk, megadtuk a típusát. Majd a Main() függvény belsejében, a megfelelő időpontban meghívjuk a Feltoltes() függvényt, és az általa elkészített és feltöltött tömböt betesszük a megosztott változóba.

Nézzünk néhány egyszerű mintaprogramot;

 Készítsünk programot, amely bekér két egész számot. Majd kiszámolja a két szám összegét,
különbségét, szorzatát és hányadosát.
Megoldás:
static
void
Main(
string
[] args)
{
int
szam1;
int
szam2;
int
osszeg;
int
kulonbseg;
int
szorzat;
int
hanyados;
Console
.WriteLine(
"Ala
pműveletek program"
);
Console
.Write(
"Kérem az első számot: "
);
szam1 =
int
.Parse(
Console
.ReadLine());
Console
.Write(
"Kérem a második számot: "
);
szam2 =
int
.Parse(
Console
.ReadLine());
osszeg = sza
m1 + szam2;
kulonbseg = szam1
-
szam2;
szorzat = szam1 * szam2;
hanyados = szam1 / szam2;
Console
.WriteLine(
"A két szám összege: {0}"
, osszeg);
Console
.WriteLine(
"A két szám különbsége: {0}"
, kulo
nbseg);
Console
.WriteLine(
"A két szám szorzata: {0}"
, szorzat);
Console
.WriteLine(
"A két szám hányadosa: {0}"
, hanyados);
Console
.ReadKey();
------------------
A nagyobból vonja ki a kisebbet!
Alakítsuk át úgy a programot, hogy a nagyobb számból vonja ki a kisebbet, valamint a nagyobb
számot ossza el a kisebbel!
Megoldás:
static
void
Main(
string
[] args)
{
int
szam1;
int
szam2;
int
osszeg;
int
kulonbseg;
int
szorzat;
int
hanyados;
Console
.WriteLine(
"Alapm
űveletek program"
);
Console
.Write(
"Kérem az első számot: "
);
szam1 =
int
.Parse(
Console
.ReadLine());
Console
.Write(
"Kérem a második számot: "
);
szam2 =
int
.Parse(
Console
.ReadLine());
osszeg = szam1
+ szam2;
szorzat = szam1 * szam2;
if
(szam1 > szam2)
{
kulonbseg = szam1
-
szam2;
hanyados = szam1 / szam2;
}
else
{
kulonbseg = szam2
-
szam1;
hanyados = szam2 / szam1;
};
Console
.WriteLine(
"A két szám összege: {0}"
, osszeg);
Console
.WriteLine(
"A két szám különbsége: {0}"
, kulonbseg);
Console
.WriteLine(
"A két szám szorzata:
{0}"
, szorzat);
Console
.WriteLine(
"A két szám hányadosa: {0}"
, hanyados);
Console
.ReadKey();
}
-----------
Készítsünk programot, mely bekér a felhasználótól egy számot, majd kiírja az adott számról, hogy
páros, páratlan, vagy nulla.
Megoldás:
static
void
Main(
string
[] args)
{
int
szam;
Console
.WriteLine(
"Párosság vizsgáló program"
);
Console
.Write(
"Kérek egy számot: "
);
szam =
int
.Parse(
Console
.R
eadLine());
if
(szam % 2 == 0)
Console
.WriteLine(
"A szám páros"
);
if
(szam % 2 != 0)
Console
.WriteLine(
"A szám páratlan"
);
if
(szam == 0)
Console
.WriteLine(
"A szám értéke nulla"
);
Console
.ReadKey();
}
-----------------
Készítsünk
programot, amely bekér a felhasználótól két számot. A program döntse el, hogy az elsőként
bekért számnak osztója
-
e a másodikként bekért szám. Amennyiben igen, írja ki az osztás eredményét
is.
Megoldás:
static
void
Main(
string
[] args)
{
int
szam;
int
oszto;
int
ered;
Console
.WriteLine(
"Osztója
-
e?"
);
Console
.Write(
"Kérek egy számot: "
);
szam =
int
.Parse(
Console
.ReadLine());
Console
.Write(
"Kérek egy számot: "
);
oszto =
int
.Parse(
Console
.ReadLine());
if
(szam % oszto == 0)
{
ered = szam / oszto;
Console
.WriteLine(
"Az {0} osztója {1}
-
nek."
, oszto, szam );
Console
.WriteLine(
"{0} / {1
} = {2}"
, szam, oszto, ered);
}
else
Console
.WriteLine(
"A(z) {0} NEM osztója {1}
-
nek."
, oszto, szam);
Console
.ReadKey();
}
-------------------
Készítsünk programot, mely eldönti egy háromszög hár
om oldala alapján, hogy az adott háromszög
szerkeszthető
-
e.
Megoldás:
static
void
Main(
string
[] args)
{
int
a;
int
b;
int
c;
Console
.WriteLine(
"Háromszög szerkeszthetőség"
);
Conso
le
.WriteLine(
"Kérem a hátomszög oldalait!"
);
Console
.Write(
"a: "
);
a =
int
.Parse(
Console
.ReadLine());
Console
.Write(
"b: "
);
b =
int
.Parse(
Console
.ReadLine());
Console
.Write(
"c: "
);
c =
int
.Parse(
Console
.ReadLine());
if
((a + b > c) && (a + c > b) && (b + c > a))
Console
.WriteLine(
"A háromszög szerkeszthet
ő"
);
else
Console
.WriteLine(
"A háromszög nem szerkeszthető"
);
Console
.ReadKey();
}
----------------
Bekéri a felhasználó nevét, valamint születésének évét. Kis
zámítja a felhasználó életkorát. Ezután egy
üres képernyőn, melynek kék a háttere, a képernyő közepén megjeleníti sárga színnel a felhasználó
nevét, majd alatta piros színnel a felhasználó életkorát.
Megoldás:
static
void
Main(
string
[] args)
{
string
nev;
int
ev;
int
kora;
string
korastr;
Console
.WriteLine(
"Névjegy"
);
Console
.Write(
"Kérem a nevet: "
);
nev =
Console
.ReadLine();
Console
.Write(
"Kérem
a születési évet: "
);
ev =
int
.Parse(
Console
.ReadLine());
kora =
DateTime
.Today.Year
-
ev;
korastr =
Convert
.ToString(kora);
Console
.BackgroundColor=
ConsoleColor
.Blue;
Console
.Clear();
Console
.ForegroundColor =
ConsoleColor
.Yellow;
Console
.SetCursorPosition((
Console
.WindowWidth / 2)
-
(nev.Length/2),
Console
.WindowHeight / 2);
Console
.WriteLine(nev);
Console
.ForegroundColor =
ConsoleColor
.Red;
Console
.SetCursorPosition((
Console
.WindowWidth / 2)
-
(korastr.Length/2), (
Console
.WindowHeight / 2)+1);
Console
.WriteLine(kora);
Console
.ReadKey();
}
------------------
Készítsünk programot, amely bekér egy N számot
és kiírja a számokat 1
-
től N
-
ig.
Megoldás:
static
void
Main(
string
[] args)
{
int
N;
int
i;
Console
.WriteLine(
"Számok 1
-
N
-
ig"
);
Console
.Write(
"Kérek egy tetszőleges pozitív egész számot: "
);
N =
int
.Parse(
Console
.ReadLine());
for
(i = 1; i <= N; i++)
Console
.Write(
"{0}, "
, i);
Console
.ReadKey();
}
Kiegészítés:
Módosítsuk úgy a programot, hogy az csak a páros számokat írja ki!
Megoldás:
static
v
oid
Main(
string
[] args)
{
int
N;
int
i;
Console
.WriteLine(
"Számok 1
-
N
-
ig"
);
Console
.Write(
"Kérek egy tetsz
őleges pozitív egész számot: "
);
N =
int
.Parse(
Console
.ReadLine());
for
(i = 1; i <= N; i++)
if
(i % 2 == 0)
Console
.Write(
"{0}, "
, i);
Console
.ReadKey();
}
Megjegyzés:
A feladatban akár a páratl
an számok kiíratása, akár a tetszőleges számmal történő oszthatóság
vizsgálata lehetséges, mint kiegészítés.
---------------
Készítsünk programot, mely a következő feladatot látja el:
Bekér a felhasználótól egy számot, majd eldönti róla, hogy az adott s
zám prímszám
-
e.
Megoldás:
static
void
Main(
string
[] args)
{
int
szam;
int
i;
int
osztok;
Console
.Write(
"Kérem a vizsgálandó számot: "
);
szam =
int
.Parse(
Console
.ReadLine());
os
ztok = 0;
for
(i = 2; i <= szam / 2; i = i + 1)
{
if
(szam % i == 0) osztok = osztok + 1;
}
if
(osztok == 0)
Console
.WriteLine(
"A megadott szám PRÍM"
);
else
Console
.WriteLine(
"A me
gadott szám NEM PRÍM"
);
Console
.ReadKey();
}
Kiegészítés:
A program írja ki, hogy a felhasználó által megadott szám osztóit, illetve, hogy az adott számnak hány
osztója van
egyen és önmagán kívül
.
Megoldás:
static
void
Main(
string
[] arg
s)
{
int
szam;
int
i;
int
osztok;
Console
.Write(
"Kérem a vizsgálandó számot: "
);
szam =
int
.Parse(
Console
.ReadLine());
osztok = 0
;
for
(i = 2; i <= szam / 2; i = i
+ 1)
{
if
(szam % i == 0)
{
osztok = osztok + 1;
Console
.WriteLine(i);
}
}
if
(osztok == 0)
Console
.WriteLine(
"A megadott szám PRÍM"
);
else
{
Console
.WriteLine(
"A megadott szám NEM PRÍM"
);
Console
.Write(
"A szám TERMÉSZETES osztóinak száma: "
);
Console
.WriteLine(osztok);
}
Console
.ReadKey();
}
Megjegyzés:
A feladat további kiegészítéseként kiírathatjuk a szám osztóit is.
-----------------------
Készítsünk programot, mely a következő feladatot látja el:
Bekér a felhasználótól egy számot, majd a megadott számig kiírja a prímszámokat.
Meg
oldás:
static
void
Main(
string
[] args)
{
int
szam;
int
i;
int
osztok;
int
N;
Console
.Write(
"Kérem a vizsgálandó végértéket: "
);
N =
int
.Parse(
Console
.ReadLine());
f
or
(szam = 2; szam <= N; szam = szam + 1)
{
osztok = 0;
for
(i = 2; i <= szam / 2; i = i + 1)
{
if
(szam % i == 0) osztok = osztok + 1;
}
if
(os
ztok == 0)
Console
.WriteLine(szam);
}
Console
.ReadKey();
}
----------------
Készítsünk programot,
mely elvégzi egy szám prímtényezős felbontását.
Megoldás:
static
void
Main(
string
[] args)
{
int
szam;
int
i;
int
osztok;
int
veg;
Console
.Write(
"Kérem a vizsgálandó végértéket: "
);
veg =
int
.Parse(
Console
.ReadLine());
szam = 1;
do
{
szam=szam+1;
osztok = 0;
for
(i = 2; i <= szam % 2; i = i + 1)
{
if
(szam % i == 0) osztok = osztok + 1;
}
if
(osztok == 0)
{
if
(veg % szam == 0)
{
Console
.WriteLine(szam);
veg = veg / szam;
szam = szam
-
1;
}
}
}
w
hile
(szam<=veg);
Console
.ReadKey();
}
--------------
Készítsünk programot, mely
kiszámítja egy szám faktoriálisát.
Megoldás:
static
void
Main(
string
[] args)
{
int
szam;
int
fakt;
int
i;
Console
.WriteLine(
"Faktoriális program"
);
szam =
int
.Parse(
Console
.ReadLine());
fakt = 1;
for
(i=1; i<=szam;i++) fakt = fakt*i;
Console
.WriteLine(
"A megadott szám faktoriálisa:
{0}"
, fakt);
Console
.ReadKey();
}
------------------
Készítsünk programot, mely
a
következő feladatokat végzi el:

Feltölt egy N elemű tömböt egy és száz közé eső véletlen számokkal. A tömb méretét a
felhasználó határozza meg!

Feltöltés után a tömb elemeit a program írja ki a képernyőre!

Döntse el a program, hogy a tömb tartalmaz
-
e páro
s elemet! (eldöntés tétele)

Határozza meg az első páros szám sorszámát! (kiválasztás tétele)

A program négy, jól elkülöníthető, egymástól független részből álljon!
Figyelem: A tömb elemeinek sorszámozása 0
-
val kezdődik!!! Tehát, az egy elemű tömb egyetlen
elemének sorszáma 0.
Megoldás:
static
void
Main(
string
[] args)
{
Console
.WriteLine(
"Eldöntés tétele, kiválasztás tétele"
);
Random
rnd =
new
Random
();
Console
.Write(
"Hány eleme legyen a tömbnek? "
);
int
N =
int
.Parse(
Console
.ReadLine());
int
[] A =
new
int
[N];
//feltöltés
for
(
int
i=0;i<N;i++)
{
A[i] = rnd.Next(100) + 1;
}
//kiiratás
foreach
(
int
j
in
A)
{
Console
.Write(
"{0}, "
, j);
}
//eldöntés
int
cv = 0;
bool
vane =
false
;
do
{
if
(A[cv] % 2 ==0) vane =
true
;
cv = cv
+ 1;
}
while
((cv < N)&&(vane==
false
));
if
(vane ==
true
)
Console
.WriteLine(
"A tömb tartalmaz páros elemet"
);
else
Console
.WriteLine(
"A tömb nem tartalmaz páros elemet"
);
//kiválasztás
cv = 0;
int
sorsz =
-
1;
do
{
if
(A[cv] % 2 == 0) sorsz = cv;
cv = cv + 1;
}
while
((cv < N) && (sorsz ==
-
1));
if
(sorsz !=
-
1)
Cons
ole
.WriteLine(
"A tömb első páros elemének helye {0}"
, sorsz);
Console
.ReadLine();
}
-----------------
Készítsünk programot, mely a következő feladatokat végzi el:

Feltölt egy N elemű tömböt egy és száz közé eső véletlen számokkal. A
tömb méretét a
felhasználó határozza meg!

Feltöltés után a tömb elemeit a program írja ki a képernyőre!

Másolja át a program egy másik tömbbe a páros számokat! (kiválogatás tétele)

Számolja meg a program, hogy hány páros számot tartalmazott a tömb! (megszá
mlálás tétele)

Írja ki a program a páros elemek számát!

Írja ki a program a páros elemeket!
Figyelem: A tömb elemeinek sorszámozása 0
-
val kezdődik!!! Tehát, az egy elemű tömb egyetlen
elemének sorszáma 0.
Megoldás:
static
void
Main(
string
[] args)
{
Console
.WriteLine(
"Eldöntés tétele, kiválasztás tétele"
);
Random
rnd =
new
Random
();
Console
.Write(
"Hány eleme legyen a tömbnek? "
);
int
N =
int
.Parse(
Console
.ReadLine());
int
[] A =
new
i
nt
[N];
//feltöltés
for
(
int
i=0;i<N;i++)
{
A[i] = rnd.Next(100) + 1;
}
//kiiratás
foreach
(
int
j
in
A)
{
Console
.Write(
"{0}, "
, j);
}
//Kiválogatás
-
megszámlálás
int
cv = 0;
int
[] paros =
new
int
[N];
int
db = 0;
for
(cv = 0; cv<N;cv++)
{
if
(A[cv] % 2 == 0)
{
db=db+1;
paros[db]=A[cv];
}
}
//Kiiratás
Console
.WriteLine();
Console
.WriteLine(
"A tömbben {0} darab páros szám található"
, db);
for
(
int
i=1;i<=db;i++)
Console
.Write(
"{0}, "
, paros[i]);
Console
.ReadLine();
}
--------------------
Készítsünk programot, mely a következő feladatokat végzi el:

Feltölt egy N elemű tömböt egy és száz közé eső véletlen számokkal. A tömb méretét a
felhasználó határ
ozza meg!

Feltöltés után a tömb elemeit a program írja ki a képernyőre!

Másolja át a program egy másik tömbbe a páros számokat!

Másolja át a program egy harmadik tömbbe a páratlan számokat!

Számolja meg a program, hogy hány páros illetve hány páratlan szám
ot tartalmazott a tömb!
(megszámlálás tétele)

Írja ki a program a páros illetve páratlan elemek számát!

Írja ki a program a páros illetve páratlan elemeket!
Figyelem: A tömb elemeinek sorszámozása 0
-
val kezdődik!!! Tehát, az egy elemű tömb egyetlen
eleméne
k sorszáma 0.
Megoldás:
static
void
Main(
string
[] args)
{
Console
.WriteLine(
"Eldöntés tétele, kiválasztás tétele"
);
Random
rnd =
new
Random
();
Console
.Write(
"Hány eleme legyen a tömbnek? "
);
i
nt
N =
int
.Parse(
Console
.ReadLine());
int
[] A =
new
int
[N];
//feltöltés
for
(
int
i=0;i<N;i++)
{
A[i] = rnd.Next(100) + 1;
}
//kiiratás
foreach
(
int
j
in
A)
{
Console
.Write(
"{0}, "
, j);
}
//Kiválogatás
-
megszámlálás
int
cv = 0;
int
[] paros =
new
int
[N];
int
[] paratlan =
new
int
[N];
int
parosdb = 0;
i
nt
paratlandb = 0;
for
(cv = 0; cv<N;cv++)
{
if
(A[cv] % 2 == 0)
{
parosdb = parosdb + 1;
paros[parosdb] = A[cv];
}
else
{
paratlandb = paratlandb + 1;
paratlan[paratlandb] = A[cv];
}
}
//Kiiratás
Console
.WriteLine();
Console
.WriteLine(
"A tömbben {0} darab páros s
zám található"
,
parosdb);
for
(
int
i=1;i<=parosdb;i++)
Console
.Write(
"{0}, "
, paros[i]);
Console
.WriteLine();
Console
.WriteLine(
"A tömbben {0} darab páratlan szám található"
,
paratlandb);
for
(
int
i = 1; i <=
paratlandb; i++)
Console
.Write(
"{0}, "
,
paratlan[i]);
Console
.ReadLine();
}
--------------------
Készítsünk programot, mely a következő feladatokat végzi el:

Feltölt egy N elemű tömböt egy és száz közé eső véletlen számokkal. A tömb mére
tét a
felhasználó határozza meg!

Feltöltés után a tömb elemeit a program írja ki a képernyőre!

Rendezze a program a tömb elemeit emelkedő sorrendbe!

Írja ki a program a rendezett tömb elemeit!
Megoldás:
static
void
Main(
string
[] args)
{
Console
.WriteLine(
"Eldöntés tétele, kiválasztás tétele"
);
Random
rnd =
new
Random
();
Console
.Write(
"Hány eleme legyen a tömbnek? "
);
int
N =
int
.Parse(
Console
.ReadLine());
int
[] A =
new
int
[N];
//feltöltés
for
(
int
i = 0; i < N; i++)
{
A[i] = rnd.Next(100) + 1;
}
//kiiratás
foreach
(
int
j
in
A)
{
Console
.Write(
"{0}, "
, j);
}
//Rendezés
for
(
int
i = 0; i < N
-
1; i++)
{
for
(
int
j = i+1; j < N; j++)
{
if
(A[j] < A[i])
{
int
c = A[i];
A[i] = A[j];
A[j] = c;
}
}
}
Console
.WriteLine();
Console
.WriteLine(
"A tömb elemei emelkedő sorrendben: "
);
for
(
int
i = 0; i < N; i++)
Console
.Write(
"{0}, "
, A[i]);
Console
.ReadLine();
}Készítsünk programot, mely a következő feladatokat végzi el:

Feltölt egy N elemű tömböt egy és száz közé eső véletlen számokkal. A tömb mére
tét a
felhasználó határozza meg!

Feltöltés után a tömb elemeit a program írja ki a képernyőre!

Rendezze a program a tömb elemeit emelkedő sorrendbe!

Írja ki a program a rendezett tömb elemeit!
Megoldás:
static
void
Main(
string
[] args)
{
Console
.WriteLine(
"Eldöntés tétele, kiválasztás tétele"
);
Random
rnd =
new
Random
();
Console
.Write(
"Hány eleme legyen a tömbnek? "
);
int
N =
int
.Parse(
Console
.ReadLine());
int
[] A =
new
int
[N];
//feltöltés
for
(
int
i = 0; i < N; i++)
{
A[i] = rnd.Next(100) + 1;
}
//kiiratás
foreach
(
int
j
in
A)
{
Console
.Write(
"{0}, "
, j);
}
//Rendezés
for
(
int
i = 0; i < N
-
1; i++)
{
for
(
int
j = i+1; j < N; j++)
{
if
(A[j] < A[i])
{
int
c = A[i];
A[i] = A[j];
A[j] = c;
}
}
}
Console
.WriteLine();
Console
.WriteLine(
"A tömb elemei emelkedő sorrendben: "
);
for
(
int
i = 0; i < N; i++)
Console
.Write(
"{0}, "
, A[i]);
Console
.ReadLine();
}
--------------
  Készítsünk programot, mely a következő feladatokat végzi el:

Feltölt egy n*m elemű mátrixot 1
-
99 közé eső véletlen számokkal. A program elején a sorok és
oszlopok számát konstansok tárolják. (m, n)

Feltöltés után a mátrix elemeit a program írja
ki a képernyőre, rendezetten, átláthatóan.

Képezze a program a mátrix valamely tükörmátrixát!

A kész tükörmátrixot, az eredeti mátrix mellé, hasonló módon rendezetten írja ki a program!

A programban végrehajtott tevékenységeket válasszuk el egymástól!
Meg
oldás:
static
void
Main(
string
[] args)
{
const
int
m = 6;
const
int
n = 6;
int
[,] matrix =
new
int
[m, n];
Random
rnd =
new
Random
();
// mátrix feltöltése adatokkal
for
(
int
i = 0; i < m; i++)
{
for
(
int
j = 0; j < n; j++)
{
matrix[i, j] = rnd.Next(99)+1;
}
}
// mátrix kiírása
Console
.WriteLine(
"Az eredeti m
átrix: "
);
for
(
int
i = 0; i < m; i++)
{
for
(
int
j = 0; j < n; j++)
{
Console
.SetCursorPosition(i * 3,5+(j * 2));
Console
.Write(matrix[i, j]);
}
}
// A mátrix tükrözése
for
(
int
i = 0; i < m; i++)
{
for
(
int
j = i; j < n; j++)
{
int
cs = matrix[i, j];
matrix[i, j] = matrix[j, i]
;
matrix[j, i] = cs;
}
}
// Tükörmátrix kiiratása
Console
.SetCursorPosition(40, 0);
Console
.Write(
"Az eredeti mátrix: "
);
for
(
int
i = 0; i < m; i++)
{
for
(
int
j = 0; j < n; j++)
{
Console
.SetCursorPosition(40+(i * 3),5+(j * 2));
Console
.Write(matrix[i, j]);
}
}
Console
.ReadKey();
}
------------------
Készítsünk programot, mely a következő feladatokat végzi el:

Feltölt egy
5
elemű tömböt egy és
90
közé eső véletlen számokkal.
Ez a tömb a nyerőszámokat
tartalmazó tömb.

Bekér egy 5 elemű tömböt a felhasználótól. A számok itt is 1 és 90 kö
zé eshetnek. (ezt a
programnak figyelnie is kell
, valamint azt is, hogy a megadott szám 1 és 90 közé essen).
Ez a tömb a felhasználó által megadott tippeket tartalmazza.

Feltöltés után a tömb elemeit a program írja ki a képernyőre!

Rendezze a program a
két
tömb elemeit emelkedő sorrendbe!

Vizsgálja meg a program, hogy hány találatot ért el a felhasználó, majd írja ki azt.

Írja ki a program emelkedő sorrendben a felhasználó által adott tippeket illetve a nyerő
lottószámokat is.
Megoldás:
static
void
Main(
string
[] args)
{
Random
rnd =
new
Random
();
//Nyerő számok generálása
int
[] nyero =
new
int
[5];
int
cv = 0;
while
(cv < 5)
{
int
aktszam = rnd.Next(90) + 1
;
bool
vane =
false
;
for
(
int
i = 0; i<cv; i++)
if
(nyero[i] == aktszam) vane =
true
;
if
(vane ==
false
)
{
nyero[cv] = aktszam;
cv = cv + 1;
}
}
//Felhasználó számainak bekérése
int
[] felh =
new
int
[5];
Console
.WriteLine(
"Kérem adja meg a tippeket!"
);
cv = 0;
while
(cv < 5)
{
Console
.WriteLi
ne();
Console
.Write(
"Kérem a {0}. számot: "
, cv+1);
int
aktszam =
int
.Parse(
Console
.ReadLine());
bool
vane =
false
;
for
(
int
i = 0; i < cv; i++)
if
(felh[i] == aktszam) vane =
true
;
if
(vane ==
false
)
{
if
((aktszam >= 1) && (aktszam <= 90))
{
felh[cv] = aktszam;
cv = cv + 1;
}
else
Console
.WriteLine(
"A megadott szám nem megfelelő
Lottószám!"
);
}
else
Console
.WriteLine(
"Ezt a számot már megadta egyszer!"
);
}
-
19
-
//Nyerő számok rendezése
for
(
int
i = 0; i < 5
-
1; i++)
{
for
(
int
j = i + 1; j < 5; j++)
{
if
(nyero[j] < nyero[i])
{
int
c = nyero[i];
nyero[i] = nyero[j];
nyero[j] = c;
}
}
}
//Felhasználó számainak rendezése
for
(
int
i = 0; i < 5
-
1; i++)
{
for
(
int
j = i + 1; j < 5; j++)
{
if
(felh[j] < felh[i])
{
int
c = felh[i];
felh[i] = felh[j];
felh[j] = c;
}
}
}
//Találatok keresése
int
talalat = 0;
for
(
int
i = 0; i < 5; i++)
{
for
(
int
j = 0; j < 5; j++)
{
if
(felh[i] == nyero[j]) talalat = talalat + 1;
}
}
//Kiiratás
Console
.WriteLine();
Console
.WriteLine(
"A találatok száma: {0}"
, talalat);
Console
.WriteLine(
"A nyrő számok: "
);
foreach
(
int
i
in
nyero)
Console
.Write(
"{0}, "
, i);
Console
.WriteLine();
Console
.WriteLine(
"A felhasználó számai: "
);
foreach
(
int
i
in
felh)
Console
.Write(
"{0}, "
, i);
Console
.ReadKey();
}
----------------------