Forenbeiträge von Daniel B. Ingesamt 81 Beiträge
Alles klar, ich finde nichts mehr, du bist dran!
Bei folgendem Fall dreht sich das Bild nicht in die richtige Richtung
(der rote Punkt ist der "new Looking at"-Punkt)
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 😁
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 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
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
Funktioniert 😃
Viel Spaß mit der nächsten Aufgabe 😃
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 😃
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;
}
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;
}
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 😃
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 😉
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
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' ? 😁
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
Funktioniert - du bist drann 👍
Nachricht von Alf Ator vom 22.07.2011 15:03
RE: Programmier spielDa 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 😛 (hab das als .rar hochgeladen da ich es irgendwie unnütz finde 4 .cs Dateien zu posten) [Programm update]
@Alf Ator
Ist es ausreichend wenn man sieht dass die Objekte kolidieren oder muss man auch eine Kollisionserkennung einbauen?
Ich hab hier mal eine kleine Grafische darstellung gemacht, für die die es brauchen (so wie ich 😛) :
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]
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 😉
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 😉
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
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.
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
Wegen deinem Platzproblem kannst du dich damit mal spielen:
Console.WindowHeight
Console.WindowWidth
Das Prog funktioinert auf den ersten Blick - du bist dran 👍
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 😛
Hehe, ok - werd ich mir merken 😛
Okay, um wieder mal das Spiel hervorzuheben hätte ich gerne ein "GameOfLife" mti einer schönen grafischen Ausgabe
Hier noch zwei Links:
Game of Life - Deutsch
Conway's Game of Life - English
Falls Fragen auftreten stehe ich gerne zur Verfügung!
Viel Spass! 😃
Ich denke das liegt daran, dass ab den darauf folgenden Zahlen ein Überlauft passiert. Zumindest wenn ich mir das im Debugger ansehe wird x1 negativ.
//EDIT: Hab das jetzt mit einer BigInt-Klasse probiert -> funktioniert einwandfrei
Im Anhang hab ich jetzt noch das Projekt mit BigInt angehängt - hoffe diesmal passt alles 😃
Hier mal mein Vorschlag (Miller-Rabin Methode):
Meine Klasse:
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");
}
}
}
Scheint zu funktionieren, falls jemand nen Fehler findet kann er sich gerne melden 😛
Viel Spaß mit der nächsten Aufgabe ^^
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
Funktioniert 👍 -viel Spaß mit der nächsten Aufgabe 🙂
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
Dankeschön und auf zur nächsten Aufgabe!
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 😉
Viel Spaß!
ja natürlich - ich hatte auch nicht vor eine Angabe zu Posten bevor eine Bestätigung erfolgt 😉
Das Beispiel sollte gelöst sein - Neue Angabe kommt bald 😃
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace kartentrick
{
class Program
{
static char[] colors = { 'H', 'K', 'P', 'Z' };
static string[] cardtypes = { "Zehn", "Bube", "Dame", "König", "Ass" };
static void Main(string[] args)
{
Console.WindowWidth = 90;
string[] cards = GetCardPack();
Print(5, cards);
Console.Write("\nIn welchem Stapel ist ihre Karte?: ");
string input = Console.ReadLine();
Print(4, cards);
Console.Write("\nIn welchem Stapel ist ihre Karte?: ");
string stacknum = Console.ReadLine();
string choosen = RetrieveChoosenCard(int.Parse(input), int.Parse(stacknum), cards);
Console.Clear();
Console.WriteLine("Ihre Karte: {0}", choosen);
Console.ReadLine();
}
/// <summary>
/// Gibt die gesuchte Karte zurück
/// </summary>
static string RetrieveChoosenCard(int fiveStack, int fourStack, string[] cards)
{
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 5; j++)
{
if (cards[i * 5 + fiveStack-1] == cards[j * 4 + fourStack - 1])
{
return cards[i * 5 + fiveStack - 1];
}
}
}
return null;
}
/// <summary>
/// Initialisiert Karten und mischt sie
/// </summary>
/// <returns></returns>
static string[] GetCardPack()
{
string[] pack = new string[20];
int ct = 0;
for (int i = 0; i < cardtypes.Length; i++)
{
for (int j = 0; j < colors.Length; j++)
{
pack[ct] = colors[j] + " " + cardtypes[i] ;
ct++;
}
}
Random random = new Random();
for (int i = 0; i < 50; i++) //Funktion zum Mischen der Karten
{
int a = random.Next(0, 20);
int b = random.Next(0, 20);
if (a != b)
{
string swap = pack[a];
pack[a] = pack[b];
pack[b] = swap;
}
}
return pack;
}
static void Print(int stackcount, string[] cards)
{
for (int i = 0; i < stackcount; i++)
{
Console.Write("{0}.Stapel\t", i + 1);
}
Console.WriteLine("\n");
int ct = 0;
for (int i = 0; i < 20 / stackcount; i++)
{
for (int j = 0; j < stackcount; j++)
{
Console.Write(cards[ct] + "\t\t");
ct++;
}
Console.WriteLine();
}
}
}
}
Wäre es noch möglich, dass du deinen Code uploadest?
Eine Frage habe ich noch, ich bekomme wenn ich auf eine Nachricht warte beim Server folgenden Fehler:
Ein nicht blockierender Socketvorgang konnte nicht sofort ausgeführt werden
was bedeutet das ?
Hab es jetzt mehr oder weniger soweit das man schon normal spielen kann, hab jetzt die ganzn schleifen rausgenommen und die sockets in einen eigenen thread gepackt, muss morgen nur noch den ablauf konfigurieren
großes Danke für eure hilfe
Ich hab aber keine Ahnung wie ich es sonst machen soll, irgendwann muss ich die Daten abschicken und irgndwann auch warten
Die sleeps hab ich zum größten teil schon weggelöscht, nö, netzwerk läuft nicht in eigenem thread
Naja, das problem is bei SwitchPlayerAndSetImage sollte das bild bereits gesetzt werden, aber wenn ich draufdrücke "blockiert" sofort alles, also es kommt auch kein bild (ohne netzwerk dingens funktioniert alles einwandfrei)
Was vl. noch nützlich sein könnte:
Das Passiert wenn eine PictureBox angeklickt wird:
private void pictureBox1_Click(object sender, EventArgs e)
{
pictureBox1 = SwitchPlayerAndSetImage(pictureBox1, 0, 0);
if (hostToolStripMenuItem.Checked || clientToolStripMenuItem.Checked)
{
SendMessage(pictureBox1.Name);
}
block = false;
}
Danke ist schon mal ein guter tipp, nur ich bekomm wie immer eine verbindung zu stande , aber sobald ich irgndwo auf ein feld klicke (dann sollte es den namen des feldes senden), aber auch wenn ich nirgends hinklicke hängt sich die Form auf (sowohl bei Server als auch Client)
Hier erstelle ich den Serversocket
int port = 45678;
byte[] puffer = new byte[256];
IPEndPoint ep = new IPEndPoint(IPAddress.Any, port);
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
serverSocket.Bind(ep);
serverSocket.Listen(1);
try
{
Socket clientSocket = serverSocket.Accept();
client = clientSocket;
host = serverSocket; // öffentliche variable des typs Socket
MessageBox.Show("Verbunden mit Client", "Connected");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Achtung", MessageBoxButtons.OK);
}
Hier erstelle ich einen ClientServer
int port = 45678;
byte[] puffer = new byte[256];
IPEndPoint ep = new IPEndPoint(IPAddress.Parse(ipTB.Text), port);
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
System.Threading.Thread.Sleep(5000);
try
{
clientSocket.Connect(ep);
client = clientSocket;
MessageBox.Show("Verbunden mit " + client.RemoteEndPoint.ToString(), "Connected");
player = "Spieler 1";
showPlayer.Text = player;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Achtung");
}
Die MessageBox wird bei beiden Seiten angezeigt, also muss alles mit dem erstellen geklappt haben.
Ich habe auch darauf geachtet das nicht auf einem pc beide server erstellt werden sondern immer nur einer (eben host , oder client)
Hy Community,
ich probiere schon seit einer weile mit Sockets Nachrichten zu versenden. Nur leider funktioniert das nicht so ganz wie ich es mir vorstelle. Der Server und der Client schaffen es eine Verbindung aufzubauen, nur bekomme ich das mit dem Nachrichten senden nicht so ganz hin....
Hier meine Methode die eine Nachricht senden sollte:
private void SendMessage(string pictureBoxName)
{
try
{
int inputB = client.Send(System.Text.Encoding.ASCII.GetBytes(pictureBoxName));
}
catch (Exception ex)
{
MessageBox.Show("Senden der Aktion fehlgeschlagen", "Achtung");
}
}
Hier wie ich Nachrichten auf der Seite des Clients empfange:
private void GetMessageClient()
{
int inputB;
byte[] puffer = new byte[256];
while (!win)
{
richTextBox1.Text += "Warte auf Aktion des Gegners" + Environment.NewLine;
while ((inputB = client.Receive(puffer)) == 0)
{
System.Threading.Thread.Sleep(1000);
}
richTextBox1.Text += "Gegner: " + System.Text.Encoding.ASCII.GetString(puffer) + Environment.NewLine;
GetPictureBox(System.Text.Encoding.ASCII.GetString(puffer));
block = true;
richTextBox1.Text += "Warte auf Klick";
while (block)
{
System.Threading.Thread.Sleep(1500);
}
}
}
Hier wie ich Nachrichten empfange auf der Seite des Servers:
private void GetMessageHost()
{
int inputB;
byte[] puffer = new byte[256];
while (!win)
{
richTextBox1.Text += "Warte auf Klick" + Environment.NewLine;
block = true;
while (block)
{
System.Threading.Thread.Sleep(1500);
}
richTextBox1.Text += "Warte auf Aktion des Gegners";
while ((inputB = client.Receive(puffer)) == 0)
{
System.Threading.Thread.Sleep(1000);
}
richTextBox1.Text += "Gegner: " + System.Text.Encoding.ASCII.GetString(puffer) + Environment.NewLine;
GetPictureBox(System.Text.Encoding.ASCII.GetString(puffer));
puffer = new byte[256];
}
}
Hiermit hab ich meine Verknüpfung erstellt:
string PfadVK = DirectoryPath, NameVK = "\\"+LinkPathName;
string OriginalDateiMitPfad = TargetPathName;
object oWS = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell"));
object oLink = oWS.GetType().InvokeMember("CreateShortcut", BindingFlags.InvokeMethod, null, oWS, new object[] { PfadVK + NameVK + ".lnk" });
oLink.GetType().InvokeMember("TargetPath", BindingFlags.SetProperty, null, oLink, new object[] { OriginalDateiMitPfad });
oLink.GetType().InvokeMember("WorkingDirectory", BindingFlags.SetProperty, null, oLink, new object[] { Application.StartupPath });
oLink.GetType().InvokeMember("Save", BindingFlags.InvokeMethod, null, oLink, new object[] { });