A InfoWiki wikiből
11. sor: | 11. sor: | ||
<path p1="Kezdolap|Kezdőlap" p2="EBooks|Jegyzetek" p3="mp1/Nyitolap|Tartalomjegyzék" | <path p1="Kezdolap|Kezdőlap" p2="EBooks|Jegyzetek" p3="mp1/Nyitolap|Tartalomjegyzék" | ||
xx="-" | xx="-" | ||
- | w1="mp2 | + | w1="mp2/Nyitolap|Gyakorlatok" w2="mp1/Tematika|Vizsgatematika" w3="cs/Blog|Programok C# nyelven" |
/> | /> | ||
<path/> | <path/> |
A lap 2009. október 15., 09:46-kori változata
Alapvető algoritmusok C# függvények formában
Feltöltés billentyűzetről I.
Egy 'N' elemű 'int' vektor elemeinek bekérése, feltöltés billentyűzetről.
public static void Feltoltes_Billentyuzetrol(int[] t) { for(int i=0;i<t.Length;i++) { Console.Write("Kerem a tomb {0}. elemenek erteket:",i); int x = int.Parse( Console.ReadLine() ); t[i] = x; } }
Feltöltés billentyűzetről II.
Egy 'N' elemű 'int' vektor elemeinek bekérése, feltöltés billentyűzetről. Egyszerű szabály alkalmazása a bekért értékekre, pl. csak [1,100] közötti számokat fogadhatunk el:
public static void Feltoltes_Billentyuzetrol(int[] t) { int i=0; while (i<t.Length) { Console.Write("Kerem a tomb {0}. elemenek erteket:",i); int x = int.Parse( Console.ReadLine() ); if (1<=x && x<=100) { t[i] = x; i++; } else Console.WriteLine("Nem elfogadható érték."); } }
Feltöltés billentyűzetről III.
Egy 'N' elemű 'int' vektor elemeinek bekérése, feltöltés billentyűzetről. Kivételtekezelés alkalmazása a hibás értékbevitel kiszűrésére, és a program leállásának megakadályozására:
public static void Feltoltes_Billentyuzetrol(int[] t) { int i=0; while (i<t.Length) { Console.Write("Kerem a tomb {0}. elemenek erteket:",i); int x; try { x = int.Parse( Console.ReadLine() ); t[i] = x; i++; } catch { Console.WriteLine("Nem feldolgozgató érték, nem egész szám."); } } }
Feltöltés véletlen értékekkel
Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel valamely ['a','b'] intervallumból. Az intervallum 'a' és 'b' értékei is paraméterként adottak:
public static void Feltoltes_VeletlenSzamokkal(int[] t, int a, int b) { Random rnd = new Random(); for (int i=0;i<t.Length;i++) { t[i] = rnd.Next(a,b+1); } }
Vektor feltöltése véletlen értékekkel, ismétlődés nélkül
Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel valamely ['a','b'] intervallumból. Az intervallum 'a' és 'b' értékei is paraméterként adottak. A vektoron belül nem választhatunk ki két egyforma értéket, tehát a feltöltés során ismétlődés nem lehet (halmazszerű eredmény):
public static void Feltoltes_NincsIsmetlodes(int[] t, int a, int b) { Random rnd = new Random(); int i = 0; while (i<t.Length) { int x = rnd.Next(a,b+1); bool egyenlo_e = false; for (int j=0;j<i;j++) { if (x==t[j]) { egyenlo_e=true; break; } } if (egyenlo_e==false) { t[i]=x; i++; } } }
Vektor feltöltése eleve rendezett, de véletlenszerű értékekkel
Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel. A feltöltött tömb eleve rendezett állapotban lesz, de véletlenszerűnek tűnő módon. Választhatnánk azt is, hogy feltöltjük véletlen számokkal, majd a tömböt rendezzük valamely rendezőalgoritmussal, de ezen mód, amely a következőkben ismertetésre kerül eleve ezt az eredményt adja:
public static void Feltoltes_Rendezett(int[] t, int a, int b, int c) { Random rnd = new Random(); t[0] = rnd.Next(a,b+1); for (int i=1;i<t.Length;i++) { t[i] = t[i-1]+rnd.Next(1,c+1); } }
Vektor feltöltése eleve rendezett, de véletlenszerű értékekkel
Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel, melyek egy adott intervallumból kerülnek ki. Ezen intervallum első eleme paraméterként adott ('a'). Az intervallum szélessége megegyezik a tömb számosságával, vagyis az intervallumból minden elem bekerül a tömbbe, és minden elem csakis egyszer kerül kiválasztásra (ismétlődés nem fordulhat elő):
public static void Feltoltes_IntervallumMindenEleme(int[] t, int a) { for (int i=0;i<t.Length;i++) t[i]=a+i; Random rnd = new Random(); for (int i=0;i<t.Length;i++) { int j = rnd.Next(t.Length); int k = rnd.Next(t.Length); int x = t[j]; t[j]=t[k]; t[k]=x; } }
Vektor elemeinek összegzése
Állapítsuk meg, mennyi egy adott 'N' elemű vektorban lévő elemek összege:
public static int Oszzegkepzes(int[] t) { int sum = 0; for(int i=0;i<t.Length;i++) sum += t[i]; return sum; }
Vektor elemeinek átlagának meghatározása
Állapítsuk meg, mennyi egy adott 'N' elemű vektorban lévő elemek átlaga:
public static double Atlagkepzes(int[] t) { int sum = 0; for(int i=0;i<t.Length;i++) sum += t[i]; return (double)sum/t.Length; }
Vektor elemeinek szorzatát
Állapítsuk meg egy adott 'N' elemű vektor elemeinek szorzatát:
public static int SzorzatKepzes(int[] t) { int prod = 1; for(int i=0;i<t.Length;i++) prod *= t[i]; return prod; }
Eldöntés tétele I. (while)
Állapítsuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték):
public static bool Eldontes_WHILE(int[] t) { // T tulajdonsßg: 80tˇl nagyobb szßm int i=0; while (i<t.Length && !(t[i]>80)) i++; bool van = i<t.Length; return van; // if (van==true)Console.WriteLine("Van benne 80tól nagyobb elem"); // else Console.WriteLine("Nincs benne ilyen elem"); } }
Eldöntés tétele II. (for)
Állapítsuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték):
public static bool Eldontes_FOR(int[] t) { // T tulajdonsßg: 80tól nagyobb szßm for (int i=0;i<t.Length;i++) if (t[i]>80) return true; return false; }
Eldöntés tétele III. (foreach)
Állapítsuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték):
public static bool Eldontes_FOREACH(int[] t) { // T tulajdonsßg: 80tˇl nagyobb szßm foreach(int a in t) if (a>80) return true; return false; }
Kiválasztás tétele I. (while, első elem)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az első ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:
public static int Kivalasztas_LegelsoElem_WHILE(int[] t) { // T tulajdonsßg: 80tól nagyobb szßm int i=0; while (i<t.Length && !(t[i]>80)) i++; if (i<t.Length) return i; // van ilyen elem return -1; // nincs ilyen elem }
Kiválasztás tétele II. (for, első elem)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az első ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:
public static int Kivalasztas_LegelsoElem_FOR(int[] t) { // T tulajdonsßg: 80tˇl nagyobb szßm for (int i=0;i<t.Length;i++) if (t[i]>80) return i; return -1; }
Kiválasztás tétele III. (foreach, első elem)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az első ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:
public static int Kivalasztas_LegelsoElem_FOREACH(int[] t) { // T tulajdonsßg: 80tól nagyobb szßm int i=0; foreach(int a in t) { if (a>80) return i; i++; } return -1; }
Kiválasztás tétele IV. (while, utolsó elem)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az utolsó ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:
public static int Kivalasztas_LegutolsoElem_WHILE(int[] t) { // T tulajdonság: 80tól nagyobb szám int i=t.Length-1; while (i>=0 && !(t[i]>80)) i--; if (i>=0) return i; // van ilyen elem return -1; // nincs ilyen elem }
Kiválasztás tétele V. (for, utolsó elem)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az utolsó ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:
public static int Kivalasztas_LegutolsoElem_FOR(int[] t) { // T tulajdonság: 80tól nagyobb szám for (int i=t.Length-1;i>=0;i--) if (t[i]>80) return i; return -1; }
Minimumkiválasztás tétele I. (for, érték)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előforduló legkisebb elem értékét:
public static int MinimalisElem_Erteke(int[] t) { int min = t[0]; for(int i=1;i<t.Length;i++) if (min>t[i]) min=t[i]; return min; }
Minimumkiválasztás tétele II. (for, index, első)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előforduló legkisebb elem indexét. Ha ez az érték többször is előfordulna, akkor az első előfordulás indexét kell megadni:
public static int MinimalisElem_Pozicioja_1(int[] t) { int minI = 0; for(int i=1;i<t.Length;i++) if (t[minI]>t[i]) minI=i; return minI; }
Minimumkiválasztás tétele II. (for, index, utolsó)
Határozzuk meg, hogy egy adott 'N' elemű vektorban előforduló legkisebb elem indexét. Ha ez az érték többször is előfordulna, akkor az utolsó előfordulás indexét kell megadni:
public static int MinimalisElem_Pozicioja_2(int[] t) { // ha a minimßlis elem t÷bbsz÷r is szerepel a vektorban // akkor a legutolsˇ el§fordulßs indexe-t adjuk vissza int minI = 0; for(int i=1;i<t.Length;i++) if (t[minI]>=t[i]) minI=i; return minI; }
Bináris keresés
Egy adott 'N' elemű, rendezett vektorban keressünk meg egy adott érték előfordulásának indexét. Ha a keresett elem nincs a tömbben, adjunk vissza '-1'-t. Használjuk ki azt a jellemzőt, hogy a vektor rendezett:
public static int Binaris_Kereses(int[] t, int keresett_elem) { int elso = 0; int utolso = t.Length-1; int kozep; do { kozep = (elso+utolso)/2; if (t[kozep]<keresett_elem) elso = kozep+1; if (t[kozep]>keresett_elem) utolso = kozep-1; } while (t[kozep]!=keresett_elem && elso<=utolso); if (elso<=utolso) return kozep; // A keresett elem indexe: kozep return -1; // A keresett elem nincs a tömbben }
Megszámlálás I. (for)
Határozzuk meg egy adott 'N' elemű vektorban valamely T tulajdonságú elemből hány példány van. A jelen kódban a konkrét feladat: számoljuk meg hány 80-tól nagyobb érték van a tömbben:
public static int Megszamlalas_1(int[] t) { // T tulajdonsßg: 80tól nagyobb szám int db = 0; for(int i=0;i<t.Length;i++) if (t[i]>80) db++; return db; }
Megszámlálás II. (foreach)
Határozzuk meg egy adott 'N' elemű vektorban valamely T tulajdonságú elemből hány példány van. A jelen kódban a konkrét feladat: számoljuk meg hány 80-tól nagyobb érték van a tömbben:
public static int Megszamlalas_2(int[] t) { // T tulajdonsßg: 80tˇl nagyobb szßm int db = 0; foreach(int a in t) if (a>80) db++; return db; }
Kiválogatás tétele I. (for)
Egy adott, 'N' elemű vektorban szereplő adott T tulajdonságú elemeket válogassuk át egy másik vektorba. A függvény adja meg hány darab ilyen elemet talált, és pakolt át a második vektorba:
public static int VektorKivalogatas_FOR(int[] a, int[] b) { // T tulajdonság: 80tól nagyobb szám int b_db = 0; for(int i=0;i<a.Length;i++) if (a[i]>80) { b[b_db]=a[i]; b_db++; } return b_db; // ennyi elem lett a B vektorban }
Kiválogatás tétele II. (foreach)
Egy adott, 'N' elemű vektorban szereplő adott T tulajdonságú elemeket válogassuk át egy másik vektorba. A függvény adja meg hány darab ilyen elemet talált, és pakolt át a második vektorba:
public static int VektorKivalogatas_FOREACH(int[] a, int[] b) { // T tulajdonság: 80tól nagyobb szám int b_db = 0; foreach(int x in a) if (x>80) { b[b_db]=x; b_db++; } return b_db; // ennyi elem lett a B vektorban }
Szétválogatás tétele I. (for)
Egy adott, 'N' elemű vektorban szereplő adott T tulajdonságú elemeket válogassuk át egy másik vektorba. A másik vektor elején helyezzük el a T tulajdonságú elemeket. A vektor végére (második fele) helyezzük el a nem T tulajdonságú elemeket. A függvény adja meg hány darab T tulajdonságú elemet talált, és pakolt át a második vektorba (határvonal):
public static int VektorSzetvalogatas_FOR(int[] a, int[] b) { // T tulajdonság: 80tól nagyobb szám int b_el = 0; int b_ut = a.Length-1; for(int i=0;i<a.Length;i++) if (a[i]>80) { b[b_el]=a[i]; b_el++; } else { b[b_ut]=a[i]; b_ut--; } return b_el; // ennyi 'jó' elem lett a B vektorban }
Szétválogatás tétele II. (foreach)
Egy adott, 'N' elemű vektorban szereplő adott T tulajdonságú elemeket válogassuk át egy másik vektorba. A másik vektor elején helyezzük el a T tulajdonságú elemeket. A vektor végére (második fele) helyezzük el a nem T tulajdonságú elemeket. A függvény adja meg hány darab T tulajdonságú elemet talált, és pakolt át a második vektorba (határvonal):
public static int VektorSzetvalogatas_FOREACH(int[] a, int[] b) { // T tulajdonsßg: 80tˇl nagyobb szßm int b_el = 0; int b_ut = a.Length-1; foreach(int x in a) if (x>80) { b[b_el]=x; b_el++; } else { b[b_ut]=x; b_ut--; } return b_el; // ennyi 'jˇ' elem lett a B vektorban }
Összefuttatás tétele (ismétlődéssel)
Adott két elemekkel feltöltött, rendezett vektor. Generálni kell egy olyan vektort, mely tartalmazza a két vektor összes elemét, és szintén rendezett. Ha a két vektor mindegyikében előfordul ugyanazon érték, akkor a generált vektorban ezen érték kétszer szerepeljen. A megoldást optimalizáljuk sebességre, tehát ne úgy oldjuk meg, hogy a két vektor elemeit összemásoljuk, majd az eredmény vektort utólag rendezzük, hanem eleve rendezett módon generáljuk az eredmény vektort.
public static void RendezettVektorOsszefuttatasa_Ismetlodessel(int[] a, int[] b, int[] c) { int adb=0; int bdb=0; int cdb=0; while (adb<a.Length && bdb<b.Length) { if (a[adb]<b[bdb]) { c[cdb] = a[adb]; adb++; } else { c[cdb] = b[bdb]; bdb++; } cdb++; } while (adb<a.Length) { c[cdb] = a[adb]; adb++; } while (bdb<b.Length) { c[cdb] = b[bdb]; bdb++; } }
Összefuttatás tétele (ismétlődés nélkül)
Adott két elemekkel feltöltött, rendezett vektor. Generálni kell egy olyan vektort, mely tartalmazza a két vektor összes elemét, és szintén rendezett. Ha a két vektor mindegyikében előfordul ugyanazon érték, akkor a generált vektorban ezen érték csak egyszer szerepeljen. A megoldást optimalizáljuk sebességre, tehát ne úgy oldjuk meg, hogy a két vektor elemeit összemásoljuk, majd az eredmény vektort utólag rendezzük, hanem eleve rendezett módon generáljuk az eredmény vektort.
public static void RendezettVektorOsszefuttatasa_IsmetlodesNelkul(int[] a, int[] b, int[] c) { int adb=0; int bdb=0; int cdb=0; while (adb<a.Length && bdb<b.Length) { if (a[adb]==b[bdb]) { c[cdb] = a[adb]; adb++; bdb++; } else if (a[adb]<b[bdb]) { c[cdb] = a[adb]; adb++; } else { c[cdb] = b[bdb]; bdb++; } cdb++; } while (adb<a.Length) { c[cdb] = a[adb]; adb++; } while (bdb<b.Length) { c[cdb] = b[bdb]; bdb++; } }
Rendezés közvetlen elemkiválasztással
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
static public void Rendezes_KozvetlenElemkivalasztassal(int[] t) { for(int i=0;i<t.Length-1;i++) for(int j=i+1;j<t.Length;j++) if (t[i]>t[j]) { int temp=t[i]; t[i]=t[j]; t[j]=temp; } }
Rendezés maximumkiválasztással
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
static public void Rendezes_MaximumKivalasztassal(int[] t) { for (int i=t.Length-1;i>0;i--) { int max=i; for (int j=i-1;j>=0;j--) if (t[max] < t[j]) max=j; if (max != i) { int temp=t[i]; t[i]=t[max]; t[max]=temp; } } }
Rendezés minimumkiválasztással
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
static public void Rendezes_MinimumKivalasztassal(int[] t) { for (int i=0;i<t.Length-1;i++) { int min=i; for (int j=i+1;j<t.Length;j++) if (t[min] > t[j]) min=j; if (min != i) { int temp=t[i]; t[i]=t[min]; t[min]=temp; } } }
Rendezés buborék módszerrel (I.)
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
public static void Rendezes_Buborek_I(int[] t) { for (int i=t.Length-1;i>1;i--) { for (int j=0;j<i;j++) { if (t[j]>t[j+1]) { int csere = t[j+1]; t[j+1]=t[j]; t[j]=csere; } } } }
Rendezés buborék módszerrel (II.)
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
public static void Rendezes_Buborek_II(int[] t) { bool kesz=false; int k=t.Length-1; while (k>0 && !kesz) { kesz=true; for (int j=0;j<t.Length-1;j++) { if (t[j]>t[j+1]) { int c=t[j]; t[j]=t[j+1]; t[j+1]=c; kesz=false; } } k--; } }
Rendezés buborék módszerrel (III.)
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
public static void Rendezes_Buborek_III(int[] t) { int j = t.Length - 1; while (j >= 1) { int utolsocsere = 0; for (int i = 0; i < j; i++) { if (t[i] > t[i + 1]) { int a = t[i]; t[i] = t[i + 1]; t[i + 1] = a; utolsocsere = i; } } j = utolsocsere; } }
Rendezés beszúró módszerrel
Egy adott, elemekkel feltöltött vektor értékeit rendezzük növekvő sorrendbe.
public static void Rendezes_Beszuro(int[] t) { for(int i=1;i<t.Length;i++) { int x = t[i]; int j=i-1; while (j>=0 && x<t[j]) { t[j+1] = t[j]; j--; } t[j+1] = x; } }