Hypercell ein ] Hypercell aus ] Zeige Navigation ] Verstecke Navigation ]
c++.net  
   

Die mobilen Seiten von c++.net:
https://m.c-plusplus.net

  
C++ Forum :: C++ (alle ISO-Standards) ::  Aktuelle Array Position  
Gehen Sie zu Seite Zurück  1, 2, 3, 4  Weiter
  Zeige alle Beiträge auf einer Seite
Auf Beitrag antworten
Autor Nachricht
b4mbus
Mitglied

Benutzerprofil
Anmeldungsdatum: 16.04.2018
Beiträge: 15
Beitrag b4mbus Mitglied 23:40:48 16.04.2018   Titel:              Zitieren

Wow! Perfekt! Vielen Dank!

Noch einige Sachen die ich zu ändern habe, aber das versuche ich erstmal selber zu lösen :)
b4mbus
Mitglied

Benutzerprofil
Anmeldungsdatum: 16.04.2018
Beiträge: 15
Beitrag b4mbus Mitglied 23:46:56 16.04.2018   Titel:              Zitieren

Belli schrieb:
Wie sorgst Du denn eigentlich dafür, dass nicht alle untereinander stehenden Bäume sofort anfangen zu brennen?

Wenn ich mir vorstelle, dass in Spalte 15 i Bäume übereinander stehen, und der in Zeile 0 brennt, dann zündest Du bei i=0 den darunter an, und wenn Du die nächste Zeile durchgehst, erkennst Du nicht mehr, ob der Baum [1][15] schon vorher gebrannt hat, oder ob Du ihn gerade erst angezündet hast, also zündest Du jetzt [2][15] an, und so weiter, oder sehe ich das falsch?


Durch den Zähler "c" den ich aus dem Hauptprogramm ausgebe werden nur eine eingestelle Anzahl an Durchgängen durchgeführt. Aber das klappt alles sowieso noch nicht so wie ich wollte. Ich konnte aber nicht weiter machen, da mit die Arrays Kopfzerbrechen gebrahct haben


Zuletzt bearbeitet von b4mbus am 23:48:17 16.04.2018, insgesamt 1-mal bearbeitet
b4mbus
Mitglied

Benutzerprofil
Anmeldungsdatum: 16.04.2018
Beiträge: 15
Beitrag b4mbus Mitglied 00:13:48 17.04.2018   Titel:              Zitieren

Da mir die Schleife echt Probleme mit einem sauberen abbrennen macht, wäre es gut wenn ich das array irgendwie durchsuchen könnte und gleichzeitig alle Werte die zb '+' sind bearbeiten kann.

Ich hab zb das Problem das die Schleife zückwerts nicht mehr prüft ob da was brennt.


Zuletzt bearbeitet von b4mbus am 00:14:15 17.04.2018, insgesamt 1-mal bearbeitet
yahendrik
Mitglied

Benutzerprofil
Anmeldungsdatum: 30.04.2011
Beiträge: 267
Beitrag yahendrik Mitglied 03:00:50 17.04.2018   Titel:              Zitieren

Siehe Floodfill. Bei einem Waldbrand kannst du den Algorithmus auch leicht steuern, dass die Windrichtung einbezogen wird (scharfer Wind aus Nord-Ost-> nur linke und untere Bäume fangen jeweils Feuer).
Und schau dir gleich die iterative Lösung an, ein std::vector<Point> bietet sich als Stack an.
Du nimmst also die zu überprüfende Position vom stack und überprüfst die entsprechenden Richtungen, bei einem Treffer markierst du die Position als abgebrannt und fügst die Koordinate dem Stack hinzu.

Das machst du dann so lange, bis der Stack leer ist.
Klara
Unregistrierter




Beitrag Klara Unregistrierter 07:26:57 17.04.2018   Titel:              Zitieren

yahendrik schrieb:
ein std::vector<Point> bietet sich als Stack an.


Aua. nimm doch lieber einen std::stack<Point> als Stack :D
Belli
Mitglied

Benutzerprofil
Anmeldungsdatum: 29.08.2009
Beiträge: 2714
Beitrag Belli Mitglied 11:21:01 17.04.2018   Titel:              Zitieren

b4mbus schrieb:
Belli schrieb:
Wie sorgst Du denn eigentlich dafür, dass nicht alle untereinander stehenden Bäume sofort anfangen zu brennen?

Wenn ich mir vorstelle, dass in Spalte 15 i Bäume übereinander stehen, und der in Zeile 0 brennt, dann zündest Du bei i=0 den darunter an, und wenn Du die nächste Zeile durchgehst, erkennst Du nicht mehr, ob der Baum [1][15] schon vorher gebrannt hat, oder ob Du ihn gerade erst angezündet hast, also zündest Du jetzt [2][15] an, und so weiter, oder sehe ich das falsch?


Durch den Zähler "c" den ich aus dem Hauptprogramm ausgebe werden nur eine eingestelle Anzahl an Durchgängen durchgeführt. Aber das klappt alles sowieso noch nicht so wie ich wollte. Ich konnte aber nicht weiter machen, da mit die Arrays Kopfzerbrechen gebrahct haben

Ich würde es folgendermaßen machen:
Das Array zweimal vorhalten.
In einer Version ist der aktuelle Zustand.
Dieses Array durchsuchen nach den Änderungen, die zu machen sind.
Die Änderungen aber machst Du in der anderen Version des Arrays.
Dadurch ist sichergestellt, dass sich die Änderungen eines Laufes nicht unerwünscht auswirken.
Wenn Du damit fertig bist, gibst Du das geänderte Array aus.
Beim nächsten Durchlauf tauschen die beiden Arrays die Rollen, dh. das heißt, nun durchsuchst Du das Array, das im vorigen Durchlauf geändert worden ist, baust das andere Array, das zuvor durchsucht worden ist, wieder neu auf.

Ein Array ist also jeweils Quelle, eins Ziel, und nach jedem Durchlauf tauschen sie diese Rolle.
DocShoe
Mitglied

Benutzerprofil
Anmeldungsdatum: 02.04.2008
Beiträge: 2871
Beitrag DocShoe Mitglied 15:11:45 17.04.2018   Titel:              Zitieren

yahendrik schrieb:
Siehe Floodfill. Bei einem Waldbrand kannst du den Algorithmus auch leicht steuern, dass die Windrichtung einbezogen wird (scharfer Wind aus Nord-Ost-> nur linke und untere Bäume fangen jeweils Feuer).
Und schau dir gleich die iterative Lösung an, ein std::vector<Point> bietet sich als Stack an.
Du nimmst also die zu überprüfende Position vom stack und überprüfst die entsprechenden Richtungen, bei einem Treffer markierst du die Position als abgebrannt und fügst die Koordinate dem Stack hinzu.

Das machst du dann so lange, bis der Stack leer ist.

lol?

Kapsel deinen Wald in ´ne Klasse oder Struktur und erzeuge aus deinem Anfangswald den Folgewald. Dazu ein paar Zugriffsfunktionen und fertig.

Konnte jetzt nicht widerstehen :(

C++:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <vector>
#include <iostream>
 
namespace TreeState
{
    enum State_t
    {
        Invalid,
        Whole,
        Lit,
        Burnt
    };
}
 
class Forest
{
    std::size_t ExtentX_;
    std::size_t ExtentY_;
 
    std::vector<TreeState::State_t> TreeStates_;
 
public:
    Forest() :
        Forest( 30, 30 )
    {
    }
 
    Forest( std::size_t EX, std::size_t EY ) :
        ExtentX_( EX ),
        ExtentY_( EY ),
        TreeStates_( EX * EY, TreeState::Whole )
    {
    }
 
    std::size_t extent_x() const
    {
        return ExtentX_;
    }
 
    std::size_t extent_y() const
    {
        return ExtentY_;
    }
 
    TreeState::State_t tree_state( std::size_t x, std::size_t y ) const
    {
        if( x < extent_x() && y < extent_y() )
        {
            return TreeStates_[make_index( x,y )];
        }
        return TreeState::Invalid;
    }
 
    void set_tree_state( std::size_t x, std::size_t y, TreeState::State_t State )
    {
        if( x < extent_x() && y < extent_y() )
        {
            TreeStates_[make_index( x,y )] = State;
        }
    }
 
private:
    std::size_t make_index( std::size_t x, std::size_t y ) const
    {
        return extent_x() * y + x;
    }
};
 
char tree_state_symbol( TreeState::State_t State )
{
    if( State == TreeState::Whole )        return 'X';
    else if( State == TreeState::Lit )     return '+';
    else if( State == TreeState::Burnt )   return '-';
    else                                   return '?';
}
 
std::ostream& operator<<( std::ostream& os, const Forest& f )
{
    for( size_t y = 0; y < f.extent_y(); ++y )
    {
        for( size_t x = 0; x < f.extent_x(); ++x )
        {
            os << tree_state_symbol( f.tree_state( x,y ) );
        }
        os << "\n";
    }
    return os;
}
 
Forest spread_ignition( const Forest& f )
{
    Forest retVal( f.extent_x(), f.extent_y() );
    for( size_t y = 0; y < f.extent_y(); ++y )
    {
        for( size_t x = 0; x < f.extent_x(); ++x )
        {
            if( f.tree_state( x,y ) == TreeState::Whole )
            {
                if( f.tree_state( x -1, y ) == TreeState::Lit ||
                    f.tree_state( x +1, y ) == TreeState::Lit ||
                    f.tree_state( x, y -1 ) == TreeState::Lit ||
                    f.tree_state( x, y +1 ) == TreeState::Lit )
                {
                    // heil -> brennend
                    retVal.set_tree_state( x, y, TreeState::Lit );
                }
            }
            else if( f.tree_state( x,y ) == TreeState::Lit )
            {
                // brennend -> verbrannt
                retVal.set_tree_state( x, y, TreeState::Burnt );
            }
            else
            {
                // verbrannt bleibt verbrannt
                retVal.set_tree_state( x, y, f.tree_state( x,y ) );
            }
        }
    }
    return retVal;
}
 
int main()
{
    Forest f( 9, 5 );
    f.set_tree_state( 4, 2, TreeState::Lit );
 
    std::cout << f << "\n\n";
 
    f = spread_ignition( f );
    std::cout << f << "\n\n";
 
    f = spread_ignition( f );
    std::cout << f << "\n\n";
 
    f = spread_ignition( f );
    std::cout << f << "\n\n";
}


Edit:
Funktionsaufrufe korrigiert.

Edit 2:
Programm korrigiert. Bis auf Weiteres :rolleyes:

_________________
Die fünf häufigsten Anzeichen für Faulheit:
1.


Zuletzt bearbeitet von DocShoe am 09:31:25 18.04.2018, insgesamt 5-mal bearbeitet
wob
Mitglied

Benutzerprofil
Anmeldungsdatum: 09.05.2017
Beiträge: 398
Beitrag wob Mitglied 15:27:26 17.04.2018   Titel:              Zitieren

1. Wie lange brennt denn ein Baum eigentlich? Abgebrannte Bäume kommen bei DocShoe nicht vor, wenn ich das richtig sehe. Will die Aufgabe vielleicht, dass nach einer Runde brennen ein Baum abgebrannt ist?

2. Was tut ignition_progress? Refactoring/Umbenennung in spread_ignition, ohne alle Vorkommen zu ersetzen?
DocShoe
Mitglied

Benutzerprofil
Anmeldungsdatum: 02.04.2008
Beiträge: 2871
Beitrag DocShoe Mitglied 15:59:05 17.04.2018   Titel:              Zitieren

wob schrieb:

2. Was tut ignition_progress? Refactoring/Umbenennung in spread_ignition, ohne alle Vorkommen zu ersetzen?


Sehr gut, da passt jemand auf ;)

Edit:
Im Gegensatz zu mir. Hab´ die Aufgabe nur überflogen und überheblicherweise angenommen, das hätte gereicht und ich die Aufgabe verstanden. Pustekuchen...

_________________
Die fünf häufigsten Anzeichen für Faulheit:
1.


Zuletzt bearbeitet von DocShoe am 16:18:51 17.04.2018, insgesamt 1-mal bearbeitet
wob
Mitglied

Benutzerprofil
Anmeldungsdatum: 09.05.2017
Beiträge: 398
Beitrag wob Mitglied 18:49:44 17.04.2018   Titel:              Zitieren

Und wenn du ostream durch std::ostream ersetzen würdest (oder ein using machen würdest), dann würde das auch kompilieren. Macht schon Spaß, einen virtuellen Wald an mehreren Stellen anzustecken und zu schauen, wie sich das Feuer ausbreitet :cool:
C++ Forum :: C++ (alle ISO-Standards) ::  Aktuelle Array Position  
Gehen Sie zu Seite Zurück  1, 2, 3, 4  Weiter
Auf Beitrag antworten

Zeige alle Beiträge auf einer Seite




Nächstes Thema anzeigen
Vorheriges Thema anzeigen
Sie können Beiträge in dieses Forum schreiben.
Sie können auf Beiträge in diesem Forum antworten.
Sie können Ihre Beiträge in diesem Forum nicht bearbeiten.
Sie können Ihre Beiträge in diesem Forum nicht löschen.
Sie können an Umfragen in diesem Forum nicht mitmachen.

Powered by phpBB © 2001, 2002 phpBB Group :: FI Theme

c++.net ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de Werbekostenerstattung verdient werden kann.

Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info und www.c-plusplus.net enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt (vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden. Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.