Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Daniel B.
Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Alles klar, ich finde nichts mehr, du bist dran!

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Bei folgendem Fall dreht sich das Bild nicht in die richtige Richtung

(der rote Punkt ist der "new Looking at"-Punkt)

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Im Anhang sieht man wie ich das gemeint hab (hoffentlich) :)

Vektor 1 ergibt sich aus der ImageDirection. Ich hab einfach angenommen das der Vektor dann dadurch berechnet wird das p1 je nach Direction um 1 erhöht wird und somit der Vektor zustande kommt.

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Damit jeder noch weiß, was es mit dem "sehen" auf sich hat:

siehe Anhang

Das Flugzeug "sieht" nach oben, dass bedeutet, ich würde GetAngle mit ImageDirection.Top aufrufen!

Man darf sich darauf verlassen, dass die Vektoren richtig übergeben werden. Trotzdem sollen Exceptions geworfen werden wenn z. B. Angle außerhalb von 0-360 ° liegt oder das übergebene Bild null ist.

Ich hoffe die Aufgabenstellung ist klar genug formuliert. Ansonsten wird Herbivore sich schon melden :D

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Da mir gerade etwas eingefallen ist, warum denn nicht, wenn sonst niemand will?

Schreibe folgende Methoden:



        /// <summary>
        /// This is used to indicate in which direction the image is "looking"
        /// </summary>
        public enum ImageDirection
        {
            Top,
            Right,
            Bottom,
            Left
        }

        /// <summary>
        /// Calculates the angle between 2 Vectors
        /// </summary>
        /// <param name="p1">Vector 1</param>
        /// <param name="p2">Vector 2</param>
        /// <returns>Angle between the vectors</returns>
        public static float GetAngle(Point vectorA, Point vectorB);

        /// <summary>
        /// Calculates the angle
        /// </summary>
        /// <param name="p1">Point, where the image should be placed</param>
        /// <param name="p2">Point, where the image should "look" to</param>
        /// <param name="direction">The direction, where the image is "looking" actually</param>
        /// <returns>The Angle, that would be needed to rotate the image to "look" at p2</returns>
        public static float GetAngle(Point p1, Point p2, ImageDirection direction);

        public static Bitmap RotateImage (Bitmap image, float angle);


Aufgabe:
Die Methode "GetAngle" soll den Winkel in ° (deg) zurückgeben, der von beiden Vektoren eingeschlossen ist:

siehe Anhang

Bei der Überladung mit ImageDirection muss man zuerst die Vektoren berechnen

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Ich hoffe es ist nicht zuviel Code :/


        static long rnd = DateTime.Now.Ticks;

        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i + ": " + get_random);
            }
            Console.ReadLine();
        }

        static long get_random
        {
            get
            {
                rnd = (rnd * 110671L + 1263L) & 167215L;
                return rnd;
            }
        }

lg Daniel

Thema: Umfangreichere Projektideen gesucht
Am im Forum: Smalltalk

Hallo,

zuerst möchte ich darauf hinweisen, dass ich bereits diesen Thread gelesen habe:
[FAQ] C# Projektvorschläge (Anfänger, Schüler, Praktikanten)

Ich suche nach Projektideen für mehrere Leute (3-5), dass auch etwas länger dauern kann. (ohne Dokumentationszeit)

Für weitere Anregungen: Wir haben an unserer Schule mehrere Sensoren(Temperatur, GPS, Entfernung, etc.) zur verfügung und auch Roboter:
Nao : Roboterfußball, eine Drohne: Drohne,
natürlich noch einige weitere, unter anderem auch selbst zusammengebaute).

Wir haben ebenfalls RFID-Chips und die zugehörigen Lesegeräte.

Es sollte nicht der 10000ste Mediaplayer werden oder Dateiverwaltung, sondern etwas im Alltag nützliches oder evtl. auch ein lustiges Spiel sein (DirectX ist natürlich auch möglich).

Hoffe ihr könnt mir ein paar Ideen, Anregungen, etc. geben.

lg Daniel

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Funktioniert :)

Viel Spaß mit der nächsten Aufgabe :)

Zitat
P.S.: Ich war mal so frei und habe die Länge der Trennstriche zwischen den Zeilen auf die tatsächliche Zeilenlänge hochgesetzt, siehe
Nachdem ich in dem Programm wo ich das raushab nur 1 Zeichen pro Spalte hatte, habe ich es so lassen können, aber deine Variante ist natürlich die Verallgemeinerung ;)

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Mir ist gerade etwas eingefallen und dachte ich Poste das einfach mal.

Ein Algorithmus der ein 2-Dimensionales Array ausgibt. Der Haken ist, dass das ganze 'schön' aussehen soll. Dass heißt man soll sehen wie die Ausgabe erfolgt:


public void Print2Console()
        {
            for (int i = 0; i < field.GetLength(0); i++)
            {
                for (int j = 0; j < field.GetLength(1)*2+1; j++)
                {
                    Console.Write("-");
                }
                Console.WriteLine();
                Console.Write("|");
                for (int j = 0; j < field.GetLength(1); j++)
                {
                    Console.Write(field[i, j].ToString() + "|");
                    System.Threading.Thread.Sleep(10); //Somit 'sieht' man den Aufbau
                }
                Console.WriteLine();
            }
        }

Dadurch dass man manchmal aber nicht einfach nur Zeile für Zeile, Spalte für Spalte ausgeben möchte, sollt ihr eine Methode implementieren die ca. so aussieht:


public static void PrintField(object[,] field, (enum/flag) PrintOption, int sleepTime)

Es kann nur eine PrintOption ausgewählt werden - also niemals zwei zur gleichen Zeit.

Als PrintOption sollen verfügbar sein:

Normal (Array wird Zeile für Zeile, Spalte für Spalte ausgegeben)
BottomUp (Array wird von letzter Zeile bis zur ersten ausgegeben, Spalten wieder wie bei Normal)
BottomUpSecond (Array wird von letzter Zeile bis zur ersten ausgegeben, Spalten werden jedoch einmal von 0 - x und dann von x - 0 usw. ausgegeben)

Bin gespannt ob es jemand lösen möchte, bis dahin: Viel Spaß!

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Naja da ich mich noch nie mit dieser Sound Api beschäftigt habe bin ich einfach nach den Variablennamen in den Methoden gegangen - was definitiv falsch war^^. Ich habe mir zwar die Doku zu der API angesehen aber zu wenig Zeit und da auf meinem Rechner ununterbrochen einen Ton abgespielt wurde dachte ich ich poste es einfach mal :)

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Hier mein 2ter Versuch:


static void Main(string[] args)
        {
            int bufferCount = 5;
            Random rand = new Random();
            IntPtr device = OpenAL.ALC.OpenDevice(null);
            IntPtr context = OpenAL.ALC.CreateContext(device, null);
            OpenAL.ALC.MakeContextCurrent(context);
            uint source;
            OpenAL.AL.GenSources(1, out source);
            uint[] buffers = new uint[bufferCount];
            OpenAL.AL.GenBuffers(bufferCount, buffers);
            OpenAL.AL.SourceUnqueueBuffers(source, bufferCount, buffers);
            for (int i = 0; i < bufferCount; i++)
            {
                short[] wave = GenerateSound(rand.Next(3000, 8001), rand.Next(500, 2001));
                OpenAL.AL.BufferData(buffers[i], AlAudioFormat.Mono16Bit, wave, wave.Length, 1000);
            }
            OpenAL.AL.SourceQueueBuffers(source, bufferCount, buffers);
            OpenAL.AL.SourcePlay(source);
            int act = 0;
            while (true)
            {
                int proc = OpenAL.AL.GetSourcei(source, OpenAL.AlSourceInts.Buffers_Processed);
                if (proc > 0)
                {
                    OpenAL.AL.SourceUnqueueBuffers(source, 0);
                    short[] wave = GenerateSound(rand.Next(3000, 8001), rand.Next(500, 2001));
                    OpenAL.AL.BufferData(buffers[act], AlAudioFormat.Mono16Bit, wave, wave.Length, 1000);
                    act++;
                    if (act == bufferCount) { act = 0; }
                    OpenAL.AL.SourceQueueBuffer(source, buffers[act]);
                }
            }
        }

        static short[] GenerateSound(int sampleRate, int frequenz)
        {
            short[] waves = new short[sampleRate];
            short amplitude = short.MaxValue / 2;
            for (int n = 0; n < waves.Length; n++)
            {
                waves[n] = (short)(amplitude * Math.Sin((2 * Math.PI * n * frequenz) / sampleRate));
            }
            return waves;
        }

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Berechnung von: http://en.wikipedia.org/wiki/Sine_wave



        static void Main(string[] args)
        {
            IntPtr device = OpenAL.ALC.OpenDevice(null);
            IntPtr context = OpenAL.ALC.CreateContext(device, null);
            OpenAL.ALC.MakeContextCurrent(context);
            uint sources;
            OpenAL.AL.GenSources(1, out sources);
            short[] wave = GenerateWave(8000, 1000);
            uint buffer = OpenAL.AL.GenBuffer();
            OpenAL.AL.SourceUnqueueBuffers(sources, 1);
            OpenAL.AL.BufferData(buffer, AlAudioFormat.Mono16Bit, wave, wave.Length, 1000);
            OpenAL.AL.SourceQueueBuffers(sources, 1, ref buffer);
            while (true)
            {
                OpenAL.AL.SourcePlay(sources);
                System.Threading.Thread.Sleep(1500);
            }
        }

        static short[] GenerateWave(int sampleRate, int frequenz)
        {
            short[] waves = new short[sampleRate];
            short amplitude = short.MaxValue / 8;
            for (int n = 0; n < waves.Length; n++)
            {
                waves[n] = (short)(amplitude * Math.Sin((2 * Math.PI * n * frequenz) / sampleRate));
            }
            return waves;
        }

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Ich möchte eine Klasse die einen Generischen Binärbaum zur verfügung stellt. Die Objekte die in den Baum eingefügt werden müssen ICompareable sein.

Der Baum soll folgende
-Methoden: Insert, Remove, Clear, Contains
-Properties: Count
-Indexer: item setzen und zurückgeben

Insert: Fügt Element T in den Baum ein
Remove: Löscht übergebenes Element
Clear: Löscht den gesamten Baum
Contains: Falls das übergebene Object im Baum ist wird 'true' zurückgegeben ansonsten 'false'
Count: Liefert die Anzahl der Elemente im Baum (beim Insert mitzählen - nicht jedesmal neu Zählen)


public class BinaryTree<T> where T: IComparable<T>
{
      public bool Remove(T data) {}
      public void Insert(T data) {}
      public bool Contains(T data) {}
      public void Clear() {}
      public int Count { get { return this.count; }}
      public T this[int index] { get; set; }
}

Vielleicht noch hilfreich: Binärbaum

Der Baum MUSS immer ausgeglichen sein. D.h. jeder Knoten hat maximal zwei Blätter und beim Einfügen in den Baum muss man darauf achten wie man absteigt (rechts oder links).
Beim Zugriff mit Index wird der Baum nach Preorder durschucht (hier gut zu erkennen)



//EDIT:

Da mir keine "lustigen" Sachen einfallen - kann man ersatzweise auch vorheriges Beispiel iterativ lösen :)

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Hallo myUnderTakeR

Hier sind meine Ergebnisse:
a) n=27; min=6; max=7 ---> 112
b) n=23; min=11; max=14 --> 5552
c) n=16; min=5; max=8 -----> 17088


class Program
    {
        static List<int> permutation = new List<int>();
        static List<List<int>> solutions = new List<List<int>>();
        static void Main(string[] args)
        {
            Console.WriteLine("Count Permutations!\n\n");
            Console.Write("Höchstmögliche Zahl [1 .. n]: ");
            int n, min, max;
            while (!int.TryParse(Console.ReadLine(), out n))
            {
                Console.Write("Ungültige Eingabe! Erneuter Versuch: ");
            }
            Console.Write("Minimaler Abstand: ");
            while (!int.TryParse(Console.ReadLine(), out min))
            {
                Console.Write("Ungültige Eingabe! Erneuter Versuch: ");
            }
            Console.Write("Maximaler Abstand: ");
            while (!int.TryParse(Console.ReadLine(), out max))
            {
                Console.Write("Ungültige Eingabe! Erneuter Versuch: ");
            }
            int ret = CountPermutations(n, min, max, 1, true);
            Console.Write("{0} Lösungen gefunden! Sollen die Lösungen ausgegeben werden? [N/y]: ", ret);
            if (Console.ReadLine().ToLower() == "y")
            {
                Console.WriteLine();
                foreach (List<int> perm in solutions)
                {
                    Console.Write("[");
                    foreach (int item in perm)
                    {
                        Console.Write(item.ToString() + " ");
                    }
                    Console.Write("]\n");
                }
                Console.ReadLine();
            }
        }

        /// <summary>
        /// Berechnet die Anzahl der Permutation von [1,...,n], bei denen der
        /// Absolutbetrag der Differenz zweier aufeinanderfolgender Zahlen zwischen
        /// min und max liegt. (min ≤ max ≤ n)
        /// </summary>
        /// <param name="n">Anzahl und Werte der Elemente (n Elemente mit den Werten 1-n)</param>
        /// <param name="min">Minimaler Abstand zwischen zwei aufeinanderfolgenden Elementen (inklusive)</param>
        /// <param name="max">Maximaler Abstand zwischen zwei aufeinanderfolgenden Elementen (inklusive)</param>
        /// <returns>Anzahl der möglichen Permutationen</returns>
        public static int CountPermutations(int n, int min, int max, int act, bool basicCall)
        {
            //Rekursiver Ausstieg
            if (act > n || act < 1 || permutation.Contains(act)) //Außerhalb des Definitionsbereiches!
            {
                return -1;
            }
            //Da wir innerhalb des Bereiches sind - gültige Zahl hinzufügen!
            permutation.Add(act);
            if (permutation.Count == n) //Lösung gefunden!
            {
                List<int> list = new List<int>(permutation);
                solutions.Add(list);
                permutation.RemoveAt(permutation.Count - 1); //Letztes Element wieder entfernen
                return -1; //Da wir alle Lösungen wollen, geben wir an, keine Lösung gefunden zu haben!
            }
            //Rekursiver Abstieg
            for (int i = min; i ≤ max; i++)
            {
                CountPermutations(n, min, max, act + i, false);
                CountPermutations(n, min, max, act - i, false);
            }
            if (basicCall)
            {
                permutation.Clear();
                act++;
                CountPermutations(n, min, max, act, true);
            }
            permutation.Remove(act);
            return solutions.Count;
        }
    }
Dirty-Backtracking aber was solls - es funktioniert ;)

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Hier ist noch meine Lösung, mir ist leider spontan auch nichts besseres als ein bruteforceartiger Algorithmus in den Sinn gekommen...


 public void FindString()
            {
                // TODO Hier seid ihr gefragt!
                StringBuilder guess = new StringBuilder();
                int erg = 0;
                do
                {
                    guess = guess.Append((char)64);
                    erg = stringHider.Ask(guess.ToString());
                } while (erg == -1);
                int len = guess.Length;
                for (int i = 0; i < len; i++)
                {
                    for (int v = 0; v < 26; v++)
                    {
                        guess[i]++;
                        int asked = stringHider.Ask(guess.ToString());
                        if (asked > erg || asked == -2)
                        {
                            erg++;
                            break;
                        }
                    }
                }
           }

Alles in allem auf die FindString Methode begrenzt, falls mir noch ein besserer Ansatz einfällt werde ich diesen Post editieren

Thema: Suche Liegestuhl für PC- Arbeit
Am im Forum: Smalltalk

Zitat von winSharp93
Ja, dem kann ich zustimmen.
Ich sitze selbst auf einem und er ist wirklich angenehm.

Ich war auch schon an dem gedanken mir den zu holen-aber bei den 5 Minuten Testsitzen weiß man nie ob man es auf dem Teil länger aushält^^

Also ist der Stuhl länger am Tag 'benutzbar' ?

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Wahrscheinlich gilt dies nicht als richtige Lösung aber man kanns ja mal versuchen ^^


 public void FindString()
            {
                // TODO Hier seid ihr gefragt!
                object erg = typeof(StringHider).InvokeMember("value", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic, null, stringHider, null);
                string asking = (string)erg;
                int ret = stringHider.Ask(asking);
            }

Grüße Daniel

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Funktioniert - du bist drann

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Zitat
Nachricht von Alf Ator vom 22.07.2011 15:03
RE: Programmier spiel

Da du jetzt grundsätzlich triffst, gilt die Aufgabe als gelöst, und du darfst dir eine neue Aufgabe ausdenken

Endlich 8)

OK-neue Aufgabe ...

ich hätte gerne eine Klasse die mit Binärzahlen rechnet (es sollen die 4 Grundrechnungsarten implementiert werden). (Einmal mit operator overloading und einmal als Methode [ebenfalls alle 4] um beispielsweise eine int-Zahl hinzu zu addieren [ binary.add(123) ])
Als Konstruktor kann man entweder die Binärzahl als string übergeben oder eine int-Zahl die dann in eine Binärzahl umgerechnet wird. Intern wird alles bitweise gerechnet!
Jedes Bit soll einzeln via Index gesetzt werden können bzw abgerufen werden (Die Zahl darf ebenfalls nicht als normale int-Zahl vorhanden sein sondern im Binär-Format).
Man soll ebenfalls die Zahl mit ToInt() als Integer Zahl bekommen können.
Viel Spaß!

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Ich lade jetzt einfach mal meine derzeitige Lösung hoch.
Vielleicht ist es ja schon ausreichend :P (hab das als .rar hochgeladen da ich es irgendwie unnütz finde 4 .cs Dateien zu posten) [Programm update]

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

@Alf Ator
Ist es ausreichend wenn man sieht dass die Objekte kolidieren oder muss man auch eine Kollisionserkennung einbauen?

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Ich hab hier mal eine kleine Grafische darstellung gemacht, für die die es brauchen (so wie ich :P) :


  public partial class DrawBoard : Form
    {
        public MovingObject ship;
        public MovingObject ast;
        public MovingObject shot;

        public DrawBoard(MovingObject a, MovingObject b) : this(a, b, null)
        {
        }

        public DrawBoard(MovingObject a, MovingObject b, MovingObject c)
        {
            InitializeComponent();
            ship = a;
            ast = b;
            shot = c;
            Timer t = new Timer();
            t.Interval = 500;
            t.Tick += new EventHandler(t_Tick);
            t.Start();
        }

        void t_Tick(object sender, EventArgs e)
        {
            if (ship != null)
            {
                ship.Move();
            }
            if (ast != null)
            {
                ast.Move();
            }
            if (shot != null)
            {
                shot.Move();
            }
            this.Invalidate();
            if (shot.x == ast.x && shot.y == ast.y)
            {
                MessageBox.Show("TREFFER!");
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics draw = e.Graphics;
            {//DrawGraph
                    Pen gray = new Pen(Brushes.Gray, 1F);
                    int max = 200; // constant     |
                    int abstand = 50; // constant  > change for graphstyle
                    for (int i = 0; i < max; i++)
                    {
                        draw.DrawLine(gray, new Point(i * abstand, 0), new Point(i * abstand, max * abstand));
                        draw.DrawLine(gray, new Point(0, i * abstand), new Point(max * abstand, i * abstand));
                        draw.DrawString((i * abstand).ToString() + "px", new Font(FontFamily.GenericSansSerif, 7F), Brushes.Black, new PointF(abstand * i, 0));
                        draw.DrawString((i * abstand).ToString() + "px", new Font(FontFamily.GenericSansSerif, 7F), Brushes.Black, new PointF(0, abstand * i));
                    }
            } //End DrawGraph
            //Draw the Objects
            if (ship != null)
            {
                Pen black = new Pen(Brushes.Black, 2F);
                draw.DrawEllipse(black, ship.x * 40, ship.y * 40, ship.r * 10, ship.r * 10);
            }
            if (ast != null)
            {
                Pen blue = new Pen(Brushes.Blue, 2F);
                draw.DrawEllipse(blue, ast.x * 40, ast.y * 40, ast.r * 10, ast.r * 10);
            }
            if (shot != null)
            {
                Pen green = new Pen(Brushes.Green, 1.5F);
                draw.DrawEllipse(green, shot.x * 40, shot.y * 40, shot.r * 10, shot.r * 10);
            }
            //Draw line for movement
            Pen red = new Pen(Brushes.Red, 1F);
            draw.DrawLine(red, new Point(ship.x * 40, ship.y * 40), new Point(ship.dx * 40, ship.dy * 40));
            draw.DrawLine(red, new Point(ast.x * 40,ast.y * 40), new Point(ast.dx * 40, ast.dy * 40));
            draw.DrawLine(red, new Point(shot.x * 40, shot.y * 40), new Point(shot.dx * 40, shot.dy * 40));
        }
        

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.SuspendLayout();
            // 
            // DrawBoard
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(365, 262);
            this.Name = "DrawBoard";
            this.Text = "DrawBoard";
            this.ResumeLayout(false);

        }

        #endregion
    }

OK, hab das ganze denk ich jetzt mal verstanden, fehlt nur noch die Berechnung - aber das ist nur noch Kopfsache und wenn ich Zeit dafür finde ^^

[DrawBoard updated]

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Hallo,

ich verstehe deine Angabe leider noch nicht so ganz, aber eins weiß ich bestimmt:

Deklariere das Random Objekt irgendwo und erzeuge nur eine Instanz davon, da ansonsten ziemlich oft gleiche Werte als Ergebnis kommen ;)

Thema: Eigene MP3 Player library schreiben
Am im Forum: Grafik und Sound

Vielleicht habe ich mich ein bisschen falsch ausgedrückt. Ich möchte das aus eigenem Interesse machen und 'Frusteffekt' würde definitiv keiner entstehen ;)

Das man dies mal in der Praxis benötigt bezweifle ich ebenfalls, nur wie gesagt möchte ich mal sozusagen hinter die Kulissen sehen.

Thema: Eigene MP3 Player library schreiben
Am im Forum: Grafik und Sound

Weil es für mich interessanter ist seine eigene Bibliothek zu schreiben als bereits bestehende zu verwenden-ist mir zu wenig. Außerdem hat man so zugleich einen höheren 'Lerneffekt' und ist zugleich 'besser' zum Vorführen ;)

Thema: Eigene MP3 Player library schreiben
Am im Forum: Grafik und Sound

Danke schonmal für die Info

Das andere Problem das ich dann noch habe ist, wie ich die Töne ausgebe wenn ich sie mal 'herausgelesen' hab

Thema: Eigene MP3 Player library schreiben
Am im Forum: Grafik und Sound

Hallo,
ich würde gerne meine eigene DLL schreiben um mp3 Files abzuspielen (so was ähnliches wie die bass.dll oder die wmp dll), nur leider habe ich noch keine Ahnung wo ich zu suchen beginnen soll. Ich möchte die mp3 Files selbst parsen und nicht vorgefertigte Bibliotheken wie Audio.play() verwenden.
Hoffe ihr könnt mir ein paar nützliche Links posten!

lg Daniel B.

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Ich habe wieder etwas ausgegraben:

Ein string-search Algorithmus á la Boyer-Moore: http://de.wikipedia.org/wiki/Boyer-Moore-Algorithmus

Da in dem Artikel ein Beispielcode in C existiert könnte man sich auch die Zeit nehmen und diesen zu überarbeiten - doch würde ich eine eigene Implementation bevorzugen

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

Wegen deinem Platzproblem kannst du dich damit mal spielen:


Console.WindowHeight
Console.WindowWidth 

Das Prog funktioinert auf den ersten Blick - du bist dran

Thema: Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Am im Forum: Smalltalk

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