In der anderen Klasse ist es umgekehrt, das sind die IL Instruktionen von denen Floste gesprochen hat.
So der zweite Teil liegt an der String.Concat (der Reflector verschluckt das, Jade zeigt es richtig an, der Reflector zeigt nur zwei verräterische Klammern an)
Wenn jetzt die "falsche" Methode aufgerufen wird ist wird die variable pws abgerufen ohne das sie initalisiert wurde übrig bleibt der Typ, der ist eben System.String[] der wird magischerweise fund zugewiesen, die eigentlich System-String ist (Aber warum? Das habe ich nicht ganz kapiert) und diese Variable wiederum wird dann an String.Concat(object) übergeben, diese Überladung ruft object.ToString() auf der den Typ als String zurückgibt, und das ist das richtige Passwort.
In der anderen Klasse ist es umgekehrt, das sind die IL Instruktionen von denen Floste gesprochen hat.
Richtig
Zitat von Scavanger
Wenn jetzt die "falsche" Methode aufgerufen wird ist wird die variable pws abgerufen ohne das sie initalisiert wurde übrig bleibt der Typ, der ist eben System.String[] der wird magischerweise fund zugewiesen, die eigentlich System-String ist (Aber warum? Das habe ich nicht ganz kapiert)
Mit magie hat das ganze nichts zutun.
Hehe, also übrigbleiben tut bei einer nicht initialisierten variable erstmal ein null.
Eigendlich wurde es ja initialisiert, nur sind im speicher die felder einer klasse keineswegs alphabetisch sortiert, sondern (mit bestimmten ausnahmen) in der reihenfolge, in der sie definiert wurden. Und in DisplayClass1 und DisplayClass4 sind die felder fund und pws im speicher vertauscht. Daher ist pws in fund zu finden und umgekehrt, wenn man einen reinterpret cast durchführt.
Da ein string[] aber dadurch immernoch kein string ist, ist ToString nötig, sonst gibts abstürtze, und um das unauffällig zu machen eben das Concat.
Markus war zwar schneller, aber irgendwie gefällt mir deine Antwort besser, Scavanger. Gelöst ist es in jedem Fall. -> Der Nächste kann ne Aufgabe stellen
Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von Floste am .
Projekte:Jade, HttpSaver
Zum Rechtschreiben gibts doch schon die Politiker. Aber die bauen auch nur mist!
Welchen Code? Lade dir die Assemly und schau sie dir in Jade.net/Reflector oder jage die Assembly durch Ildasm, so wie es gedacht ist...
O.K.,
dann doch mal eine neue Aufgabe:
Das Ziel besteht darin ein kleines Programm zu schreiben das folgenden Kartentrick vorführt:
Zitat
Sie suchen sich aus 20 verschiedenen Spielkarten (z.B. 10 - Ass, alle Farben) eine Karte aus und merken sie sich. Ich lege die Karten sichtbar nacheinander auf 5 Stapel (nach dem letzten Stapel beginne ich wieder mit dem ersten) und sie sagen mir in welchen Stapel sich die Karte befindet. Das ganze wird nochmal wiederholt allerdings nur mit 4 Stapeln.
Danach sage ich ihnen welche Karte sie sich ausgesucht haben.
Edit:
Wegen einer Nachfrage:
Die Stapel werden zwischen den beiden Durchgängen nicht gemischt, d.h. die Reihenfolge der Karten bleibt immer gleich.
Eine Konsolenanwendung reicht völlig aus, auf den Lösungsalgorithmus kommts an
Viel Spass!
Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von Scavanger am .
Ich möchte nochmal darauf hinweisen, dass eine Aufgabe nur dann gelöst ist, wenn der Aufgabensteller es bestätigt, nicht wenn der Lösende einfach sagt das sie gelöst sein müsste! (Oder aber natürlich aufgrund von lang andauernder Inaktivität keine Antwort mehr zu erwarten ist)
Interessante Lösung,so gehts natürlich auch, aber eigentlich wollte ich auf eine andere
Lösung hinaus:
Den chinesisches Restsatz:
Den ganzen "Trick" kann man als ein System von Kongruenzen betrachten.
Die Nummer des Stapels entspricht der Restklasse der gemerkten Kartennummer im Stapel Modulo 5 bzw. 4. Da 5 und 4 paarweise Teilerfremd sind gibt es eine eindeutige Lösung in der Menge { 1 ... 20 } (Z 20) (5x4 = 20).
Nun benötigt man die modular Inversen von 20 bzgl. mod 5 und 4:
M1 = 20 / 5 = 4 ~M1 = 4 mod 5 = 5 N1 = 4 * 4 = 16
M2 = 20 / 4 = 5 ~M2 = 5 mod 4 = 1 N2 = 1 * 5 = 5
Um nun die gemerkte Karte zu berechnen braucht man nur noch einsetzen und ds ganze mod 20 zu nehmen:
Für einen Leveleditor für das Spiel "Pacman" (Pacman) ist eine Überprüfung notwendig, ob Pacman auf ein beliebiges Feld zugriff hat.
Es ist eine Methode zu erstellen die mindestens diesen Kopf aufweisen muss:
private bool IsAccessable(int sourceX, int sourceY, int destX, int destY){ ... }
Natürlich dürfen mehr Parameter verwendet werden bzw. x/y als Point realisiert werden.
Die Methode soll 'true' zurückgeben, wenn man vom Startpunkt den Zielpunkt erreichen kann, ansonsten 'false'. Das Feld in dem ihr euch befindet ist ein 2D-Buttonarray. Ein "befahrbares" Feld hat in den Himmelsrichtungen eine "Schranke" die geöffnet oder geschlossen werden kann.
Um mit meinem Leveleditor ein Level zu erzeugen müsst ihr einfach oben im Toolstripmenü auf 'new' klicken (Funktioniert nur einmal pro Start!). Man kann dann das Feld beliebig verändern und jederzeit über das ToolStripItem 'CanPacmanAccess?' testen, ob Pacman den Käfig der Geister erreichen kann!. Die öffentlichen Variablen könnt ihr unter der Region 'Variables' finden, der Rest des Projekts sollte nicht von Belang sein.
Um nicht zu vergessen: Das ToolstripItem 'CanPacmanAccess?' muss ebenfalls implementiert werden. Dort wird eure Methode aufgerufen (siehe Source im Anhang).
Ich habe noch zwei Bilder in den Ordner gepackt, was eventuelle Testfälle sein könnten.
Sollten noch unklarheiten bestehen habt keine Angst mich zu fragen
ich habe mir gerade das Projekt angeschaut und wollte schon anfangen, jedoch habe ich jetzt nur noch Fragezeichen über meinem Kopf.
Dein Aufbau wie ich ihn verstanden habe:
Du hast gaaaanz viele Buttons, wobei es 4 Typen gibt. Die flächen (Pacmans gehweg) , die kleinen Ecken und Horizontale sovie Vertikale Schranken, wie du sie nennst. In den Schranken unterscheidest du anhand der Backgroundcolor ob sie offen oder zu ist.
Das ganze hast du in deinem Array pacmanField.
Was mir zum Lösen dieser Aufgabe ganz klar fehlt ist eine Funktion, mit der ich per X und Y Angabe an jede Fläche komme (Pacmans gehweg) und über diese Fläche an die Schranken dieser Fläche, wobei sich jedoch 2 Gehwege die Schranke dazwischen teilen.
Oder:
Eine Unterscheidung in den Buttons in pacmanField, weil sowohl schranken als auch Felder nur ihre Kordinaten im Tag-Feld haben.
Ich stoppe an dieser Stelle mit dem Forschen in deinem Quellcode und hoffe auf konkretere Vorstellungen für den Lösungsweg.
Du kannst um nur die Felder durchzulaufen den Delegate ganz oben verwenden (ChangeButton) und dann rufst du einfach die Methode 'AccessAllField' auf (Beachte dass du bei dem referenzierten Button IMMER null kriegst!). Der Methode übergibst du einfach den Delegaten der benötigt wird und null falls du beispielsweise bei einer Ecke nichts unternehmen möchtest. Des Weiteren kann man ein Feld daran erkennen, dass beide Koordinaten ungerade sind.
Wenn du noch wissen willst was es ist (Feld, Schranke, Ecke,...) kannst du das vlt. im Control.Name Prop. abspeichern:
private void InitEdge(ref Button b, int i, int h)
{
.
.
.
.
b.Name = "Ecke";
}
private void InitField(ref Button b, int i, int h)
{
.
.
.
.
b.Name = "Feld";
}
private void InitHorStone(ref Button b, int i, int h)
{
.
.
.
.
b.Name = "HSchranke";
}
private void InitVerStone(ref Button b, int i, int h)
{
.
.
.
.
b.Name = "VSchranke";
}
//EDIT: Im angehängten Bild siehst du wie du die Schranken des Feldes kriegst
Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Daniel B. am .
Das ganze ist nichts anders als den Weg durch ein Labyrinth suchen.
Ich habe einen einfachen Backtracking-Algorithmus (Versuch und Irrtum) mit einem Stack als Ariadnefaden (um wieder herauszufeinden) dafür verwendet.
Er findet nicht den kürzesten Weg, sondern macht unnötig viele Umwege, aber der kürzeste Weg war ja nicht gefragt.
Ich habe das ganze in eine eigen Klasse gesteckt damit es übersichtlicher ist, und habe auch nicht direkt auf dem Button Array gearbeitet, sonder mit einem eigenem, damit lässt sich leicher durch das Labyrinth laufen.
Hier die Methoden im Leveleditor:
private void canPacmanAccessToolStripMenuItem_Click(object sender, EventArgs e)
{
if (IsAccessable(startPoint[0], startPoint[1], cageField[0], cageField[1]))
MessageBox.Show("YES! Pacman can access!");
else
MessageBox.Show("NO! Pacman can NOT access.");
}
private bool IsAccessable(int sourceX, int sourceY, int destX, int destY)
{
// Labyrinth aus dem Button Array erzugen
Pathfinder.Field[,] labyrinth = new Pathfinder.Field[11,8];
for (int i = 0; i < 11; i++)
{
for (int j = 0; j < 8; j++)
{
Pathfinder.Field curField = new Pathfinder.Field();
int curPacmanField_X = i == 0 ? 1 : i * 2 + 1;
int curPacmanField_Y = j == 0 ? 1 : j * 2 + 1;
// Feld oben geschlossen?
if (pacmanField[curPacmanField_X, curPacmanField_Y - 1].BackColor == colorClosed)
curField.WallAbove = true;
// Feld rechts geschlossen?
if (pacmanField[curPacmanField_X + 1, curPacmanField_Y].BackColor == colorClosed)
curField.WallRight = true;
// Feld unten geschlossen?
if (pacmanField[curPacmanField_X, curPacmanField_Y + 1].BackColor == colorClosed)
curField.WallBelow = true;
// Feld links geschlossen?
if (pacmanField[curPacmanField_X - 1, curPacmanField_Y].BackColor == colorClosed)
curField.WallLeft = true;
labyrinth[i, j] = curField;
}
}
Pathfinder pathfinder = new Pathfinder(labyrinth, 11, 8);
return pathfinder.CanReach(ToRealIndex(sourceX), ToRealIndex(sourceY), ToRealIndex(destX), ToRealIndex(destY));
}
private int ToRealIndex(int index)
{
return (int)(index / 2);
}
Und meine Pathfinder-Klasse, die den eigentlichen Weg findet:
using System;
using System.Collections.Generic;
namespace pacman
{
class Pathfinder
{
/// <summary>
/// Ein Feld im Labyrinth
/// </summary>
public class Field
{
public bool WallAbove { get; set; }
public bool WallRight { get; set; }
public bool WallBelow { get; set; }
public bool WallLeft { get; set; }
public bool visited { get; set; }
}
/// <summary>
/// Ein Punkt im Labyrinth, für den "Faden" benötigt
/// </summary>
class Point
{
public int X { get; set; }
public int Y { get; set; }
public Point(int x, int y)
{
X = x;
Y = y;
}
}
/// <summary>
/// Das Labyrinth als 2D-Array
/// </summary>
private Field[,] labyrinth;
private int rows;
private int colums;
public Pathfinder(Field[,] labyrinth, int rows, int colums)
{
if (labyrinth.Length < 4 || labyrinth == null)
throw new ArgumentException("No valid labyrinth");
if (rows < 2 || colums < 2)
throw new ArgumentException("Invalid row or colums count.");
this.labyrinth = labyrinth;
this.rows = rows - 1;
this.colums = colums - 1;
}
private bool FieldAlreadyVisited(int x, int y)
{
// Oben raus, unten rein, rechts raus, links rein umd umgekehrt ;)
if (x < 0)
x = rows;
if (x > rows)
x = 0;
if (y < 0)
y = colums;
if (y > colums)
y = 0;
return labyrinth[x, y].visited;
}
public bool CanReach(int startX, int startY, int targetX, int targetY)
{
if (startX > rows || startY > colums || startX < 0 || startY < 0)
throw new ArgumentException("No valid start point.");
if (targetX > rows || targetY > colums || targetX < 0 || targetY < 0)
throw new ArgumentException("No valid target point.");
if (startX == targetX && startY == targetY)
throw new ArgumentException("Start and target are equal.");
// Der Ariadnefaden um im Labyrinth wieder (aus Sackgasse) herauszufinden
Stack<Point> ariadne = new Stack<Point>();
// Startwerte setzten
int curFieldX = startX;
int curFieldY = startY;
while (true)
{
// Ziel schon erreicht?
if (curFieldX == targetX && curFieldY == targetY)
return true;
// In das nächte Feld gehen, wenn keine Wand im Weg oder nicht schon besucht
if (!labyrinth[curFieldX, curFieldY].WallAbove && !FieldAlreadyVisited(curFieldX, curFieldY - 1))
{
if (curFieldY - 1 < 0)
curFieldY = colums;
else
curFieldY--;
}
else if (!labyrinth[curFieldX, curFieldY].WallRight && !FieldAlreadyVisited(curFieldX + 1, curFieldY))
{
if (curFieldX + 1 > rows)
curFieldX = 0;
else
curFieldX++;
}
else if (!labyrinth[curFieldX, curFieldY].WallBelow && !FieldAlreadyVisited(curFieldX, curFieldY +1 ))
{
if (curFieldY + 1 > colums)
curFieldY = 0;
else
curFieldY++;
}
else if (!labyrinth[curFieldX, curFieldY].WallLeft && !FieldAlreadyVisited(curFieldX - 1, curFieldY))
{
if (curFieldX - 1 < 0)
curFieldX = rows;
else
curFieldX--;
}
else // Sackgasse
{
// Wieder am Startpunkt angelangt oder eingesperrt -> Kein Weg
if (ariadne.Count == 0)
return false;
// Ein Schritt zurück
Point prev = ariadne.Pop();
curFieldX = prev.X;
curFieldY = prev.Y;
continue;
}
// Aktuelles Feld als besucht markieren
labyrinth[curFieldX, curFieldY].visited = true;
// "Faden verlängern"
ariadne.Push(new Point(curFieldX, curFieldY));
}
}
}
}
Da Scavenger eine Woche lang nichts gepostet hat, mach ich wieder was rein
(Falls es noch niemand gelöst hat kann er gerne jederzeit was andres reinstellen!)
Ich hätte gerne das 8-Damen Problem iterativ gelöst
Viel Spaß! ;)
//EDIT: Es muss nur eine Lösung gefunden werden nicht alle und die Ausgabe in eine Datei/auf die Konsole
Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Daniel B. am .
Moderationshinweis von MarsStein
(15.04.2011 - 15:44)
Im Anhang ist eine .net exe. Es soll eine Eingabe gefunden werden, die zu folgender Ausgabe führt: richtig
Wie letztes mal:
1.) Es ist nicht ganz so offensichtlich, wie es den Anschein hat.
2.) Es gibt eine Lösung!!!!
Wie man unschwer erkennen kann, ist es diesesmal sehr wenig Code, also auch weniger Platz um etwas zu verstecken. Wissen um die Eigenheiten der Clr und Msil sollte zur Lösung sehr nützlich sein.
Also: Fröhliches "wtf?!"
(Wenn jemand sich wundert, kann er gerne seinen Kommentar abgeben :D)
Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von Floste am .
Mir fehlt es eindeutig am Wissen.. :)
Keine Ahnung inwiefern der GC eine Rolle spielt.
Ebenfalls frage ich mich ob der QWORD eine Rolle spielt ( den String den man daraus bekommt hilft mir auch nicht weiter :S )
Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Regenwurm am .
Wie viel verwirrung ein par Zeilen Code stiften können. 8)
Lösung:
1337!
Wie ich darauf gekommen bin:
Das ulong Wert 15481342765760561 was damit zu tun hat und wird war klar (durch das Sequenzielle Layout der Klasse und dem Hack mit dem IL Keyword newslot in der ToString-Methode, überdeckt der Wert des Feldes, dessen Bytefolge dann als String ausgewertet wird, scheinbar das im Stack), also hab ich einfach mal die Bitfolge des Wertes in einen String konvertiert
string s = Encoding.Unicode.GetString(BitConverter.GetBytes(15481342765760561ul));
Das ist aber nicht die Lösung. Irgendwann hab ich dann den Speicherbereich des Prozesses ausgelesen und festgestellt das hinter dem 1337 noch ein "!" steht.
So wie ich das verstehe überschriebt der Bytewert des Feldes den Speicherbereich des Strings nicht ganz und das "!" des Strings (wtf?!) bleibt erhalten.
@Floste:
Ich glaub Langsam hab ich hab ich deine "IL-Masche" raus.
P.S. Der GC hat damit nichts zu tun, ich hab mal spaßeshalber das "GC.KeepAlive" raus gepachet: Das Ergebnis bleibt das gleiche. Das "wtf?!.ToString()" bleibt natürlich.
Aber chic, dass du einfach Methoden als fremde Instanzmethoden ausgeben kannst, war mir garnich klar... aber wenigstens peverify meckert rum.
Mit dieser Methode fummelst du dann quasi in fremden Objekte rum. Genauer gesagt im übergebenen String an der Stelle, wo bei dir @ulong steht. Und dort ist genau bei einem String (hinter der Länge) der eigentliche Content. Und so überschreibst du dann die ersten 4 Unicode Zeichen. Aus "wtf?!" wird damit "1337!"
Und dank String-Internalisierung wird auch bei späterem "wtf?!" der selbe, manipulierte String, verwendet.
Soweit meine Theorie, jedenfalls kommt richtig raus ;) Warum ist das GC.KeepAlive nötig? Würde er sonst nicht internalisieren?
beste Grüße und danke für das schöne Rätsel. Ich denk schon über das nächste nach :)
zommi
//Edit: Arggg... ein µ zu langsam ;) Dann is Scavanger dran!
Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von zommi am .
Nein, ich hatte die Lösung schon früher, wollte aber das spanische Pokalfinale nicht verpassen, dann hab ich's schnell noch danach gepostet, gerade noch rechtzeitig. ;)
O.K. nun wieder was algorithmisches:
Einen Programm zum Primzahltest, aber ich hätte gerne nicht das einundelfzigste Sieb des Eratosthenes sondern einen Probabilistischen Algorithmus
Viel Spass.
Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Scavanger am .
public class MillerRabin
{
int w; // Zeugen
int zahl;
string bin;
int t;
public MillerRabin(int zahl, int durchlaeufe)
{
if (zahl % 2 == 0 || durchlaeufe < 1 || zahl < 2)
{
throw new ArgumentException();
}
w = durchlaeufe;
this.zahl = zahl;
}
//Startet den Algorithmus
public bool Start()
{
if (zahl != 0)
{
return miller_rabin(zahl, w);
}
throw new ArgumentException();
}
//Hauptmethode
private bool miller_rabin(int n, int s)
{
int r;
bool prime = true;
Random rand = new Random();
for (w = 1; w < s + 1; w++)
{
r = rand.Next(2, n);
if (witness(r, n))
{
prime = false;
break;
}
}
return prime;
}
// Konvertiert eine Zahl zu einem Binärstring
private void IntToBinary(int B)
{
bin = Convert.ToString(B, 2);
}
private int modular_exponentiation(int a, int u, int n)
{
int c = 0;
int d = 1;
// Sei {b[0],b[1],...,b[k-1],b[k]} die binäre Darstellung von b
if (w == 1) IntToBinary(u);
// Da für alle Zeugen gleich, nur einmal berechnen
for (int i = 0; i < bin.Length; i++)
{
c *= 2;
d = (int)Math.Pow(d, 2) % n;
if (bin[i] == '1')
{
c += 1;
d = (d * a) % n;
}
}
return d;
}
private bool witness(int a, int n)
{
int N_1 = n - 1;
if (w == 1) while ((N_1 / (int)(Math.Pow(2, t)) % 2) == 0) t++;
// Da für alle Zeugen gleich, nur einmal berechnen
int u = N_1 / (int)Math.Pow(2, t);
int x0;
int x1 = modular_exponentiation(a, u, n);
for (int i = 1; i < t + 1; i++)
{
x0 = x1;
x1 = (int)Math.Pow(x0, 2) % n;
if (x1 == 1 && x0 != 1 && x0 != N_1)
return true;
}
return x1 != 1;
}
}
Und hier noch meine Main:
static void Main(string[] args)
{
while (true)
{
Console.Write("Zahl eingeben (ungültige Eingabe für Abbruch!): ");
string input = Console.ReadLine();
int zahl;
if (!int.TryParse(input, out zahl) || zahl < 1 || zahl % 2 == 0)
{
Console.WriteLine("Ungültige Eingabe! Zahl muss größer 0 sein und ungerade sein!");
Console.ReadLine();
return;
}
if (zahl < 4)
{
Console.WriteLine("Zahl ist prim!");
}
else
{
MillerRabin mr = new MillerRabin(zahl, 20);
Console.WriteLine("Zahl ist{0} prim!", mr.Start() ? "" : " nicht");
}
}
}
Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Daniel B. am .
Das ist natürlich die Ideal-Lösung, auch wenn es hier natürlich eine Grenze gibt bei der ein Überlauf satt findet, das soll jetzt aber egal sei.
Mir hätte es im übrigen gereicht wenn die die Grenzen überprüft hättest.
So, hier ist meine Lösung. Ich habe allerdings keine neue Idee, d.h. jeder kann eine neue Aufgabe stellen(sofern mein Code als richtig befunden wird).
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConwaysGameOfLife
{
class Program
{
public bool Abort { get; set; }
private bool[,] map;
private int amount, sleeptime;
private Thread t;
static void Main(string[] args)
{
Program p = new Program();
p.Start();
Console.ReadLine();
p.Abort = true;
}
public void Start()
{
do {
Console.WriteLine("Bitte geben Sie die Zeit in ms zwischen den Generationen an.");
} while (!Int32.TryParse(Console.ReadLine(), out sleeptime)
|| sleeptime < 1);
do {
Console.WriteLine("Bitte geben Sie die Anzahl der Felder ein.");
} while (!Int32.TryParse(Console.ReadLine(), out amount)
|| amount < 1 || amount > 39);
map = new bool[amount, amount];
Console.WriteLine("Wollen Sie die Felder selbst befüllen? (J/N)");
if (Console.ReadLine().Equals("J", StringComparison.OrdinalIgnoreCase))
{
ReadCells();
}
else
{
RandomizeCells();
}
t = new Thread(new ThreadStart(Run));
t.Start();
}
private void Run()
{
while (!Abort)
{
PrintMap();
try
{
Thread.Sleep(sleeptime);
}
catch (Exception) { }
CalculateLife();
}
}
private void ReadCells()
{
Console.WriteLine("Bitte geben Sie die lebenden Zellen im Format 'x,y' an.");
string line;
do
{
line = Console.ReadLine();
string[] elements = line.Split(',');
if (elements.GetLength(0) == 2)
{
int x, y;
if (Int32.TryParse(elements[0], out y)
&& Int32.TryParse(elements[1], out x))
{
if (x ≥ 0 && x < amount
&& y ≥ 0 && y < amount)
{
map[x, y] = true;
}
else
{
Console.WriteLine("Bitte geben Sie eine Zahl im gültigen Bereich ein.");
}
}
else
{
Console.WriteLine("Bitte geben Sie eine Zahl ein.");
}
}
else
{
Console.WriteLine("Bitte geben Sie die lebenden Zellen im Format 'x,y' an.");
}
} while (line != "");
}
private void RandomizeCells()
{
Random random = new Random();
for (int i = 0; i < amount; ++i)
{
for (int j = 0; j < amount; ++j)
{
map[i, j] = random.Next(2) == 0;
}
}
}
private void PrintMap()
{
Console.Clear();
for (int i = 0; i < map.GetLength(0); i++)
{
Console.WriteLine(new string('-', amount * 2 + 1));
for (int j = 0; j < map.GetLength(1); j++)
{
Console.Write('|');
Console.Write(map[i,j] ? (char)2 : ' ');
}
Console.WriteLine('|');
}
Console.Write(new string('-', amount * 2 + 1));
}
private void CalculateLife()
{
bool[,] newGen = new bool[amount, amount];
for (int i = 0; i < amount; ++i)
{
for (int j = 0; j < amount; ++j)
{
int neighbors = GetNeighbors(i, j);
if (neighbors < 2)
{
newGen[i, j] = false;
}
if (neighbors == 3)
{
newGen[i, j] = true;
}
if (neighbors == 2 && map[i, j])
{
newGen[i, j] = true;
}
if (neighbors > 3)
{
newGen[i, j] = false;
}
}
}
map = newGen;
}
private int GetNeighbors(int x, int y)
{
int count = 0;
if (x != 0)
{
if (y != 0)
{
count += map[x - 1, y - 1] ? 1 : 0;
}
if (y != amount - 1)
{
count += map[x - 1, y + 1] ? 1 : 0;
}
count += map[x - 1, y] ? 1 : 0;
}
if (x != amount - 1)
{
if (y != 0)
{
count += map[x + 1, y - 1] ? 1 : 0;
}
if (y != amount - 1)
{
count += map[x + 1, y + 1] ? 1 : 0;
}
count += map[x + 1, y] ? 1 : 0;
}
if (y != 0)
{
count += map[x, y - 1] ? 1 : 0;
}
if (y != amount - 1)
{
count += map[x, y + 1] ? 1 : 0;
}
return count;
}
}
}
edit: 12x12 deswegen, da man ansonsten scrollen muss, was imho recht nervig ist. Ich habe jetzt 39x39 genommen, da das die maximale Anzahl für die Breite ist.
Zufälliges Befüllen habe ich jetzt ebenfalls implementiert.
Die logischen Bedingungen für die Begrenzungen waren ebenfalls falsch.
Dieser Beitrag wurde 4 mal editiert, zum letzten Mal von Sekkiy am .
Mach doch bitte noch eine Standardintialisierung hinzu , bzw. zufälliges Befüllen der Felder. Eventuell noch die Grenzen etwas erhöhen - 12x12 ist mir irgendwie zu klein :P
Moderationshinweis von herbivore
(15.05.2011 - 08:27)
Die Ausgabe muss von vornherein so formuliert sein, dass klar ist, was gewünscht ist. Nachkarten, also nachträglich Forderungen aufzustellen, ist nicht erlaubt. Ob eine Aufgabe korrekt gelöst ist, muss gegen die ursprüngliche Aufgabenstellung geprüft werden.