c#

Modern programozási nyelvek

2022-04-06T15:12:25+00:00

A portfolio.hu oldalon megjelent (és archivalt) cikk nyomtatott változata ITT olvasható!

ÉRETTSÉGI PROGRAMOZÁSI FELADATOK MEGOLDÁSA C#-BAN

2020-06-11T16:34:48+00:00

A 2020. májusi emelt szintű érettségi vizsga programozási feladatát oldottam meg. Részletesen elmagyarázom és megmutatom a megoldást az alábbi videókon. Remélem, sokan kedvet kaptok a prgramozáshoz!

Az 1. és 2. rész megoldása:

A 3. és 4. rész megoldása:

Az 5. rész megoldása:

És itt az általam megírt programkód!

C# lépésről-lépésre

2019-10-20T14:49:36+00:00

Az Info Tanár Mentor Program Klub támogatásával elkészült egy videó sorozat, amely a C# programozás elsajátítást segíti lépésről-lépésre.
(egy korábbi cikkben már felkerült a sorozat első három része)

Az egyes részek elérhetőségei és a film hossza:

Tananyag	Hossz
C# Programozás 1.rész - Alapok	15:37
C# Programozás 2.rész - Operátorok, adatbekérés	14:26
C# Programozás 3.rész - Elágazások: if-else	17:48
C# Programozás 4.rész - Elágazások: switch	10:08
C# Programozás 5.rész - Iterációk, ciklusok	20:05
C# Programozás 6.rész - Prefix, postfix, túlcsordulás	10:35
C# Programozás 7.rész - Randomolás, Tömbök: vektorok, mátrixok, mutatóvektorok, stringek	27:06
C# Programozás 9.rész - Alprogramok:eljárások és függvények	31:14
C# Programozás 10.rész - Alprogramok - feladatok	19:36
C# Programozás 14.rész - List és ArrayList + Elmélet	29:22
C# Programozás 19. rész - Struktúrák	11:29
C# Programozás 23. rész - OOP1 - Alapok, konstruktor	18:36
C# Programozás 24. rész - OOP2 - Láthatóságok, jellemzők	16:19
C# Programozás 25. rész - OOP3 - Jellemzők, osztálymetódus, statikus mezők, osztályok	14:04
C# Programozás 26. rész - OOP4 - Öröklődés, is a viszony	35:29
C# Programozás 27. rész - OOP5 - Öröklődés: override, virtual, new, sealed	12:08
C# Programozás 28. rész - OOP6 - Késői, korai kötés, polimorfizmus	12:07
C# Programozás 31. rész - OOP9 - Interfészek	11:45

Ezen kívül elérhető Karsa Zoltán: C# programozás c. jegyzete, amelyet ITT lehet elolvasni! (..de letölthető innet is!)

Programozás kezdőknek-VIDEÓK!

2019-07-13T16:51:18+00:00

Telepítés, alapok

Operátorok, adatbekérés

Elágazások

Ciklusok

Bővített változat

2019-07-13T16:28:39+00:00

Gyors segítség:

Ha elírjuk a változók nevét:

Kis és nagybetű számít

Sokan használják ugyanazt a nevet eltérő betűmérettel, pl.: ha egy függvény beállítja egy osztály „PontokSzama” mezőjét, a paraméter lehet „pontokSzama” nevű.

Ne cseréljünk fel betűket.

Ha tünetek jelentkeznek:

Piros aláhúzás

Ha a View / Error List menüponttal megjelenítjük az Error List ablakot>>

A kódkiegészítés nem ajánlja fel a változó nevét, és az utána leütött pontra sem jelenik meg metódus lista.

Gyakran előfordul:

A tömbnél kapcsos zárójel kell: szamok[5] és nem szamok(5)

A for ciklus fejlécében pontosvesszők vannak: for(int i=0; i<10; i++)

A do{ … }while(…) után kell pontosvessző: do{ i++; }while(i<10);

A sima while-nál viszont nem kell.

Ha segítségre szorulsz, keress az alábbi könyvekben:

A C# alapjai

A programozás lépései

Operátorok

Adatstruktúrák

Egyszerűbb programok 1.

2019-07-13T15:58:47+00:00

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 soron kö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;
        }