Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch

Zitat von edsplash:

C#-Code: (number & (number - 1)) == 0

Du musst allerdings noch die 0 ausschließen. (0 ist keine Zweierpotenz)
Siehe  Rausfinden ob eine Zahl 2^x ist.

beste Grüße
zommi

Hallo,

C#-Code:

static void Main(string[] args)         {             int a=10,b=78;             int[] Werte = Euklid(a, b);             Console.WriteLine("{0} = {1} * {2} + {3} * {4}", Werte[0], Werte[1], a, Werte[2], b);             Console.ReadLine();         }         private static int[] Euklid(int a, int b)         {             if(b==0)                 return new int[]{a,1,0};             int[] Strich = Euklid(b, a % b);             int[] Werte = new int[3];             Werte[0] = Strich[0];             Werte[1] = Strich[2];             Werte[2] = Strich[1] - (int)(a / b) * Strich[2]; ;             return Werte;         }

Nächste Aufgabe:

Den erweiterten euklidischen Algorithmus iterativ implementieren.

Grüße FZ

Vielleicht nicht die schönste Implementierung aber das sollte es eigentlich sein:

C#-Code:

static void Main() {     bool parseOk = false;     int a=0, b=0;     while (!parseOk)     {         Console.WriteLine("Integer Wert a: ";);         parseOk = Int32.TryParse(Console.ReadLine(), out a);     }     parseOk = false;     while (!parseOk)     {         Console.WriteLine("Integer Wert b: ";);         parseOk = Int32.TryParse(Console.ReadLine(), out b);     }     int ggT, x, y;     if (a > b)     {         ExtendedEuclidian(a, b, out ggT, out x, out y);         Console.WriteLine(a + " * " + x + " + " + b + " * " + y + " = " + ggT);         Console.WriteLine(a * x + b * y == ggT ? "Stimmt!" : "Stimmt net!";);     }     else     {         ExtendedEuclidian(b, a, out ggT, out x, out y);         Console.WriteLine(b + " * " + x + " + " + a + " * " + y + " = " + ggT);         Console.WriteLine(b * x + a * y == ggT ? "Stimmt!" : "Stimmt net!";);     }     Console.ReadKey(); } private static void ExtendedEuclidian(int a, int b, out int ggT, out int x, out int y) {     if (a%b == 0)     {         x = 0;         y = 1;         ggT = b*y;         return;     }     int dggT, dX, dY, divRem;     ExtendedEuclidian(b, a % b, out dggT, out dX, out dY);     x = dY;     y = dX - dY * Math.DivRem(a, b, out divRem);     ggT = a * x + b * y; }

Hatte noch ein Pseudocodeschnippsel in alten Vorlesungsunterlagen ....

*EDIT*: Formatierung angepasst.

Ok, wer lesen kann ist klar im Vorteil. Nun aber:

C#-Code:

private static void ExtendedEuclidianIterative(int a, int b, out int ggT, out int x, out int y)         {             x = 0;             y = 1;             int dX = 1, dY = 0;             while(b != 0)             {                 int divRem;                 int divQuot = Math.DivRem(a, b, out divRem);                 int temp = b;                 b = divRem;                 a = temp;                 temp = x;                 x = dX - divQuot * x;                 dX = temp;                 temp = y;                 y = dY - divQuot*y;                 dY = temp;             }             ggT = a;             x = dX;             y = dY;         }

PS: Stammt natürlich nicht von mir sondern aus der Wiki. Nur was soll man bei solchen Algorithmen denn machen ....

Ok, dann mal weg von den reinen Algorithmen.

Ich hätte gern die Implementierung des  Marienbad Spieles mit einem Computergegner. Als Darstellung reicht die Anzahl der Hölzer als Zahl der jeweiligen Reihe. Die Ausgangsposition sieht also so aus:

1
3
5
7

Der Computergegner soll, wenn es möglich ist, die optimale Strategie fahren. Optional kann auch noch berechnet werden ob für die jeweilige Spielsituation des Computergegners eine Gewinnstrategie existiert. Einen Hinweis dazu, wie das gehen kann findet ihr hier:

 http://www-i1.informatik.rwth-aachen.de/...hmus/algo14.php

Die Aufgabe ist ein wenig umfangreicher als ein reiner Algorithmus aber die meiste Arbeit bezieht sich eigentlich auf die Eingabe. Falls eine solche Aufgabe den Rahmen des Threads sprengt - ich hätte auch noch eine etwas kleinere.

[offtopic]@JAck30lena: Hmm, ich finde in diesem Thread mindestens 3 Lösungen die dieser Vorgabe nicht entsprechen und so aufwendig ist die Implementierung auch nicht.[/offtopic]

Aber gut, dann die etwas weniger spassige Aufgabe:
Das Programm muss einen Kreis "zeichnen" können durch Eingabe des Radius. Als Zeichenfeld soll ein einfaches 2 Dimensionales boolsches Array verwendet werden bei dem der Hintergrund false und der Kreis selbst true ist. Der Mittelpunkt des Kreises ist immer der Mittelpunkt des Arrays.
Die Implementierung darf nicht den naiven Ansatz verwenden, dh. einfach nur die Berechnung der Koordinaten durch:

x = R*cos(alpha) und y = R*sin(alpha)

ist nicht ausreichend. Ich schätze, daß die Implementierung in 50 Zeilen mit Eingabe möglich ist da der eigentliche Algorithmus ca. 20 Zeilen umfasst.

Hallo,

dein Code ergibt für größere R kein geschlossenen Kreis...

Grü0e FZ

Hallo,

Zitat:

Es gibt einen Weg ohne Quadrat und Wurzel ....

...und nennt sich Bresenham-Algorithmus.
Ich hab ihn mal für den Spezialfall angepasst.

C#-Code:

class Program   {     static void BuildOctant(int r, bool[,] res)     {       int f = 1 - r;       int fx = 0;       int fy = -2*r;       int x = 0;       int y = r;       res[x+r, y+r] = true;       while (x < y)       {         if (f >= 0)         {           y--;           fy += 2;           f += fy;         }         x++;         fx += 2;         f += fx + 1;         res[x+r, y+r] = true;       }     }     public static void Main(string[] args)     {       int r = 0;       Console.Write("Radius: ");       while(!(int.TryParse(Console.ReadLine(), out r) && (r > 0))){         Console.WriteLine("Der Radius muss eine Ganzzahl größer 0 sein!");         Console.Write("Radius: ");       }       bool[,] res = new bool[2*r+1, 2*r+1];       // Grundoktant       BuildOctant(r, res);       //Spiegelung:       for(int y = 2*r; y >= 3*r/4; y--)       {         for(int x = r; x <= 2*r; x++)         {           res[y, x] = res[x, y];           res[2*r-x, y] = res[x, y];           res[x, 2*r-y] = res[x, y];           res[2*r-x, 2*r-y] = res[x, y];         }       }       // Ausgabe:       for(int y = 0; y <= 2*r; y++)       {         for(int x = 0; x <= 2*r; x++)         {           Console.Write(res[x, y] ? "0" : "x");         }         Console.WriteLine();       }       Console.ReadKey();     }   }

Ausgabe mit r=1:

Code: 1: 2: 3: x0x 0x0 x0x

Ausgabe mit r=15:

Code: 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: xxxxxxxxxxxx0000000xxxxxxxxxxxx xxxxxxxxx000xxxxxxx000xxxxxxxxx xxxxxxx00xxxxxxxxxxxxx00xxxxxxx xxxxxx0xxxxxxxxxxxxxxxxx0xxxxxx xxxxx0xxxxxxxxxxxxxxxxxxx0xxxxx xxxx0xxxxxxxxxxxxxxxxxxxxx0xxxx xxx0xxxxxxxxxxxxxxxxxxxxxxx0xxx xx0xxxxxxxxxxxxxxxxxxxxxxxxx0xx xx0xxxxxxxxxxxxxxxxxxxxxxxxx0xx x0xxxxxxxxxxxxxxxxxxxxxxxxxxx0x x0xxxxxxxxxxxxxxxxxxxxxxxxxxx0x x0xxxxxxxxxxxxxxxxxxxxxxxxxxx0x 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 0xxxxxxxxxxxxxxxxxxxxxxxxxxxxx0 x0xxxxxxxxxxxxxxxxxxxxxxxxxxx0x x0xxxxxxxxxxxxxxxxxxxxxxxxxxx0x x0xxxxxxxxxxxxxxxxxxxxxxxxxxx0x xx0xxxxxxxxxxxxxxxxxxxxxxxxx0xx xx0xxxxxxxxxxxxxxxxxxxxxxxxx0xx xxx0xxxxxxxxxxxxxxxxxxxxxxx0xxx xxxx0xxxxxxxxxxxxxxxxxxxxx0xxxx xxxxx0xxxxxxxxxxxxxxxxxxx0xxxxx xxxxxx0xxxxxxxxxxxxxxxxx0xxxxxx xxxxxxx00xxxxxxxxxxxxx00xxxxxxx xxxxxxxxx000xxxxxxx000xxxxxxxxx xxxxxxxxxxxx0000000xxxxxxxxxxxx

Hab leiuder heut keine Zeit mehr für was neues... das muss bis morgen warten.

Gruß, MarsStein

Hi,

Ich hab genau 4minuten und 28sekunden programmiert würde mich mal interessieren ob diese tolle Funktion hier das bringt was du wolltest(Achtung: 0 ist bei mir keine Farbe d.h. falls 0 als Farbe benutzt wird, müsste man etwas ergänzen wie: wenn ein Array 0 enthält dann alles Inkrementieren):

C#-Code:

bool MastermindTest(int[] geheimnis, int[] versuch, out int schwarz, out int weiss)         {             schwarz = 0;             weiss = 0;             for (int i = 0; i < 4; i++)             {                 if (geheimnis[i] == versuch[i])                 {                     geheimnis[i] = 0;                     schwarz++;                 }                 else if (geheimnis.Contains(versuch[i]))                 {                     for (int i2 = 0; i2 < 4; i2++)                     {                         if (geheimnis[i2] == versuch[i])                         {                             geheimnis[i2] = 0;                             break;                         }                     }                     weiss++;                 }             }             if (schwarz == 4) return true;             return false;         }

Ok ich geb zu das is weder kurz noch elegant, aber dafür schnell;)

Mfg Campac

Hallo,

hier meine Lösung. Ist ein Stück länger, dafür zum Verständnis kommentiert.

C#-Code:

private static bool MastermindTest(int[] geheimnis, int[] versuch, out int schwarz, out int weiss) {     schwarz = 0;     weiss = 0;     // Arrays zum Angeben bereits ausgewerteter Stellen     bool[] geheimnisIndizes = new bool[4];     bool[] versuchIndizes = new bool[4];     // Anzahl zu setzender schwarzer Stecker ermitteln     for (int i = 0; i < 4; i++)     {         if (geheimnis[i] == versuch[i])         {             schwarz++;             geheimnisIndizes[i] = true;             versuchIndizes[i] = true;         }     }     // Über Geheimnis-Array iterieren     for (int i = 0; i < 4; i++)     {         // Geheimnis-Ziffer wurde bereits ausgewertet         if (geheimnisIndizes[i])         {             continue;         }         // Über Versuch-Array iterieren         for (int j = 0; j < 4; j++)         {             // Versuch-Ziffer wurde bereits ausgewertet             if (versuchIndizes[j])             {                 continue;             }             // "Halb-Treffer" (weiss) gefunden             if (geheimnis[i] == versuch[j])             {                 weiss++;                 geheimnisIndizes[i] = true;                 versuchIndizes[j] = true;             }         }     }     return (schwarz == 4); }

Edit: kleine Änderungen nach Anregungen von herbivore eingearbeitet.

m0rius

tja ich sags mal so: versuch wars wert ich hatte nich viel zeit und war todmüde;)
beim nächsten mal!

Funkt bei mir:

C#-Code:

public static void Main()         {             int[] zahlen = new int[6]             {                 0,//0                 0,//1                 4,//Uboot(2)                 3,//Kreutzer(3)                 2,//Zerstörer(4)                 1,//Schlachtschiff(5)             };             int[,] feldx = new int[10, 10];             int[,] feldy = new int[10, 10];             for(int x=0;x<10;x++)                 for (int y = 0; y < 10; y++)                 {                     feldx[x, y] = 10 - x;                     feldy[x, y] = 10 - y;                 }             Random rnd = new Random();             for (int i = zahlen.Length - 1; i >= 0; i--)             {                 for (int i2 = zahlen[i] - 1; i2 >= 0; i2--)                 {                     int xcount = feldx.Cast<int>().Count((f) => f >= i);                     int ycount = feldy.Cast<int>().Count((f) => f >= i);                     int c = rnd.Next(xcount + ycount);                     if (c < xcount)                     {                         for(int x=0;x<10;x++)                             for (int y = 0; y < 10; y++)                             {                                 if (feldx[x, y]>=i)                                 {                                     if (c > 0)                                     {                                         c--;                                     }                                     else                                     {                                         for (int ilen = 0; ilen < i; ilen++)                                         {                                             Set(x,y,feldx,feldy);                                             x++;                                         }                                         goto breakout;                                     }                                 }                             }                     breakout:{}                     }                     else                     {                         c -= xcount;                         for (int x = 0; x < 10; x++)                             for (int y = 0; y < 10; y++)                             {                                 if (feldy[x, y] >= i)                                 {                                     if (c > 0)                                     {                                         c--;                                     }                                     else                                     {                                         for (int ilen = 0; ilen < i; ilen++)                                         {                                             Set(x, y, feldx, feldy);                                             y++;                                         }                                         goto breakout;                                     }                                 }                             }                     breakout: { }                     }                 }             }             for (int y = 0; y < 10; y++)             {                 for (int x = 0; x < 10; x++)                 {                     if (feldx[x, y] == -1 && feldy[x, y] == -1)                         Console.Write("X");                     else                         Console.Write(".");                 }                 Console.WriteLine();             }             Console.ReadLine();         }         private static void Set(int x, int y, int[,] feldx, int[,] feldy)         {             Setx(x, y, feldx);             Setx(x, y + 1, feldx);             Setx(x, y - 1, feldx);             Sety(x, y, feldy);             Sety(x + 1, y, feldy);             Sety(x - 1, y, feldy);         }         private static void Setx(int x, int y, int[,] feldx)         {             if (y < 0 || y >= 10) return;             if (x < 9)             {                 feldx[x + 1, y] = 0;             }             int dist = -1;             for (int x2 = x; x2 >= 0; x2--)             {                 if (feldx[x2, y] < dist) break;                 feldx[x2, y] = dist;                 dist++;             }         }         private static void Sety(int x, int y, int[,] feldy)         {             if (x < 0 || x >= 10) return;             if (y < 9)             {                 feldy[x, y+1] = 0;             }             int dist = -1;             for (int y2 = y; y2 >= 0; y2--)             {                 if (feldy[x, y2] < dist) break;                 feldy[x, y2] = dist;                 dist++;             }         }

Da es programmier-SPIEL heißt, dachte ich, es kann auch mal ein spiel rauskommen.

Das wird, wenn es auch keine besonders anspruchsvolle Aufgabe ist, doch eine recht Lange.
Spielidee: Man schießt aus der Mitte mit Geschossen herumfligende Brocken ab, damit diese einem nicht zu nahe kommen.

Um die Sache einfach zu halten ist alles rechteckig:
-Das Spielfeld ist 500x500 Pixel groß
-Genau in der Mitte ist ein zu verteidigendes Quadrat, das 20x20 Pixel groß ist
-Aus der Mitte herkommend kann man zum Mauszeiger hin 10x10 große Quadrate (am besten rot) schießen, die sich mit 200px/sekunde Fortbewegen
-Von oben herab regnet es Rechtecke, die 10 bis 50px Seitenlänge haben , sich mit 50 bis 100px/Sekunde nach unten bewegen und mit -50 bis +50px/Sekunde seitwärts bewegen. Sie behalten genau wie die Geschosse ihre Richtung und Größe bei. Die Blöcke sollen sich von Geschossen und dem Hintergrund abheben. Alle Werte sollen innherhalb der Vorgaben möglichst zufällig sein.
-Wenn ein Geschoss einen Block trifft, verschwinden Beide, es wird aber ein neuer Block erzeugt, sodass die Blockanzahl konstant ist.
-Wenn ein Block das Spielfeld verlässt, wird er zerstört und ein neuer erzeugt.
-Wenn ein Geschoss das Spielfeld verlässt wird es ersatzlos zerstört.
-Alle 5 Sekunden kommt ein Block hinzu, am Anfang gibt es genau 5 Stück.
-Wenn ein Block die mitte erreicht hat man verloren und die zeit wird angezeigt.
-Man kan alle 250ms schießen.
-Blöcke haben mit anderen blöcken keine kollision, selbiges gild für geschosse. (ok, eine Variante mit Blockkollision wäre auch mal lustig.)

-Für Grafik sollte Gdi reichen (bitte flackerfrei), anderes ist erlaubt

-Markus111 ist, weil er die Lösung kennt ausgeschlossen.
-Alle, die sich das Programm von markus111 geholt haben sind ebenfalls ausgeschlossen.

Damit es nich so lange dauert, ist heir ein Stub, man muss ihn aber nicht unbedingt benutzen und kann ihn abwandeln.
Tipp1: eine for-Schleife rückwärts ist hilfreich!
Tipp2: rectangle.IntersectsWith testet Kollision!

C#-Code:

public class Asteriods : Form     {         public Asteriods()         {             this.Size = new Size(500, 500);             this.FormBorderStyle = FormBorderStyle.FixedDialog;             SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint,true);             DoubleBuffered = true;             sw = new Stopwatch();             sw.Start();             //TODO:Ergänzen         }         Stopwatch sw;         float nowMilliseconds=0;         float lastShot = 0;         Random rnd = new Random();         List<Particle> asteroids=new List<Particle>();         List<Particle> missils=new List<Particle>();         RectangleF center;         protected override void OnPaint(PaintEventArgs e)         {             float timeOffset = sw.ElapsedMilliseconds - nowMilliseconds;             UpdateParticles(missils, timeOffset);//bewegen und aussortieren, was aus dem Rahmen fällt             UpdateParticles(asteroids, timeOffset);             //TODO:Ergänzen             using (SolidBrush sb = new SolidBrush(Color.Green))                 e.Graphics.FillRectangle(sb,center);             foreach (Particle p in asteroids.Concat(missils))             {                 using (SolidBrush sb = new SolidBrush(p.c))                     e.Graphics.FillRectangle(sb, p.rect);             }             nowMilliseconds += timeOffset;             Invalidate();         }         protected override void OnMouseDown(MouseEventArgs e)         {             //TODO:Ergänzen         }         class Particle         {             public RectangleF rect;             public float speedx;             public float speedy;             public Color c;         }     }

ps: inklusive gegebenen Code und using-krimskrams hab ich 122 Zeilen gebraucht
wenn man tipp1 beachtet gibts in meinen Augen auch keinerlei "fallen" mehr.

Hallo Floste,

um das Programmierspiel mal wieder "aufzuwecken": Vielleicht solltest du eine neue Aufgabe mit kleinerem Umfang stellen, da an der jetzigen anscheinend kein großes Interesse besteht ...

m0rius

Hallo,

es geht sicherlich schöner / kürzer / besser, aber ich denke es erfüllt alle geforderten Vorgaben.
Ich hab' die Main() mal mir reingepackt, so dass sich der folgende Codeblock direkt zur .exe kompilieren lässt :)

C#-Code:

using System; using System.Collections.Generic; using System.Diagnostics; using System.Drawing; using System.Windows.Forms; public class Asteriods : Form {     static void Main()     {       Application.Run(new Asteriods());     }     Stopwatch sw;     int lastPaint = 0;     int lastShot = 0;     int lastBlock = 0;     List<Particle> asteroids=new List<Particle>();     List<Particle> missils=new List<Particle>();     RectangleF center = new RectangleF(240f,240f,20f,20f);     bool end = false;     public Asteriods()     {       this.Size = new Size(500, 500);       this.FormBorderStyle = FormBorderStyle.FixedDialog;       this.BackColor = Color.Black;       SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint,true);       DoubleBuffered = true;       for(int i = 0; i < 5; i++)       {         asteroids.Add(new Particle());       }       sw = new Stopwatch();       sw.Start();     }     protected override void OnPaint(PaintEventArgs e)     {       int snapshot = (int)sw.ElapsedMilliseconds;       int timeOffset = snapshot - lastPaint;       lastPaint = snapshot;       Particle p1;       Particle p2;       bool updateMissiles = true;       for(int i = asteroids.Count-1; i>=0; i--)       {         p1 = asteroids[i];         p1.rect = new RectangleF(p1.rect.Left + p1.speedx*timeOffset,                                  p1.rect.Top + p1.speedy*timeOffset,                                  p1.rect.Width, p1.rect.Height);         if(p1.rect.IntersectsWith(this.ClientRectangle))         {           if(p1.rect.IntersectsWith(center))           {             end = true;           }           for(int j = missils.Count-1; j>=0; j--)           {             p2 = missils[j];             if(updateMissiles)             {               p2.rect = new RectangleF(p2.rect.Left + p2.speedx*timeOffset,                                        p2.rect.Top + p2.speedy*timeOffset,                                        p2.rect.Width, p2.rect.Height);               updateMissiles = (j!=0);             }             if(p2.rect.IntersectsWith(this.ClientRectangle))             {               if(p1.rect.IntersectsWith(p2.rect))               {                 asteroids[i] = new Particle();                 missils.RemoveAt(j);               }             }             else             {               missils.RemoveAt(j);             }           }         }         else         {           asteroids[i] = new Particle();         }         e.Graphics.FillRectangle(Brushes.Green, asteroids[i].rect);       }       if((lastBlock+5000) <= snapshot)       {         lastBlock = snapshot-(snapshot%5000);         asteroids.Add(new Particle());       }       foreach(Particle p in missils)       {         e.Graphics.FillRectangle(Brushes.Red, p.rect);       }       e.Graphics.FillRectangle(Brushes.Blue, center);       if(end)       {         e.Graphics.DrawString((snapshot/1000f).ToString("0.000")+"s",                               new Font("system",25), Brushes.White,                               Point.Empty);       }       else       {         Invalidate();       }     }     protected override void OnMouseDown(MouseEventArgs e)     {       int snapshot = (int)sw.ElapsedMilliseconds;       if((lastShot+250) <= snapshot)       {         lastShot = snapshot;         missils.Add(new Particle(e.X-250, e.Y-250));       }     }     class Particle     {       static Random rand = new Random();       public RectangleF rect;       public float speedx;       public float speedy;       public Particle()       {         float height = rand.Next(10,50);         int width = rand.Next(10,50);         rect = new RectangleF(rand.Next(0,500-width),1-height,rand.Next(10,50),height);         speedx = rand.Next(-50,50)/1000f;         speedy = rand.Next(50,100)/1000f;       }       public Particle(int mouseX, int mouseY)       {         rect = new RectangleF(245f,245f,10f,10f);         float dia = (float)Math.Sqrt(mouseX*mouseX+mouseY*mouseY);         speedx = mouseX/dia/5;         speedy = mouseY/dia/5;       }     } }

Gruß, MarsStein

Hallo,

die nächste Aufgabe:

erstell eine Queue-Klasse, die folgendes Interface implementiert.

Haken: Die Namespaces System.Collections und System.Collections.Generic sind ausgeschlossen und dürfen nicht verwendet werden.

C#-Code:

interface IQueue<T> {   // gibt die Anzahl der Elemente an.   int Count   {     get;   }   // entfernt das Element am Anfang der Queue und gibt es zurück   T Dequeue();   // fügt das Element "elem" am Ende der Queue an   void Enqueue(T elem);   // Gibt true zurück, wenn das Element elem in der Queue enthalten ist, sonst false   bool Contains(T elem); }

Gruß, MarsStein

Edit: Habe mich vielleicht anfangs etwas unverständlich ausgedrückt.
Nach Jack30lenas nächster Antwort habe ich die Kommentare eingefügt, um kenntlich zu machen wie die Klasse arbeiten soll.

C#-Code:

class MyQueue<T> : IQueue<T>         {             private T[] internalArray = new T[10];             private int queueIndex = -1;             public int Count             {                 get { return queueIndex + 1; }             }             public T Dequeue()             {                 T result = internalArray[queueIndex];                 internalArray[queueIndex] = default(T);                 queueIndex--;                 return result;             }             public void Enqueue(T elem)             {                 if(internalArray.Length == queueIndex + 1)                 {                     T[] newArray = new T[internalArray.Length * 2];                     Array.Copy(internalArray, newArray, internalArray.Length);                     internalArray = newArray;                 }                 internalArray[++queueIndex] = elem;             }             public bool Contains(T elem)             {                 return internalArray.Any(item => item.Equals(elem));             }         }

edit: der code hat keinerlei ansprüche auf robustheit ;-)

Zitat:

wenn ich es richtig blicke, hast Du einen Stack gebaut. Unter einer Queue verstehe ich eigentlich einen FIFO.

oha... mist :-) da hab ich nciht ordendlich nachgedacht.

[edit=herbivore]Eigentlich wurde dieser Beitrag erst am 17.03.2010 um 09:38:04 gepostet, aber ich habe ihn aus Gründen der Übersichtlichkeit und des direkten Zusammenhangs an diese Stelle verschoben.[/edit]

Tja du warst schneller, meiner sähe so aus:

C#-Code:

class MyQueue<T> : IQueue<T>     {         private int _count;         private QueueElement<T> front;         public MyQueue()         {             _count = 0;         }         public int Count         {             get { return _count; }         }         public void Enqueue(T elem)         {             if (Count > 0)             {                 front.enter(elem);                 _count++;             }             else             {                 front = new QueueElement<T>(elem);                 _count++;             }         }         public T Dequeue()         {             if (Count > 0)             {                 T frontContent = front.Content;                 front = front.leave();                 _count--;                 return frontContent;             }             else             {                 return default(T);             }         }         public bool Contains(T elem)         {             if (Count > 0)             {                 return front.Contains(elem);             }             else             {                 return false;             }         }         private class QueueElement<T>         {             QueueElement<T> next;             public T Content             {                 get;                 private set;             }             public QueueElement(T Content)             {                 this.Content = Content;             }             public void enter(T elem)             {                 if (next != null)                 {                     next.enter(elem);                 }                 else                 {                     next = new QueueElement<T>(elem);                 }             }             /// <summary>             /// Gibt die nächste front zurück             /// </summary>             /// <returns></returns>             public QueueElement<T> leave()             {                 return next;             }             public bool Contains(T elem)             {                 if (next != null)                 {                     return Content.Equals(elem) || next.Contains(elem);                 }                 else                 {                     return Content.Equals(elem);                 }             }         }     }

Wurde nich lange getestet aber ich denke vom Prinzip her sollte es so ähnlich sein wie das von Corpsegrinder^^