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.
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
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
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.
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 ;)
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ß!
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 :)
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; }
}
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 :)
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 ;)
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
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ß!
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]
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.
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 ;)
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!
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
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