9.1. feladat (Feltöltés billentyűzetről sorfolytonosan – szint: 1). Egy méretű egész számokból álló mátrixot töltsünk fel sorfolytonosan billentyűzetről (először töltsük fel az első sorát, majd a második sorát, stb.)! A program összesen értéket kérjen be. A megfogalmazásban az méret csak példaképpen szerepel. A program a mátrix méretének változtatásával legyen képes eltérő méretekkel is működni! A program az adatbevitel végén jelenítse meg a mátrixban szereplő értékeket a képernyőn táblázatos formában!

9.1. forráskód. Konstansok használata

     
class Program 
{ 
 const int N = 5; 
 const int M = 4; 
 public static void Main() 
 { 
   // matrix letrehozasa 
   int[,] m = new int[N,M]; 
 } 
}
    

9.2. forráskód. A mátrix bekérése

 
class Program 
{ 
 const int N = 5; 
 const int M = 4; 
 public static void Main() 
 { 
   // matrix letrehozasa 
   int[,] m = new int[N,M]; 
 } 
}

9.3. forráskód. Formázott kiírás

 
int x = 12; 
Console.Write("{0,4}",x);

9.4. forráskód. Mátrix formázott kiírása

                                                                                                                                     

                                                                                                                                     
     
for(int i=0;i<N;i++) 
{ 
 for(int j=0;j<M;j++) 
 { 
   Console.Write("{0,4}",t[i,j]); 
 } 
 Console.WriteLine(); 
}
    

9.2. feladat (Feltöltés billentyűzetről folyamatos kijelzéssel – szint: 2). A sorfolytonos feltöltés közben minden teljes sor bevitele után a mátrix már kitöltött elemeit táblázatos alakban jelenítsük meg a képernyőn! Tehát pl. a 3. sor bevitele után az első 3 sor jelenjen meg!

9.5. forráskód. Mátrix kiírása bekérés közben

 
for(int i=0;i<N;i++) 
{ 
 // i. sor bekerese 
 for(int j=0;j<M;j++) 
 { 
   Console.Write("Kerem {0},{1} elem erteket:",i,j); 
   m[i,j] = int.Parse( Console.ReadLine() ); 
 } 
 // kiiras az i. sorig 
 Console.WriteLine("----------------------------"); 
 for(int k=0;k<=i;k++) 
 { 
   for(int l=0;l<M;l++) 
   { 
      Console.Write("{0,4}",t[k,l]); 
   } 
   Console.WriteLine(); 
 } 
}

9.3. feladat (Feltöltés billentyűzetről – szint: 1). Egy méretű egész számokból álló mátrixot töltsünk fel úgy billentyűzetről, hogy a felhasználó minden egyes adatbekérés során megadja sor- és oszlopkoordináták szerint, melyik mátrixelem értékét kívánja beírni, majd beírja magát a számértéket is! A program ügyeljen arra, hogy a mátrixelemek koordinátái a méreten belül maradjanak! A felhasználó a koordinátákat ne 0-tól, hanem 1-től számozva adhassa meg, vagyis , értékekkel.

9.6. forráskód. Adatbekérés koordinátákkal

     
int db=0; 
while (db<N*M) 
{ 
 Console.Write("Kerem a matrix sorat [1..{0}]:",N); 
 int i = int.Parse( Console.ReadLine() ); 
 Console.Write("Kerem a matrix oszlopat [1..{0}]:",M); 
 int j = int.Parse( Console.ReadLine() ); 
 Console.Write("Kerem az erteket:"); 
 int x = int.Parse( Console.ReadLine() ); 
 if (1<=i && i<=N && 1<=j && j<=M) 
 { 
   m[i-1,j-1] = x; 
   db++; 
 } 
 else Console.Write("Na ezt megegyszer, hibas volt."); 
}
    

9.7. forráskód. Adatbekérés koordinátákkal v2.0

 
for (int db=0;db<<N*M;db++) 
{ 
 // sor 
 int i; 
 do 
 { 
   Console.Write("Kerem a matrix sorat [1..{0}]:",N); 
   i = int.Parse( Console.ReadLine() ); 
 } 
 while (i<1 || i>N); 
 // oszlop 
 int j; 
 do 
 { 
   Console.Write("Kerem a matrix oszlopat [1..{0}]:",M); 
   j = int.Parse( Console.ReadLine() ); 
 } 
 while (j<1 || j>M); 
 // ertek 
 Console.Write("Kerem az erteket:"); 
 int x = int.Parse( Console.ReadLine() ); 
 // tarolas 
 m[i-1,j-1] = x; 
}

9.8. forráskód. Adatbekérés függvények segítségével v3.0

 
static int sorBekeres() 
{ 
int i; 
Console.Write("Kerem a matrix sorat [1..{0}]:",N); 
do 
{ 
   i = int.Parse( Console.ReadLine() ); 
   if (i<1 || i>N) Console.WriteLine("Nem jo. Ujra!"); 
} 
while (i<1 || i>N); 
return i; 
} 
         //................................................................          
static int oszlopBekeres() 
{ 
Console.Write("Kerem a matrix oszlopat [1..{0}]:",M); 
while(true) 
{ 
   int j = int.Parse( Console.ReadLine() ); 
   if (1<=j && j<=M) return j; 
   else Console.WriteLine("Nem jo. Ujra!"); 
} 
} 
         //................................................................          
static void Main() 
{ 
 ... 
 for (int db=0;db<<N*M;db++) 
 { 
   int i=sorBekeres(); 
   int j=oszlopBekeres(); 
   Console.Write("Kerem az erteket:"); 
   int x = int.Parse( Console.ReadLine() ); 
   // tarolas 
   m[i-1,j-1] = x; 
 } 
}

9.4. feladat (Egyszerre több érték listásan – szint: 3). A mátrix feltöltése közben lehessen egy időben több értéket is megadni! Ennek során a kezelő először megadja a cella koordinátáját, majd vesszővel elválasztva több számértéket. Ezt úgy kell kezelni, hogy a számértékek közül az első az adott x,y cellába kerüljön, a következő érték a sorfolytonosan következő cellába, stb. Ha több számérték került volna be a felsorolásba, mint amennyit az adott sor képes fogadni, úgy a felesleges értékeket hagyjuk figyelmen kívül.

9.9. forráskód. String felbontása a Split segítségével

     
// pl "12,24,35" 
string s = Console.ReadLine(); 
string[] elemek = s.Split(’,’); 
// ez esetben az elemek vektor 3 elemű lesz 
// elemek[0] = "12" 
// elemek[1] = "24" 
// elemek[2] = "35"
    

9.5. feladat (Feltöltés folytatása I/N – szint: 2). A 9.3. feladatban megfogalmazott feltöltést módosítsuk annyiban, hogy a felhasználónak legyen lehetősége korábban is félbeszakítani! Ezt oldjuk meg úgy, hogy minden egyes mátrixelem beírása után jelenjen meg a Szeretne újabb adatot beírni I/N kérdés, melyre N válasz megadása esetén a bevitelből azonnal lépjen ki! A továbbiakban a program jelenítse meg a mátrixban szereplő értékeket a képernyőn táblázatos alakban!

9.10. forráskód. Console.ReadKey használata

     
ConsoleKeyInfo k = Console.ReadKey(); 
if (k.KeyChar == ’n’ || k.KeyChar == ’N’) 
 Console.Write("NEM"); 
else if (k.KeyChar == ’i’ || k.KeyChar == ’I’) 
 Console.Write("IGEN");
    

9.6. feladat (Módosítás ellenőrzése – szint: 3). A mátrix feltöltése közben előfordulhat, hogy a felhasználó egy olyan mátrixelem bevitelét végzi, amely már korábban kapott értéket. Ha ez előfordulna, úgy a koordináták beolvasása után írjuk ki a képernyőre, hogy Figyelem: ez az elem már kapott értéket. Valóban módosítani akarja I/N?! Ha a felhasználó I-t választ, úgy módosíthassa ezt az értéket, ellenkező esetben kérjünk újabb koordinátákat be!

9.11. forráskód. Mátrix előfeltöltése speciális értékekkel

 
for (int i = 0; i < N; i++) 
 for (int j = 0; j < M; j++) 
   t[i] = int.MinValue;
                                                                                                                                     

                                                                                                                                     
    

9.12. forráskód. Mátrix cellája kitöltött-e

 
class Program 
{ 
 const int N = 5; 
 const int M = 4; 
 public static void Main() 
 { 
   // matrix letrehozasa 
   int[,] m = new int[N,M]; 
   // cellkitoltott matrix letrehozasa 
   bool[,] b = new bool[N,M]; 
 } 
}

9.7. feladat (Feltöltés befejezése 0-val – szint: 2). A korábban megfogalmazott van még elem I/N típusú befejezéssel az a gond, hogy legalább egy mátrixbeli elemet be kell írni, hogy befejezhessük a bevitelt. A felhasználónak ehelyett úgy kell jeleznie, hogy nincs további bevitel, hogy az vagy koordinátához 0 értéket ír be. Amennyiben az -hez ír be 0-t, úgy az értékét nem kell bekérni. A bevitel végén a mátrix jelenjen meg a képernyőn táblázatos alakban!

9.8. feladat (Nincs kitöltve jelzés – szint: 3). Amennyiben a felhasználó a bevitel végét kérné, a program ellenőrizze, hogy a mátrix minden eleme kitöltésre került-e! Amennyiben nem, úgy jelenítse meg a még N kitöltetlen elem van, be kívánja fejezni I/N üzenetet (N helyébe kerül a kitöltetlen elemek száma)! Amennyiben a felhasználó ennek ellenére kéri a bevitel befejezését, úgy a bevitel érjen véget! Nem válasz esetén a bevitel folytatódhasson! Ha a bevitel végét úgy kéri a felhasználó, hogy valóban már minden mátrixelem kitöltésre került, úgy a fenti üzenet ne jelenjen meg, a bevitel azonnal érjen véget! A program jelenítse meg a mátrixot a képernyőn táblázatos alakban!

9.13. forráskód. Kitöltetlen elemek száma

 
static int kitoltetlenElemekSzama() 
{ 
  int db=0; 
  for(int i=0;i<N;i++) 
   for (int j=0;j<M;j++) 
     if (seged[i,i]==false) db++; 
  // 
  return db; 
}

9.9. feladat (Mátrix térképe – szint: 2). Oldjuk meg a bevitelt úgy, hogy a képernyő felső részén jelenjen meg a mátrix térképe, jelezvén, hol van kitöltött és kitöltetlen elem. Ezt úgy érjük el, hogy a kitöltött elemek helyén egy * (csillag) karakter jelenjen meg, a kitöltetlen elemek helyén pedig egy . (pont) karakter. Mivel így a felhasználó folyamatosan nyomon követheti, hol van feltöltött vagy feltöltetlen elem, a kilépés kérése esetén azonnal befejezhető a bevitel.

9.1. ábra. Mátrixtérkép, beviteli képernyő

9.10. feladat (Mátrix területi feltöltése – szint: 2). A mátrix feltöltése történjen billentyűzetről adatbevitellel az alábbi módon: a mátrixban elhatárolunk kis területeket, melyek a nagy mátrix kis egybefüggő téglalap alakú területei. Minden területnek van bal felső sarka (x,y) koordinátákkal megadva, szélessége és magassága. A bevitel során kérjük be egy ilyen terület bal felső sarkának koordinátáját (x,y), majd a szélességét és magasságát, végül egy feltöltő értéket! A mátrix adott részterületébe eső cellákat töltsük fel egységesen ezen értékkel!

9.2. ábra. Mátrix területi feltöltése

9.14. forráskód. A terület elővizsgálata

     
int x   = int.Parse(Console.ReadLine()); 
int y   = int.Parse(Console.ReadLine()); 
int szel = int.Parse(Console.ReadLine()); 
int mag = int.Parse(Console.ReadLine()); 
int x   = int.Parse(Console.ReadLine()); 
// ---- ELOZETES KORREKCIO ----- 
// x negativ, kilog balra 
if (x<0) { szel = szel+x; x=0;} 
// x kilog jobbra 
if (x>N-1) { szel=0; } 
// y negativ, kilog fent 
if (y<0) { mag = mag+y; x=0;} 
// y kilog lent 
if (y>=M) { mag=0; } 
// x+szel kilog jobbra 
if (x+szel>N-1) szel=N-x; 
// y+mag kilog alul 
if (y+mag>M-1) mag=M-y; 
// ----- FELTOLTES ---- 
for(int i=x;i<x+szel;i++) 
  for(int j=y;j+mag;j++) 
   m[i,j]=x;
    

9.15. forráskód. A koordináták egyenkénti ellenőrzése

 
int x   = int.Parse(Console.ReadLine()); 
int y   = int.Parse(Console.ReadLine()); 
int szel = int.Parse(Console.ReadLine()); 
int mag = int.Parse(Console.ReadLine()); 
int x   = int.Parse(Console.ReadLine()); 
// ----- FELTOLTES ---- 
for(int i=x;i<x+szel;i++) 
  for(int j=y;j+mag;j++) 
   if (0<=i && i<N && 0<=j && j<M) 
     m[i,j]=x;

9.11. feladat (Exceles bevitel – szint: 3). A mátrix elemeinek bevitelét oldjuk meg úgy, hogy induláskor megjelenítjük a képernyőn a mátrixot táblázatos alakban, a cellákban a 0 kezdőértékekkel! A felhasználónak legyen lehetősége a kurzornyilakkal kiválasztani, melyik cella értékét kívánja megadni az Enter leütésével! Ekkor a táblázat alján jelenjen meg a cella koordinátája, a cella jelenlegi értéke, és legyen lehetőség az új számérték beírására!

9.1. videó. Excel bevitel futási képernyője

9.16. forráskód. Navigálás a mátrixban

     
const int N = 5; 
const int M = 4; 
int[,] m = new int[N, M]; 
 
for (int k = 0; k < N; k++) 
{ 
   for (int l = 0; l < M; l++) 
      Console.Write(" {0,5} ", m[k, l]); 
   Console.WriteLine(); 
} 
 
int i = 0, j = 0; 
bool folyt = true; 
while (folyt) 
{ 
   // m[i,j] cella kiemelese 
   Console.SetCursorPosition(j * 7, i); 
   Console.BackgroundColor = ConsoleColor.Green; 
   Console.Write(" {0,5} ", m[i, j]); 
   Console.BackgroundColor = ConsoleColor.Black; 
   // 
   ConsoleKeyInfo k = Console.ReadKey(); 
   // m[i,j] cella kiemeles megszuntetese 
   Console.SetCursorPosition(j * 7,i ); 
   Console.BackgroundColor = ConsoleColor.Black; 
   Console.Write(" {0,5} ", m[i, j]); 
   // .. 
   switch (k.Key) 
   { 
      case ConsoleKey.UpArrow: 
         if (i > 0) i--; 
         break; 
      case ConsoleKey.DownArrow: 
         if (i < N - 1) i++; 
         break; 
      case ConsoleKey.LeftArrow: 
         if (j > 0) j--; 
         break; 
      case ConsoleKey.RightArrow: 
         if (j < M - 1) j++; 
         break; 
      case ConsoleKey.Escape: 
         folyt = false; 
         break; 
      case ConsoleKey.Enter: 
         // m[i,j] bekerese 
         // ... 
         break; 
   } 
}
    

9.12. feladat (Feltöltés véletlen számokkal – szint: 1). Egy méretű egész számokból álló mátrixot töltsünk fel véletlen számokkal, az intervallumból! A program induláskor kérje be az N és M értékét, valamint az A és B értékeket is! A program a feltöltés után jelenítse meg a képernyőn a kapott mátrixot táblázatos alakban!

9.17. forráskód. Feltöltés véletlen számokkal

     
Random rnd = new Random(); 
// 
for (int i = 0; i < N; i++) 
{ 
   for (int j = 0; j < M; j++) 
      m[i, j] = rnd.Next(A,B+1); 
}
    

9.13. feladat (Feltöltés fájlból – szint: 4). Egy méretű egész számokból álló mátrixot töltsünk fel úgy, hogy a mátrixba kerülő értékek egy text fájlban vannak! A text fájl szerkezet szerinti első sora tartalmazza az N és M értékét szóközzel elválasztva, majd alatta N sor következik, mindegyikben M darab számérték, szintén szóközökkel elválasztva. A sorok végét a szokásos \r \n karakterek zárják. A program ügyeljen arra, hogy a text fájl hibás is lehet, vagyis egy sorban több vagy kevesebb mint M szám szerepelhet, és több vagy kevesebb mint N sora is lehet a text fájlnak! A beolvasás végén a program táblázatos formában jelenítse meg a képernyőn a beolvasott mátrixot, és jelezze, hogy tapasztalt-e hibát a text fájl feldolgozása közben!

9.18. forráskód. Beolvasás fájlból

                                                                                                                                     

                                                                                                                                     
     
using System; 
using System.Text; 
using System.IO; 
 
string fname = @"c:\adatok.txt"; 
StreamReader r = new StreamReader(fname, Encoding.Default); 
while (!r.EndOfStream) 
{ 
 string s = r.ReadLine(); 
 ... 
} 
r.Close();
    

9.19. forráskód. Beolvasás fájlból

 
StreamReader r = new StreamReader(fname, Encoding.Default); 
// elso sor N es M erteke 
string[] ee = r.ReadLine().Split(’ ’); 
int N = int.Parse( ee[0] ); 
int M = int.Parse( ee[1] ); 
int[,] m = new int[N,M]; 
// a matrix sorainak beolvasas 
int i=0; 
while (!r.EndOfStream) 
{ 
 string[] ss = r.ReadLine().Split(’ ’); 
 for(int j=0;j<M;j++) 
   m[i,j] = int.Parse(ss[j]); 
 i++; 
} 
r.Close();

9.14. feladat (Labirintus beolvasása fájlból – szint: 3). Egy text fájlban * és . karakterekből (csillag és pont) álló sorok vannak. A sorok egyforma hosszúak, egyéb karaktert nem tartalmaznak. A * és . karakterek egy labirintust írnak le, ahol a * reprezentálja a falat, a . karakter a folyosót. Ezek együtt egy méretű, karakterekből álló mátrixot írnak le, ahol N a sorok száma a text fájlban, M pedig a soronkénti karakterszám. A fájl első sorában egyetlen szám, a mátrix sorainak száma szerepel, a maradék sorokban a csillag és pont karakterekből álló rajzolat. Olvassuk be a mátrixot, majd jelenítsük meg a képernyőn oly módon, hogy a * karakterek pirossal, a . karakterek zöld színnel jelenjenek meg a képernyőn!

9.20. forráskód. Labirintus beolvasása fájlból

                                                                                                                                     

                                                                                                                                     
     
StreamReader r = new StreamReader(fname, Encoding.Default); 
// elso sor N erteke 
int N = int.Parse( Console.ReadLine() ); 
string[] m = new string[N]; 
for(int i=0;i<N;i++) 
{ 
 m[i] = r.ReadLine(); 
} 
r.Close();
    

9.21. forráskód. Labirintus kiírása a képernyőre

 
for(int i=0;i<N;i++) 
{ 
 for(int j=0;j<m[i].Length;j++) 
 { 
   if (m[i][j]==’.’) Console.ForegroundColor = ConsoleColor.Green; 
   else Console.ForegroundColor = ConsoleColor.Red; 
   Console.Write(m[i][j]); 
 } 
 Console.WriteLine(); 
}

9.15. feladat (Sziget generálása – szint: 4). Az óceán közepén egy szabálytalan körvonalú sziget terül el, mely befoglalható egy méretű téglalapba. A sziget közepén egy vulkán terül el. A téglalap minden négyzetkilométeréhez hozzárendelünk egy jellemző tengerszint feletti magasságértéket, melyet méréssel és átlagolással határoztunk meg. Generáljunk egy méretű mátrixot, amely lehetne akár ezen sziget magassági értékeit tároló mátrixa is! A magasságértékek közötti (méterben értett) értékek legyenek! Jelenítsük meg a mátrixot a képernyőn táblázatos alakban, használjunk színeket is a különböző magasságértékek esetén sávosan (pl: legyen sárga, legyen zöld, stb.)! A 9.3. ábrán látható egy minta, ahol a sötétebb színek a magasabb részeket jelölik, a világosabbak pedig az alacsonyabbakat. Ügyeljünk a következőkre:

• a sziget a közepe fele haladva magasodik, tehát minél beljebb vagyunk, annál valószínűbben szerepeljenek nagyobb számértékek a mátrixban,

• a sziget közepe tájékán elterülő vulkán krátere jóval alacsonyabb, mint a kráter szélei, ez egy cellát jelent a mátrix esetén (magassága [200,300] közé esik).

9.3. ábra. A sziget egy lehetséges kinézete

9.4. ábra. A vulkán krátere és a 8 szomszéd

9.5. ábra. A vulkán krátere és a véletlenszerű kiválasztás

9.6. ábra. A vulkán krátere kétmenetes vastagítás után

9.7. ábra. A véletlen vastagítás eredménye

9.22. forráskód. A vastagítás kódja (1. rész)

     
const int N = 20; 
static int[,] m = new int[N, N]; 
static Random rnd = new Random(); 
// 
static void vulkanKratere(int a, int f) 
{ 
   int x = (N / 2) + rnd.Next(-1,+2); 
   int y = (N / 2) + rnd.Next(-1, +2); 
   m[x, y] = rnd.Next(a, f + 1); 
}
    
                                                                                                                                     

                                                                                                                                     
    

9.23. forráskód. A vastagítás kódja (2. rész)

 
static bool szomszedSzimpatikus(int x, int y) 
{ 
   for (int i = x - 1; i <= x + 1; i++) 
      for (int j = y - 1; j <= y + 1; j++) 
         if (0 <= i && i < N && 0 <= j && j < N && m[i, j] > 0) 
            return true; 
   // 
   return false; 
} 
         //................................................................          
static void vastagit(int a, int f, int esely) 
{ 
   int[,] temp = (int[,])(m.Clone()); 
   for (int i = 0; i < N; i++) 
      for (int j = 0; j < N; j++) 
         if (temp[i,j]==0 && szomszedSzimpatikus(i, j)) 
            if (rnd.Next(0,100)<esely) 
               temp[i, j] = rnd.Next(a, f + 1); 
   m = temp; 
}

9.24. forráskód. A vastagítás kódja (3. rész)

 
static void Main() 
{ 
   vulkanKratere(200, 300); 
   for(int i = 0;i<2;i++) 
      vastagit(400, 500, 70-i*10); 
   for (int i = 0; i < 2; i++) 
      vastagit(300, 400, 70 - i * 10); 
   for (int i = 0; i < 2; i++) 
      vastagit(200, 300, 70 - i * 10); 
   for (int i = 0; i < 2; i++) 
      vastagit(100, 200, 70 - i * 10); 
 
   // 
   for (int i = 0; i < N; i++) 
   { 
      for (int j = 0; j < N; j++) 
      { 
         ConsoleColor c = ConsoleColor.Gray; 
         if (m[i, j] < 100) c = ConsoleColor.Gray; 
         else if (m[i, j] < 200) c = ConsoleColor.Yellow; 
         else if (m[i, j] < 300) c = ConsoleColor.Green; 
         else if (m[i, j] < 400) c = ConsoleColor.Blue; 
         else if (m[i, j] < 500) c = ConsoleColor.Red; 
         Console.ForegroundColor = c; 
         if (m[i, j] == 0) Console.Write(’.’); 
         else Console.Write(’#’); 
      } 
      Console.WriteLine(); 
   } 
   Console.ReadKey(); 
}

9.8. ábra. A 8 irányú ellenőrzés miatt kimarad 1 cella

9.9. ábra. A 4 irányú ellenőrzéskor is kimaradhat 1 cella

9.10. ábra. A szélről induló benyúlás nem hibás

9.11. ábra. Hibákat tartalmazó sziget

9.25. forráskód. Festő algoritmus

     
static void befest(int x, int y) 
{ 
   if (m[x, y] != 0) return; 
   m[x, y] = 1; 
   if (x > 0) befest(x - 1, y); 
   if (x <N-1) befest(x + 1, y); 
   if (y > 0) befest(x, y-1); 
   if (y < N - 1) befest(x, y+1); 
} 
         //................................................................          
static void jolBefest() 
{ 
   for (int i = 0; i < N; i++) 
   { 
      if (m[i, 0] == 0) befest(i, 0); 
      if (m[0, i] == 0) befest(0, i); 
      if (m[i, N-1] == 0) befest(i,N-1); 
      if (m[N - 1,i] == 0) befest(N - 1,i); 
   } 
}
    

9.26. forráskód. Korrekciózás a belső cellákra

 
static int atlagSzamit(int x, int y) 
{ 
   int ossz = 0, db = 0; 
   for (int i = x - 1; i <= x + 1; i++) 
      for (int j = y - 1; j <= y + 1; j++) 
         if (0 <= i && i < N && 0 <= j && j < N && m[i, j] > 0) 
         { 
            ossz += m[i]; 
            db++; 
         } 
   if (db == 0) return 0; 
   else return ossz/db; 
} 
         //................................................................          
static void korrekcio() 
{ 
   for (int i = 0; i < N; i++) 
      for (int j = 0; j < N; j++) 
         if (m[i, j] == 0) 
         { 
            int x = atlagSzamit(i, j)+rnd.Next(-20,20); 
            if (x<0) x=0; 
            else if (x>500) x=500; 
            m[i, j] = x; 
         } 
}
                                                                                                                                     

                                                                                                                                     
    

9.12. ábra. A korrekciózott, garantáltan „tökéletes” eredmény

9.16. feladat (Aknakereső – szint: 2). Az ismert aknakereső játékban egy méretű mátrixba kell K darab aknát elhelyezni. Az aknák elhelyezésének szabályai:

• ne tegyünk kétszer ugyanarra a helyre aknát, hogy a K darab akna a területen fellelhető legyen K különböző cellában,

• az aknák oldalukkal, sarkukkal szomszédos cellákba is kerülhetnek,

• az aknák a mátrix szélső celláiba is kerülhetnek.

A megfelelően feltöltött mátrixot jelenítsük meg a képernyőn oly módon, hogy az üres cellákat zöld színű . (pont) karakterek szimbolizálják, míg az aknát tartalmazó cellákat piros színű * (csillag) karakterek jelezzék!

9.13. ábra. Az aknakereső képernyője grafikusan

9.17. feladat (Torpedó játék – szint: 5). Egy méretű területen hajókat helyezünk el. A hajók mérete és száma különböző:

• csónakok (egyetlen cellát foglalnak el),

• halászhajók (két szomszédos cellát foglalnak el),

• cirkálók (három cella méretűek),

• rombolók (négy cella méretűek),

• anyahajók (öt cella méretűek).

A hajók alakja tetszőleges lehet, feltéve ha összefüggőek. Összefüggő akkor egy hajó, ha a hajót alkotó minden cella legalább egy másik cellával él mentén érintkezik.

Készítsünk olyan programot, amely egy méretű mátrixban elkészíti a hajók egy véletlenszerű elhelyezését oly módon, hogy 1 db anyahajó, 2 db hadihajó, 3 db cirkáló, 4 halászhajó és 5 csónak kerül elhelyezésre! A hajók egymással nem érintkezhetnek, még a sarkaik mentén sem, vagyis két különböző hajót alkotó cella még sarkával sem érhet össze. A hajók viszont a terület széleit elérhetik.

A programot úgy kell elkészíteni, hogy rugalmasan alkalmazkodjon a hajók darabszámának változásához, vagyis a hajók számát egy konstans formájában adjuk meg. A konstans értékének átírásakor a program megfelelő számú hajót helyezzen el! A program ügyeljen arra, hogy nagy mennyiségű hajó egyszerűen nem helyezhető el a területen (mivel a hajók nem érhetnek össze)! A program ilyen esetben se kerüljön végtelen ciklusba, jelezze ki a megoldhatatlanságot, és álljon le a futása!

A program a sikeres elhelyezés végén jelenítse meg a hajókat a képernyőn, * karakterrel jelezve a hajót felépítő cellákat, és . karakterrel a vizet!

9.14. ábra. A nagyobb hajók alakjainak néhány variációja

9.15. ábra. A lineáris irányú haladás bajba juthat

9.16. ábra. A cellaválasztás véletlenszerűsítése

9.17. ábra. Az irányok összekeverése