ugrás a tartalomhoz

C# Aknakerő

kriszrap · 2015. Okt. 6. (K), 15.26
Sziasztok:)
Hát nem tudtam hova írni ezt vagy egyáltalán valaki foglalkozik c# al.
Egy próbát megér.
Consoloba csináltam az aknakeresőt.
Elsőként csinálok pl egy 30x30 tömböt az lesz a pálya.
Aztán csinálok a bombáknak is egy tömböt pl 5x5 (x,y). Ez tárolja a bombák pozicióját.
Aztán egy beágyazott forral meg csinálom a pályát úgy hogy ha x,y egyezik bomba[x,y] akkor oda rakok egy "9" ami a bomba helyét jelzi és így tovább.Ha nincs bomba akkor "0". Azt második for pedig pontonként kiszámolja ott hány bomba van szépen sorba.

Nagyából így néz ki a programom.

A problémám és sokat gondolkodtam de nem tudok rájönni hogy ha üres területre nyomok(space) akkor az összes üreset mezőt eltávolítsa addig amíg számot nem talál pl 1 vagy 2 ..8.
Erre milyen ciklust lehet írni??
Segítségeteket Előre köszönöm.
Ha program kód kell akkor jelezzétek.
Nem tudom hogy ebben az esetbe szükséges e.
‹ Html5, js, jquery, stb. tanulása Más is kapott levelet a JetBrains-től? ›
 ■
1

Ha jól értem a gondod, akkor

Endyl · 2015. Okt. 6. (K), 15.51
Ha jól értem a gondod, akkor egy flood fill algoritmusra lesz szükséged.
2

Sajnos még nem használtam

kriszrap · 2015. Okt. 6. (K), 19.41
Sajnos még nem használtam még... :(
Hozzá böffenteni se tudok ugy hogy picit tudnál segíteni a mükődéséről.
thx
4

Mivel C#-ul nem feltétlenül

Endyl · 2015. Okt. 6. (K), 20.31
Mivel C#-ul nem feltétlenül tudok, a wikipédiás pszeudokódnál sokkal jobb segítséget nem tudok írni. Flood fill implementálásra is csak egyszer adtam a fejem, js-ben. Szóval csak valami irányt akartam mutatni, hogy merre indulj el.

Szerintem ess neki, és ha elakadsz, akkor a kóddal együtt tedd fel kérdésed; biztos van itt olyan, aki jobban ért a C#-hoz.

De a lényeg nagyjából annyi, hogy a kezdeti helyről indulva végigjárod a szomszédos mezőkön keresztül a tömbödet addig, amíg már csak "nem üres" mező szomszédokba ütközöl. Persze figyelve arra, hogy tényleg bejárj minden csatlakozó mezőt, illetve hogy ne menj bele nem üres mezőkbe. De mindez ott van a wikin pontosan megfogalmazva :)
5

"De a lényeg nagyjából annyi,

kriszrap · 2015. Okt. 6. (K), 21.48
"De a lényeg nagyjából annyi, hogy a kezdeti helyről indulva végigjárod a szomszédos mezőkön keresztül a tömbödet addig, amíg már csak "nem üres" mező szomszédokba ütközöl. Persze figyelve arra, hogy tényleg bejárj minden csatlakozó mezőt, illetve hogy ne menj bele nem üres mezőkbe. De mindez ott van a wikin pontosan megfogalmazva "
Igen ezt szeretném elérni de akkor próbálkozom addig ha valaki tud segíteni még az írjon:) thx
6

Algoritmus

Poetro · 2015. Okt. 6. (K), 22.21
De komolyan, oda van írva az algoritmus a Wikipédia oldalára, csak implementálni kell. Ráadásul az algoritmus nem is bonyolult, talán 100 sor lehet az egész implementáció.
7

Poetro Még analizálom az

kriszrap · 2015. Okt. 7. (Sze), 06.08
Poetro
Még analizálom az algoritmust:))
11

Sajnos nem jutok semmire

kriszrap · 2015. Okt. 7. (Sze), 13.05
Sajnos nem jutok semmire se:((
Egy pl részt tudtok neked írni??:((
12

Próbáltál esetleg rákeresni

Endyl · 2015. Okt. 7. (Sze), 13.32
Próbáltál rákeresni arra, hogy C# flood fill? Esetleg még hozzácsaphatsz egyéb kulcsszavakat is, mint implementation, neadjisten minesweeper, és fogsz találni elég C# és egyéb példakódot szerintem. Lehet, hogy a többség bitmapekkel fog dolgozni, de a lényeg ugyanúgy bennük van.

Egyébként hol akadsz el, mit nem értesz a pszeudokóddal kapcsolatban? Ha meg tudsz fogalmazni egy konkrét kérdést azon túl, hogy mutassatok kódot (amit egyébként kaptál), akkor könnyebb segíteni.
13

Egyszerűen nem értem az

kriszrap · 2015. Okt. 7. (Sze), 14.51
Egyszerűen nem értem az elméletét.
Inentől buktam a dolgot .
Csak annyit írjatok le hogy hogy is mükődik:)
Egyszerűen nem tudok rájönni..
thx
14

talán úgy kéne hogy egy

kriszrap · 2015. Okt. 7. (Sze), 14.58
talán úgy kéne hogy egy pontból elindulok 8 fele mint itt a képen : (Erre már gondoltam egyszer de nem tartottam célra vezetőnek...)
De azt nem tudnám megírni hogy egy Fordított "U" alakot megcsináljak vele .
15

Nos, aknakeresőben szerintem

Endyl · 2015. Okt. 7. (Sze), 15.22
Nos, aknakeresőben szerintem elég csak 4 irányba indulni, de persze mehetsz nyolccal is, ha úgy szeretnéd. A négyirányosra ebből mit nem értesz?

Flood-fill (node, target-color, replacement-color):
 1. If target-color is equal to replacement-color, return.
 2. If the color of node is not equal to target-color, return.
 3. Set the color of node to replacement-color.
 4. Perform Flood-fill (one step to the west of node, target-color, replacement-color).
    Perform Flood-fill (one step to the east of node, target-color, replacement-color).
    Perform Flood-fill (one step to the north of node, target-color, replacement-color).
    Perform Flood-fill (one step to the south of node, target-color, replacement-color).
 5. Return.

(Mellesleg a nyolcirányos ugyanígy működik, csak a sarkokba is át kell lépni, tehát van plusz négy rekurzív függvényhívásod.)

Emögött nincs semmiféle elmélet, amit érteni kéne (illetve ez maga az elmélet, ennél egyértelműbben nem nagyon lehet leírni). Szóról szóra le van írva, hogy hogyan működik; felesleges tovább ragozni. Csak át kell fogalmazni ezeket a lépéseket a célnyelvre és kész.

Szóval mi a pontos kérdésed, mit nem értesz ebből? Ha magad sem tudod, akkor hogy várod el, hogy mi tudjuk? Ha továbbra is annyi a kérdésed, hogy az egészet nem érted, akkor javaslom, hogy kezdd el a programozás tanulását a legelejéről, mert akkor alapvető hiányosságaid vannak.
16

itt a kép amit készítettem

kriszrap · 2015. Okt. 7. (Sze), 15.57
itt a kép amit készítettem :
Itt el kell indulnom balra azt jobbra azt lefele is kétszer abból a pontból.
Azt megint bal megint jobb...
0 kat elszeretném tüntetni. De a jobb alsókat nem szeretném x jelöli.
Amit mutattál az erre képes??
17

Ez most komoly? Ha

Endyl · 2015. Okt. 7. (Sze), 16.14
Ez most komoly?
  1. Ha utánaolvastál volna a flood fillnek, akkor tudnád, hogy az ilyen problémák megoldását szolgálja. Szóval igen, képes erre.
  2. Feltettél egy kérdést. Kaptál rá választ. Most meg azt kérdezed, hogy arra válaszoltam-e? Lehet meglepő, de igen, azért javasoltam a flood fill algoritmust, mert képes erre.
  3. Amennyi időt a kép készítésére és a hozzászólás megírására fordítottál, annyi idő alatt már implementálhattad volna az algoritmust, és tudnád, hogy képes-e erre. (Tipp: igen, képes rá; erre találták ki.)
18

Eddig nagyon szépen

kriszrap · 2015. Okt. 7. (Sze), 17.39
Eddig nagyon szépen sikerült:

static int ures(int ux, int uy)
        {
            if (tabla[ux, uy] == 0)
            {
                if (tabla[ux, uy] == 0)
                {
                    Console.SetCursorPosition((ux - 1), (uy-1));
                    Console.Write(" ");
                }
                if (tabla[ux + 1, uy] == 0)
                {
                    Console.SetCursorPosition((ux - 1) + 1, (uy - 1));//jobra
                    Console.Write(" ");
                }
                if (tabla[ux - 1, uy] == 0 && ux > 1)
                {
                    Console.SetCursorPosition((ux - 1) - 1, (uy - 1)); // balra
                    Console.Write(" ");
                }
                if (tabla[ux, uy+1] == 0)
                {
                    Console.SetCursorPosition((ux - 1), (uy-1) + 1);// le
                    Console.Write(" ");
                }
                if (tabla[ux, uy - 1] == 0 && uy >1 )
                {
                    Console.SetCursorPosition((ux - 1), (uy - 1)-1); // fel
                    Console.Write(" ");
                }
            }
            return 1;
        }
ux,uy valahogy egy while ciklussal végig kéne mennem addig amig van 0;
Ez hogyan lenne célszerű?
19

Nagy vonalakban azt mondanám,

kuka · 2015. Okt. 7. (Sze), 18.15
Nagy vonalakban azt mondanám, hogy:
  • Kell bele egy kis rekurzió – hívd meg az ures() függvényt önmagából a ±1 koordinátákra.
  • Kell bele egy kis ellenőrzés – csak akkor lépj tovább a ±1 mezőre ha az nem log ki a tábláról.
  • Kell bele egy kis jelölés – a már megvizsgált mezőket jelöld meg, hogy a következő lépésben arra már ne lépj újból.
20

Ohhh Amikor írtad már előtte

kriszrap · 2015. Okt. 7. (Sze), 18.38
Ohhh Amikor írtad már előtte rábukkantam a hibákra javítottam :).
így néz ki a kód:

 static int ures(int ux, int uy)
        {
            if (tabla[ux, uy] == 0)
            {
                Console.ForegroundColor=ConsoleColor.Red;
                if (tabla[ux, uy] == 0)
                {
                    Console.SetCursorPosition((ux - 1), (uy-1));
                    Console.Write(" ");
                }
                if (tabla[ux + 1, uy] != 9 && ux <= x )
                {
                    Console.SetCursorPosition((ux - 1) + 1, (uy - 1));//jobra
                    if (tabla[ux + 1, uy] == 0)
                    {
                    Console.Write(" ");
                    }else{
                    Console.Write(tabla[ux + 1, uy]);
                    }
                }
                if (tabla[ux - 1, uy] != 9 && 1 < ux)
                {
                    Console.SetCursorPosition((ux - 1) - 1, (uy - 1));//balra
                    if (tabla[ux - 1, uy] == 0)
                    {
                        Console.Write(" ");
                    }
                    else
                    {
                        Console.Write(tabla[ux - 1, uy]);
                    }
                }
                if (tabla[ux, uy-1] != 9 && 1 < uy)
                {
                    Console.SetCursorPosition((ux - 1), (uy - 1)-1);//fel
                    if (tabla[ux, uy-1] == 0)
                    {
                        Console.Write(" ");
                    }
                    else
                    {
                        Console.Write(tabla[ux, uy-1]);
                    }
                }

                if (tabla[ux, uy + 1] != 9 &&  uy <=y)
                {
                    Console.SetCursorPosition((ux - 1), (uy - 1) + 1);//le
                    if (tabla[ux, uy + 1] == 0)
                    {
                        Console.Write(" ");
                    }
                    else
                    {
                        Console.Write(tabla[ux, uy + 1]);
                    }
                }
            }
            Console.ResetColor();
            return 1;
        }

tessék ez után hogyan tovább??
While os dolognak kéne szerintem...
Most már csak annyikéne ogy végig mennyen a poziciókon azt hogy lehetne??
21

Utólag vettem észre, hogy

kuka · 2015. Okt. 7. (Sze), 19.13
Utólag vettem észre, hogy Endyl már szépen megírta mit kell tenni. Lévén az kifejezetten satírozó algoritmus, az 1. pont kissé módosul, de a többi stimmel:

static int ures(int ux, int uy) // Flood-fill (node, target-color, replacement-color):
{
    if (ux < 0 | ux > 9 | uy < 0 | uy > 9) // 1. If target-color is equal to replacement-color, return.
        return;

    if (tabla[ux, uy] == 1) // 2. If the color of node is not equal to target-color, return.
        return;

    tabla[ux, uy] = 1; // 3. Set the color of node to replacement-color.

    ures(ux - 1, uy); // 4. Perform Flood-fill (one step to the west of node, target-color, replacement-color).
    ures(ux + 1, uy); // Perform Flood-fill (one step to the east of node, target-color, replacement-color).
    ures(ux, uy - 1); // Perform Flood-fill (one step to the north of node, target-color, replacement-color).
    ures(ux, uy + 1); // Perform Flood-fill (one step to the south of node, target-color, replacement-color).

    return; // 5. Return.
}
Feltételezve, hogy
  • a mezők mindkét terjedelemben a 0..9 intervallumban vannnak
  • a mezők értéke eredetileg 0 és a végiglépkedett mezők 1-re változnak

Ehhez már csak az aknák számolását kell hozzácsapni.

(Lövésem sincs C#-hez, úgyhogy a fenti valószínűleg tartalmaz pár szintaktikai hibát.)
22

Eddig meg vagyok de azért

kriszrap · 2015. Okt. 7. (Sze), 19.23
Eddig meg vagyok de azért köszönöm .
Csak továbbit nem tudom sajnos:(((
hogy tudom whilel az üres mezötől végig páztázni azokat a részeket ahol üres és addig amíg már nincs üres mező??
23

Bocs, de most indokolt volna

kuka · 2015. Okt. 7. (Sze), 19.32
Bocs, de most indokolt volna szünetet tartani amíg megérted, hogy mi történik abban a kódban. Merthogy rekurzív algoritmusba annyira szükséges a while mint dízelmozdonyba a facsavar.

Lépjünk egy lépést vissza az alapokhoz: rekurziót ismered?
24

vagy is önmagát kéne

kriszrap · 2015. Okt. 7. (Sze), 22.59
vagy is önmagát kéne meghívni.
Az ures fügvénynek.
25

Pontosan. Úgy ahogy a 21.

kuka · 2015. Okt. 8. (Cs), 10.46
Pontosan. Úgy ahogy a 21. hozzászólásban vázoltam. És hogy ez az önmagát hívás ne ismétlődjön a végtelenségig, azért volt fontos betenni az ellenőrzést amelyet a 19. hozzászólás utolsó pontjában említettem (illetve Endyl a 15. hozzászólás 2. pontjában).
26

"Kell bele egy kis jelölés –

kriszrap · 2015. Okt. 8. (Cs), 11.07
"Kell bele egy kis jelölés – a már megvizsgált mezőket jelöld meg, hogy a következő lépésben arra már ne lépj újból." Mire is gondoltál pontosan?
27

A 21. hozzászólásbeli kód 09.

kuka · 2015. Okt. 8. (Cs), 11.21
A 21. hozzászólásbeli kód 09. sorában a tábla aktuális mezője 1-es értéket kap. Amikor az ures() függvény később elindított példányai ismét erre a mezőre tévednének, a 06. sor feltétele félbeszakítja a tevékenységüket (azaz nem is dolgoznak már azzal a mezővel és nem is indítanak újabb ures() hívásokat a környező mezők bejárására).
29

Hát köszönöm sikerült:)

kriszrap · 2015. Okt. 8. (Cs), 17.12
Hát köszönöm sikerült:)
3

C16

zzrek · 2015. Okt. 6. (K), 19.57
Régi szép idők! Emlékszem, hogy a C-16 ilyen scanline fill-t tudott. Annakidején én is írtam ilyen feltöltőalgoritmust gépi kódban.
8

A képed alapján fiatalabbnak

Hidvégi Gábor · 2015. Okt. 7. (Sze), 09.02
A képed alapján fiatalabbnak gondoltalak.
9

kutya

zzrek · 2015. Okt. 7. (Sze), 10.22
Milyen kép? A kutyára gondolsz?
10

Igen.

Hidvégi Gábor · 2015. Okt. 7. (Sze), 11.19
Igen.
28

Igazad van

zzrek · 2015. Okt. 8. (Cs), 13.35
Igazad van, az már egy régi képem, akkor még fiatalabb voltam. Cserélnem kellett volna. :-) De látom, te minden nap szépen megborotválkozol :-)