Meiner Erfahrung nach kann man PDFs auf dem Kindle eher vergessen.

Kann ich nicht bestätigen 😉 Dank Touchscreen auf dem Paperwhite ist das (für meine Bedürfnisse) vollkommen in Ordnung! 😉

Ansonsten hier meine Erfahrungen mit dem Kindle:

Habe den Paperwhite jetzt seit etwa 1 1/2 Wochen und bin ziemlich begeistert 😃 Das Licht ist top für das Lesen im Hellen und in der Dunkelheit, vor allem wenn man mal im Bus lesen will und es morgens noch dunkel ist.

EBooks lesen ist sehr angenehm. Lesen geht beidhändig und einhändig sehr gut, da man entweder durch "Wischen" oder durch Drücken auf den Bildschirm zwischen Seiten hin- und herwechseln kann.

PDFs lesen ist auch annehmbar. Im Hochformat kann man durch doppelten Druck automatisch passend an den Text zoomen (geht auch bei mehreren Spalten). Ansonsten lese ich PDFs bevorzugt im Querformat, was auch angemessen gut geregelt ist.

Hinzu kommt der Beta-Browser, mit dem man zu hause per WLAN schnell und (trotz E-Ink Display) eigentlich annehmbar im Internet surfen kann, um z.B. Nachrichten zu lesen. Zu diesem Zweck gibt es auch einen "Artikelmodus", in dem die Webseite so dargestellt wird, als wäre sie eine Seite aus einem "richtigen" EBook.

Alles in allem bin ich zufrieden mit dem Kauf. Der Kobo Glo wäre wohl vergleichbar gut gewesen, das will ich gar nicht abstreiten, den hatte ich jetzt letztens im Laden in der Hand 😉 Troubadix wird da wohl eher einen Erfahrungsbericht abgeben können.

Gruß

stes

Kleiner Nachtrag: Warum nicht einfach die mobile Seite, sofern vorhanden, verwenden? Dann habe ich doch eigentlich nichts anderes als einen Browser im Angebot. Und die Texte die ich mobil bekomme sind meistens in einer annehmbaren Form, sodass das eigentlich kein Problem sein sollte, oder?

Gruß

stes

(Wobei natürlich auch hier die Frage ist, ob es dem Anbieter letzten Endes gefällt. Und klagen könnte er schließlich auch, wenn ich im Recht bin 😦 )

Hallo winSharp93, hallo herbivore,

danke für eure Antworten. Letztendlich ließe sich das Problem eigentlich dadurch lösen, dass ich einen reinen RSS-Reader verwende und die Artikel anschließend über den (in die Anwendung integrierten) Browser einbinde, wie etwa bei Akregator, den ich unter Linux verwende. Dann würde der Content ja ordnungsgemäß angezeigt, mitsamt der Werbung, die in jedem anderen Browser auch sichtbar wäre.

Ob das noch schön aussieht und in eine Windows 8 App passt, müsste ich mir noch überlegen 😉

Eine Klage für eine kostenlose App zu riskieren ist mir die Sache dann nämlich doch nicht wert. ^^

Gruß

stes

Hallo zusammen,

vielen Dank für eure Antworten. Ich werde das ganze sowieso erstmal als RSS-Reader ausbauen, dann sehe ich weiter 😉

Ich habe einfach mal verschiedene Nachrichtenanbieter konsultiert und lasse mich einfach mal überraschen was als Feedback zurückkommt, wobei ich nicht wirklich optimistisch bin.

Zu herbivores Bemerkungen: Die App soll auf jeden Fall kostenlos werden, allerdings möchte ich Werbung auf keinen Fall von vornherein ausschließen.

Ein kleines Gedankenspiel: Wäre die App so gestaltet, dass standardmäßig KEINE Nachrichtenquellen vorhanden sind, der Nutzer sie also manuell (per Link) hinzufügen muss: Was genau unterscheidet eine solche Applikation dann von einem Webbrowser mit aktiviertem AdBlocker? Laut den angestellten Überlegungen wäre der Browser bei dieser Verwendung dann ebenso unzulässig.

Gruß

stes

Hallo zusammen,

ich habe in den letzten Tagen mit der Entwicklung einer Nachrichten-App für Windows 8 begonnen.

Die Artikel sollen dabei auch von Seiten wie "faz.net" oder "spiegel online" kommen. Meine Frage: Ist das ohne weiteres möglich? Schließlich ist der eigentliche Plan der Seitenbetreiber, mit Ihrem Content über Werbung auf der Seite Geld zu verdienen. Dem ist allerdings entgegen zu halten, dass ich mit meiner App ja prinzipiell nur eine Möglichkeit anbiete, den Artikel der Seite in einer anderen Darstellung anzuzeigen. Die Funktionsweise kommt damit praktisch der eines Browsers mit eingeschaltetem AdBlocker gleich.

In der App würde ich dann natürlich bei jedem Artikel die entsprechende Quelle angeben, zusammen mit einem Link zum Originalartikel.

Hat jemand hier Erfahrung in dieser Hinsicht? Ich erwarte natürlich keine juristisch vollkommen handfeste Antwort, aber vielleicht kennt sich ja zufällig jemand mit dem Thema aus 😄

Gruß

stes

Hallo Thomas,

wirklich DEN ausschlaggebenden Punkt gab es nicht. Wie gesagt, beide Geräte sind gleichwertig, mal abgesehen von kleineren Unterschieden in Soft- und Hardware.

Ich habe mir noch ein paar Reviews angesehen und bin irgendwann zum Schluss gekommen (oder habe vermutet), dass sich PDFs auf dem Kindle besser lesen lassen (hat der Kobo eigentlich eine Funktion zur Anzeige im Querformat?). Der Kindle unterstützt Zoom per Touchgeste, der Kobo nicht. 1:0 für den Kindle. Scrollen & Suchen im Dokument geht beim Kobo ohne Refresh, 1:1. So ging es dann weiter bis der Kindle am Ende einen Punkt vorne lag (oder so ähnlich 😄 ).

Bei E-Books gefiel mir die X-Ray Funktion sehr gut (siehe Amazon). Ansonsten kann ich dir anhand objektiver Argumente nicht begründen, warum ich mich so entschieden habe. Ich war auch kurz davor den Kobo zu bestellen bis ich mich dann doch noch sehr kurzfristig umentschieden habe.

Ich denke (und hoffe) wir werden beide mit unseren Geräten glücklich 😉 Aber mich würde es interessieren, wie sich der Kobo so bedienen lässt. Mein Kindle-Review wird wohl noch etwas dauern, der Paperwhite kommt nämlich erst kurz vor Weihnachten bei mir an.

Gruß

stes

Edit: PS.: mich würde interessieren wie du dich dann entgültig entschieden hast 😉

Habe mir vergangene Tage den neuen Kindle Paperwhite vorbestellt und freue mich riesig auf Dezember! 😉

Letztendlich bin ich zum Schluss gekommen, dass ich auf jeden Fall einen Reader mit Beleuchtung haben möchte, sprich es war ein "Duell" Kobo Glo vs. Kindle Paperwhite.

Eigenschaften sind vergleichbar mit Kobo Touch und Kindle Touch, allerdings jeweils mit einigen Verbesserungen / Veränderungen. Nach dem Ansehen einiger weiterer Reviews bin ich zum Schluss gekommen, dass der Kindle letztendlich für mich persönlich das bessere Gerät abgeben wird, auch wenn ich die Art und Weise, wie Amazon E-Books verkauft, nicht unbedingt vollkommen unterstütze.

Nichtsdestotrotz kam am Ende nur noch der Paperwhite in Frage. Wenn er vor mir liegt kann ich evtl. nochmal einen kurzen Überblick geben, was er alles so drauf hat und inwiefern er sich von den anderen Geräten abhebt.

Gruß

stes

Moin moin,

erstmal danke für die vielen (ausführlichen) Antworten!

Zusammenfassend möchte ich folgendes festhalten:

1. Die Akkulaufzeit scheint bei allen eInk Readern vergleichbar hoch zu sein
2. Lesen in der Sonne -> ebenfalls nur vom Displaytyp abhängig
3. Wörterbücher integriert, wenn auch von Hersteller zu Hersteller leicht unterschiedlich

Die eigentlichen Merkmale kurz zusammengefasst:

Kindle (mit Tasten)

• geringer Preis
• guter E-Book Store (mit kostenlosen Werken etc.)

~ ausreichende Bedienungmöglichkeiten bei "normalem" Lesen (von E-Books)
~ PDFs angemessen lesbar im Querformat (wenn richtig formatiert)
~ nach Konvertierung auch andere E-Book Formate lesbar

• Steuerung per Tasten reicht nicht aus, wenn es um komplexere Dokumente geht
• kein Reflow bei PDFs

Kindle Touch

• bessere Bedienung über Touchscreen
• guter E-Book Store (mit kostenlosen Werken etc.)

~ PDFs angemessen lesbar im Querformat (wenn richtig formatiert)
~ nach Konvertierung auch andere E-Book Formate lesbar

• kein Reflow bei PDFs/teilw. umständliche Bedienung

Kindle DX

• ausreichende Displaygröße
• gute Darstellung auch von Dokumenten im A4 Format

• schwerer zu transportieren
• verhältnismäßig teuer

Cybook Odyssey

• mitgelieferte Sammlung an E-Books

~ angemessende Darstellung von PDFs

• Unterstützt nur E-PUB Format

Kobo Touch

• eBooks aus allen möglichen Stores lesen
• komfortable Bedienung über Touchscreen

~ häufige Updates

• im eBook Store trifft man eher auf englischsprachige Bücher
• teilweise langsame Darstellung von PDFs

Ich habe zusätzlich noch Testvideos für Kindle Paperwhite und Kobo Glo angesehen, dabei sind mir noch folgende sehr positiven Merkmale eingefallen:

• durch das integrierte Licht keine Leselampe (z. B. in Hülle integriert) notwendig, angenehmes Lesen bei Nacht
• bessere Auflösung

Beim Kobo Glo sehen Darstellung und die Ladezeiten von PDFs zudem sehr gut aus, da die Prozessorleistung von 800 MHz (Kobo Touch) auf 1 GHz erhöht wurde.

Letztendlich komme ich zum folgenden Zwischenergebnis:
Auch wenn ich PDFs lesen möchte, werde ich nicht über ein 6'' Display hinauskommen, da mir der Kindle DX schlicht zu teuer ist und ein Gerät mit LCD auf keinen Fall infrage kommt.
Ich schwanke momentan zwischen dem Kobo Glo (130 €) und einem normalen Kindle 4 mit Tasten.

Eine zusätzliche Frage hätte ich noch: Bringt es etwas, PDFs z. B. in das EPUB-Format zu konvertieren? Ich habe mir Programme wie etwa Calibre noch nicht angesehen, aber tendenziell wären dann doch alle Probleme gelöst, selbst wenn der Reader kein Text-Reflow bei PDFs unterstützt, oder?

Anmerkung: Wenn ich von PDFs spreche, habe ich keine komplizierten und großen Zeitungsartikel im Sinn, sondern eher ein wissenschaftliches Paper mit schlimmstenfalls mal zweispaltiger Ansicht, in der Regel aber selbst das nicht. Auch Bilder halten sich dementsprechend in Grenzen.

Vor diesem Hintergrund erscheint mir der Kobo Glo als ein (fast) perfekter Reader. Gibt es vielleicht noch andere hier, die einen Kobo Touch besitzen und bzgl. der obigen Punkte einen Kommentar abgeben können? 😉

Gruß

stes

Hallo zusammen,

ich habe mich letztens dazu entschlossen, mir einen E-Book Reader zuzulegen und mir zunächst den Amazon Kindle näher angesehen. Schon da gibt es ja verschiedene Varianten, und während dem Lesen gefühlter tausender Testberichte bin ich dann auch noch auf E-Reader von Kobo gekommen..

Kurz: Ich habe zur Zeit absolut keine Ahnung, für welchen Reader ich mich entscheiden soll 😄

Meine Anforderungen sind:

• Gute Darstellung von PDF-Dokumenten (v. a. ohne lange Wartezeiten!)
• E-Ink Display, mindestens 6''
• unkomplizierte Bedienung
• gute & billige E-Books am besten direkt über den Reader beziehen können

Zunächst gibt es ja den Kindle 4 in der Grundversion mit Tasten, den ich auch schon selbst in der Hand gehalten habe. Alternativ käme der Kindle Touch in Frage, der allerdings auch deutlich teurer ist.

Ganz aktuell sind ebenfalls auch Reader mit integrierter Beleuchtung im Kommen, namentlich Kindle Paperwhite und Kobo Glo. Auf dem deutschen Markt sind diese leider noch nicht verfügbar, aber zumindest der Glo sollte Mitte Oktober erscheinen.

Meine Frage wäre ganz einfach: Wer hat schon Erfahrung mit E-Readern gemacht? Für alle, die einen Reader besitzen: Ist das entsprechende Modell zu empfehlen? Wo gibt es Defizite?

Vielleicht komme ich auf diese Weise ja mit meiner Entscheidung ein Stück weiter 😉

Gruß

stes

Hallo Mao,

habe mir die Lösung angeschaut, funktioniert alles soweit 😉

Beim Öffnen in Visual Studio musste ich allerdings noch das Icon in den Debug-Ordner kopieren, als Anmerkung für alle, die sich das Projekt auch noch ansehen wollen..
Weiterhin sollte man den jetzt doch noch nachträglich eingefügten Sourcecode nicht in mein ursprüngliches Projekt reinkopieren, da in Mao's Projekt noch ein zusätzliches Label zum Einsatz kommt, kurz: Einfach das angehängte Projekt downloaden ^^

Ansonsten kann Mao, oder

jemand anderes die nächste Aufgabe stellen.

Gruß stes

Bild aus einem Beitrag von "The Daily WTF"

😄

Hallo,

wikipedia sieht das so:

Der Begriff App (von der englischen Kurzform für application, das grammatische Geschlecht ist im Sprachgebrauch variabel) bezeichnet im Allgemeinen jede Form von Anwendungsprogrammen. Im Sprachgebrauch sind damit mittlerweile jedoch meist Anwendungen für moderne Smartphones und Tablet-Computer gemeint, die über einen in das Betriebssystem integrierten Onlineshop bezogen und so direkt auf dem Smartphone installiert werden können

Es hat sich eben mittlerweile eingebürgert, Programme für Smartphone & Co. "App" zu nennen.

Aber wenn - wie schon vorher erwähnt - z. B. mit Win8 herkömmliche PCs und Tablets ein und dieselbe UI nutzen, könnte ich mir gut vorstellen dass wir in der Zukunft nur noch "Apps" entwickeln.. 😉

Letztendlich ist es ja auch egal, ich nutze die begriffe eigentlich nach lust und laune und sehe es eigentlich wie mein Vorredner (fast, Programm != Tool IMO^^)

Gruß
stes

Hier noch ein Screenshot von der GUI:

Hallo zusammen,

hier die neue Aufgabe:

[B][U]MouseBall[/U][/B]

Ziel soll die Entwicklung eines kleines Spielchens sein. Evtl kennt es der ein oder andere von iPod & Co.: Ein Ball muss durch Antippen (hier: Anklicken) möglichst oft hochgehalten werden.

Die GUI für das Spiel gebe ich vor (siehe Anhang). Wenn ihr das Projekt so startet, befindet sich der Ball auf Startposition. Punkte bekommt man, indem man den Ball über die Linie in der Mitte spielt.

[FRAME]
Anforderungen an eine korrekte Lösung:

\* Aktualisierung der Punktzahl während des Spiels und evtl. der Highscore (Informierung über neue Highscore z.B. per MessageBox möglich, aber nicht unbedingt gefordert)
\* Ball kann nur [U]unter[/U] der Linie angespielt werden. Beim Anspielen erhält der Ball zusätzlich zur Bewegung nach oben noch eine Bewegung nach rechts oder links, je nachdem wo ihn die Maus trifft.
\* Trifft der Ball an eine der Ränder des Panels, soll er von diesen auch abprallen.
\* Wie erwähnt, gibt es einen Punkt, sobald der Ball über die Mittellinie gespielt wird

Hinweis: Es ist nicht unbedingt das Ziel, eine physikalisch besonders korrekte Flugkurve zu erhalten, das ganze ist ein [U]kleines Spiel zum Zeitvertreib und keine Simualtionssoftware[/U] ;) Andererseits soll es natürlich einigermaßen realistisch wirken (wenn ich z. B. von links unten gegen den Ball "schlage" soll er natürlich nicht nach links oben fliegen, sondern nach rechts oben^^)

Hier der (unvollständige) Code für die Interaktion. Meine Lösung erfordert das Hinzufügen von knapp 80 Codezeilen (wenn ich mich nicht verzählt habe 😄)

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
using System.IO;

namespace MouseBall
{
    public partial class Form1 : Form
    {
        public const float BALL_RADIUS = 20;

        // add/change fields as you please!
        private Image _ballImg;
        private PointF _ballPos;
        private PointF _speedVector;

        public int Score { get; private set; }
        public int Highscore { get; private set; }

        public Form1()
        {
            InitializeComponent();
            _pnlGame.Paint +=new PaintEventHandler(_pnlGame_Paint);
            _pnlGame.MouseClick += new MouseEventHandler(_pnlGame_MouseClick);

            this.initBall();

            // load and resize ball icon
            string s = Path.Combine(
                Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
                "soccer-ball.ico");
            _ballImg = new Bitmap(new Icon(s).ToBitmap());
            _ballImg = new Bitmap(_ballImg, new Size((int)BALL_RADIUS*2, (int)BALL_RADIUS*2));

            // let's start playing!
            _timer.Start();
        }

        private void initBall()
        {
            _ballPos = new PointF(_pnlGame.Width / 2, _pnlGame.Height - BALL_RADIUS);
        }

        private void _pnlGame_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            // paint middle line
            g.FillRectangle(
                Brushes.White,
                0,
                _pnlGame.Height/2-2,
                _pnlGame.Width,
                4);
            // paint the ball
            g.DrawImage(_ballImg, _ballPos.X - BALL_RADIUS,
                _ballPos.Y - BALL_RADIUS);
        }

        void _pnlGame_MouseClick(object sender, MouseEventArgs e)
        {
            // ... your part ;)
        }

        private void _timer_Tick(object sender, EventArgs e)
        {
            // ...your part ;)
            _lblScore.Text = Score.ToString();
            _pnlGame.Invalidate();
        }
    }
}

Kleiner Hinweis zur verwendeten Grafik: Quelle, Lizenz: Creative Commons (Attribution 3.0 Unported)

Das fertige Spiel liegt bereits fertig auf meiner Festplatte, evtl. wird es dann zusammen mit einer hier geposteten Lösung unter der GNU GPL v3 unter den "Projekten" veröffentlicht.
[/frame]

Viel Spaß mit der Aufgabe!

Gruß
stes

Dem muss ich zustimmen.

Wer ein Gerät mit z. B. GPS und Internet kauft (und das ist bei heutigen Smartphones wohl Standard) muss sich dem "Risiko" einfach bewusst sein.

Und selbst wenn so etwas auffliegt, will sicherlich nur die Minderheit auf ihr Smartphone verzichten, wenn überhaupt.
Außerdem gilt auch hier wie so oft: Mit der Zeit wächst Gras über die Sache, die Kunden nutzen munter weiter und beim nächsten Vorfall geht das Spektakel von vorne los, ohne jegliche Konsequenzen.

Gruß
stes

Hey Siassei,

ganz meine Meinung, aber:

Diese Entscheidung darf kein Hersteller fällen. Jede Aufzeichnung / Übermittlung von Daten muss Standardmäßig deaktiviert (oder beim ersten Start des Benutzers) sein.

Ob das dann wirklich auch der Fall ist, kann Ottonormalverbraucher wohl leider nicht immer selbst feststellen...
Und wenn es dann auffliegt heißt es wieder: "Fehler in der Software, wir wussten von nichts"

Gruß
stes

Hallo,

grade im Radio gehört:

Microsoft soll Bewegungsdaten aufgezeichnet haben

war ja nur eine Frage der Zeit bis MS (nach Apple & Co.) auch damit anfängt die GPS-Daten von Smartphones zu speichern.. Mittlerweile muss man sich echt ständig "beobachtet" fühlen, wenn man ein Gerät mit Inet + GPS in der Tasche trägt.. ^^

Gruß
stes

Hallo,

schau doch mal hier: Codeproject Tutorial WPF: "Part 1: Transformations"

Gruß
stes

Moin moin,

hier meine Lösung:

        static void Main(string[] args)
        {
            int i = 0;
            object[,] arr = new object[5, 5];
            for (int x = 0; x < 5; x++)
            {
                for (int y = 0; y < 5; y++)
                {
                    arr[x, y] = i++;
                }
            }
            PrintField(arr, PrintOptions.BottomUpSecond, 100);
            Console.ReadKey();
        }

        public static void PrintField(object[,] field, PrintOptions PrintOption, int sleepTime)
        {
            if (PrintOption == PrintOptions.Normal)
            {
                for (int i = 0; i < field.GetLength(0); i++)
                {
                    // länge der zeile bestimmen
                    StringBuilder s = new StringBuilder();
                    s.Append("|");
                    for (int j = 0; j < field.GetLength(1); j++)
                    {
                        s.Append(field[i, j].ToString() + "|");
                    }

                    for (int j = 0; j < s.Length; 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(sleepTime); //Somit 'sieht' man den Aufbau
                    }
                    Console.WriteLine();
                }
            }
            else if (PrintOption == PrintOptions.BottomUp)
            {
                Console.CursorTop = field.GetLength(0)*2-1;
                for (int i = field.GetLength(0)-1; i >= 0; i--)
                {
                    Console.Write("|");
                    for (int j = 0; j < field.GetLength(1); j++)
                    {
                        Console.Write(field[i, j].ToString() + "|");
                        System.Threading.Thread.Sleep(sleepTime); //Somit 'sieht' man den Aufbau
                    }
                    Console.CursorTop--;
                    Console.CursorLeft = 0;
                    // länge der zeile bestimmen
                    StringBuilder s = new StringBuilder();
                    s.Append("|");
                    for (int j = 0; j < field.GetLength(1); j++)
                    {
                        s.Append(field[i, j].ToString() + "|");
                    }

                    for (int j = 0; j < s.Length; j++)
                    {
                        Console.Write("-");
                    }
                    Console.CursorTop-= Console.CursorTop > 0 ? 1 : 0;
                    Console.CursorLeft = 0;
                }
                Console.CursorTop = field.GetLength(0) * 2;
            }
            else if (PrintOption == PrintOptions.BottomUpSecond)
            {
                Console.CursorTop = field.GetLength(0) * 2 - 1;
                bool left2right = false;
                for (int i = field.GetLength(0) - 1; i >= 0; i--)
                {
                    // länge der zeile bestimmen
                    StringBuilder s = new StringBuilder();
                    s.Append("|");
                    for (int j = 0; j < field.GetLength(1); j++)
                    {
                        s.Append(field[i, j].ToString() + "|");
                    }
                    if (left2right)
                    {
                        Console.Write("|");
                        for (int j = field.GetLength(1) - 1; j >= 0; j--)
                        {
                            Console.Write(field[i, j].ToString() + "|");
                            System.Threading.Thread.Sleep(sleepTime); //Somit 'sieht' man den Aufbau
                        }
                    }
                    else
                    {
                        Console.CursorLeft = s.Length;
                        for (int j = field.GetLength(1) - 1; j >= 0; j--)
                        {
                            string write = field[i, j].ToString() + "|";
                            Console.CursorLeft -= write.Length;
                            Console.Write(field[i, j].ToString() + "|");
                            Console.CursorLeft -= write.Length;
                            System.Threading.Thread.Sleep(sleepTime); //Somit 'sieht' man den Aufbau
                        }
                        Console.CursorLeft = 0;
                        Console.Write("|");
                    }
                    left2right = !left2right;
                    Console.CursorTop--;
                    Console.CursorLeft = 0;
                    for (int j = 0; j < s.Length; j++)
                    {
                        Console.Write("-");
                    }
                    Console.CursorTop -= Console.CursorTop > 0 ? 1 : 0;
                    Console.CursorLeft = 0;
                }
                Console.CursorTop = field.GetLength(0) * 2;
            }
        }

        public enum PrintOptions
        {
            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)
        }

Nicht schön programmiert, aber immerhin habe ich mal meine alten Freunde Strg+C, Strg+V sowie if & else wieder getroffen ^^

Gruß
stes

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

                    // länge der zeile bestimmen
                    StringBuilder s = new StringBuilder();
                    s.Append("|");
                    for (int j = 0; j < field.GetLength(1); j++)
                    {
                        s.Append(field[i, j].ToString() + "|");
                    }

Wobei s.Length dann die Zeilenlänge darstellt

Hallo,

das Projekt ist zwar mittlerweile schon etwas älter, aber danke für die Rückmeldung ^^

Deine 60% im Gegensatz zu den 100% konnte ich nicht bestätigen.

Muss ich dann demnächst ggf. mal überprüfen, ansonsten werde ich es korrigieren 😉

Aber danke für den Link, werde ich mir mal genauer ansehen. Wenn man den Zahlen trauen darf:

Directory.GetFiles method: ~225ms
DirectoryInfo.GetFiles method: ~230ms
FastDirectoryEnumerator.GetFiles method: ~33ms
FastDirectoryEnumerator.EnumerateFiles method: ~27ms

sowie

Directory.GetFiles method: ~43,860ms
DirectoryInfo.GetFiles method: ~44,000ms
FastDirectoryEnumerator.GetFiles method: ~55ms
FastDirectoryEnumerator.EnumerateFiles method: ~53ms

sind das allerdings "messbare Unterschiede"!

Gruß
stes

Und hier der Screenshot:

Hallo zusammen,

habe mir heute aus Langeweile mal einen kleinen Timer programmiert. Die Features (viele sind es nicht ^^):

* Zeit einstellen, Starten und Stoppen (wer hätte es gedacht ^^)
* Countdown pausieren und fortsetzen
* Reset auf die zuletzt eingestellte Zeit
* akustischer Hinweis bei Countdownende

Zur Benutzung:

1. Zeit eingeben, im Format hh:mm:ss (einfach in das Textfeld schreiben)
2. Enter drücken und/oder Start-Button drücken
3. Pausieren durch Druck auf Stop
   a. Fortsetzen durch Start
   b. Reset
   c. neue Zeit eintippen

Dokumentation habe ich mal vergessen, kommt evtl. später ^^ (das meiste erklärt sich auch von selbst).

Im Anhang das Programm, im nächsten Post kommt noch ein kleiner Screenshot.

Gruß stes

Hallo Floste,

den zweiten Versuch lasse ich gelten, habe in der Aufgabenstellung vergessen zu sagen dass nur die string.Length aus der string Klasse verwendet werden darf (wegen string.Reverse ^^).
Naja läuft auf jeden fall, wen es interessiert hier die Lösung die ich zusammengebastelt habe:

return(s.Length>i)?c(s,i+1)+(s[i]%3==0&s[i]!=' '?""+(char)(s[i]-1):"")+s[i]:"";

ist sogar etwas länger ^^

Jedenfalls bist du dann jetzt dran, bin gespannt auf die neue Aufgabe.

Gruß
stes

Hallo!

ich will den Thread mal wieder aus der Inaktivität zurückholen 😄

Nach den Regelungen in herbivore's erstem Beitrag

Wenn eine Woche seit dem jeweils letzten Beitrag vergangen ist, ist der Thread wieder frei für eine neue Aufgabe (egal wer die neue Aufgabe stellen möchte und egal ob dieser letzte Beitrag nun eine Aufgabe, eine Nachfrage oder eine Lösung ist und egal ob die Lösung richtig oder falsch war, also einfach: eine Woche Inaktivität = neue Aufgabe erlaubt).

darf ja jetzt jeder wieder eine Aufgabe stellen, daher hier eine (zur Abwechslung mal wieder kurz lösbare) - Aufgabe:

[B]Aufgabe[/B]

Herr A und Herr B möchten sicher* Nachrichten übermitteln. Dabei gelten folgende Regeln:

[list]
[*]Eine Nachricht besteht nur aus Großbuchstaben
[*]Leerzeichen sind die einzigen erlaubten Sonderzeichen
[*]das heißt auch: Umlaute sind nicht erlaubt
[/list] 

Eine Nachricht wird folgendermaßen codiert:
Vor den Zeichen B, E, H, K, N, Q, T, W und Z wird jeweils das vorherige Zeichen angehängt (Bsp.: HALLO -> HGALLO; TEEKANNE -> TSEDEDKJANMNMED).
Anschließend wird die komplette Zeichenkette umgedreht (Bsp.: HALLO -> HGALLO -> OLLAGH; ...)

Um einen solchen String zu decodieren, haben Herr A und Herr B die folgende Methode entworfen:

[csharp]
        string decode(string s, int i = 0, bool replace = false)
        {
            return (i == s.Length) ? "" : (s.Length > i + 1)
            ? decode(s, i + 1, s[i + 1] % 3 == 0 &&
            s[i + 1] != ' ') + (s[i + 1] % 3 == 0
            && s[i + 1] != ' ' ? "" : s[i].ToString())
            : decode(s, i + 1) + s[i];
        }
[/csharp]

Wie man sieht, ist der Code nicht sonderlich übersichtlich. Herr A und Herr B's Code Style ist nämlich durchaus zu optimieren.

Die Methode zum Codieren geht noch einen Schritt weiter. Nach etwas Überlegen und Herausnehmen jeglicher Struktur hat es Herr A geschafft, den Methodenrumpf (ohne "{" und "}" ) auf unter 80 Zeichen zu komprimieren und in eine Zeile zu bringen.

[FRAME]Aufgabe: Implementiere die Methode zum Codieren der Nachricht nach dem oben beschriebenen Verfahren. Der Rumpf darf dabei höchstens 100 Zeichen lang sein (optimal wären natürlich unter 80, mal sehen wer es schafft^^).

Der Methodenkopf soll dabei wie folgt aussehen:

        string c(string s, int i = 0)
        {
           // max. 100, besser sogar 80 Zeichen!!
        }

Kleiner Tipp zu den o.g. Zeichen: Schaut euch mal eine ASCII-Tabelle an, die sind nicht willkürlich ausgesucht 😉

[Wichtiger Hinweis: Zu lange Beschäftigung mit dieser Aufgabe kann den eigenen Programmierstil irreparabel degradieren 😄 bzw. "MNDERDEIDARGDED LDEABARAPDERRI LISTSRDEIMMARGORP MNDEMNDEGIDE MNDED MNMNAJK DEABAGFUA RDESDEID STIM GMNUGISTFDEAGHCSDEAB DEGMNAL UYZ"]

(*) Und zum Schluss.. dass das Verfahren alles andere als "sicher" ist, wissen wir wahrscheinlich alle 😄[/frame]

Ich kann als ersten Überblick ebenfalls das von Wassermann empfohlene Openbook empfehlen.

Grund: kostenlos, seeehr (!) umfangreich (aber gut strukturiert), gut erklärt

Anschließend kann man sich dann ja immer noch für eine Offline-Version (sprich: gedruckt^^) eines Buches entscheiden.

Hallo,

danke für eure Antworten, wenngleich ich etwas überrascht bin, dass mein Konzept mit KNNs spontan über den Haufen geschmissen wurde 😄

Ich hatte eigentlich vor, das Problem mit den nahezu endlos vielen Möglichkeiten beim Schach (und im kleineren Rahmen bei TicTacToe) mit einem KNN zu umgehen (wie gut das Netz letztendlich spielt bleibt dann abzuwarten, allerdings will ich ja auch keinen Weltmeister damit schlagen ^^).

Aber danke für die Tipps, die ja nun zu Beginn des Projekts noch früh genug kommen, ich glaube ich muss da an einigen Stellen nochmal kräftig umdenken 😉

Gruß
stes

Hallo zusammen,

ich habe mir für mein nächstes Projekt einen einigermaßen guten Schachcomputer als Ziel gesetzt, der auf künstlichen neuronalen Netzwerken basieren soll.

Um es nicht zu übertreiben (was KI anbelangt bin ich Anfänger) möchte ich zunächst eine Stufe kleiner, genauer gesagt mit Tic Tac Toe beginnen.

Ich bin mittlerweile so weit, dass ich eine TicTacToe-KI (wenn man es den "Intellienz" nennen kann) geschrieben habe, die mit einem Brute-Force-ähnlichen Algorithmus arbeitet und durchaus brauchbar spielt (man gewinnt jedenfalls nicht mehr ^^).

Nun möchte ich das ganze mit einem KNN realisieren. Ich habe bereits diverse Foren, Ebooks etc. durchstöbert und mir ein grobes Grundlagenwissen angeeignet. Nach jetzigem Stand halte ich ein feedforward-Netz mit einer Eingabe-, einer verdeckten, und einer Ausgabeschicht für angebracht. Dabei soll die Eingabeschicht sowohl direkt mit der Ausgabeschicht vernetzt werden (hemmende Wirkung, da ein Feld nicht zweimal belegt werden kann) als auch mit dem Hidden Layer.

Soweit, so gut (oder nicht?). Nun zur Lernmethode: Meiner Meinung nach wäre das Bestärkende Lernen (reinforcement learning) am ehesten geeignet. Wie auch in bestärkendes Lernen nachzulesen ist, lernt das Netz quasi selbstständig nur aufgrund der Sanktionen, die es von der "Außenwelt" erhält (also Sieg, Remis oder Niederlage; später beim Schach dann zusätzlich Figurenverlust etc.).

Wie ich in anderen Beiträgen aus diesem Forum bereits erfahren habe (Stichwort: "Künstliche Intelligenz"), treiben sich hier einige Leute rum die sich umfassend mit dem Thema beschäftigt haben und beschäftigen.

Was haltet ihr von meinem Konzept bis hier hin (Bitte auch auf sachliche Fehler hinweisen ^^) ?

Gruß
stes

Hallo zusammen,

bin wieder da 😁 Die Aufgabe scheint ja (aus welchem Grund auch immer --> zu einfach? 😉 ) ganz gut bei euch angekommen sein.

Ich habe mir aus diesem Grund auch die Arbeit gemacht und alle (gültigen) Lösungsvorschläge getestet. Hier eine kleine Zusammenfassung:

1. Testbedingungen
Alle Algorithmen wurden dreimal getestet:1.Länge 50-100 auf 10.000 Durchläufen 1.Länge 100-200 auf 1.000 Durchläufen 1.Länge 300-500 auf 1.000 Durchläufen

Außerdem habe ich mit Rücksicht auf den Moderationshinweis von herbivore auch das Datum des letzten Edits als "Abgabedatum" berücksichtigt.

2. Ergebnisse
Insgesamt habe ich fünf gültige Lösungen getestet.
Hier die Ergebnisse
Format: <Name>, <Datum>: <Anzahl Test 1>/<Anzahl Test 2> / <Anzahl Test 3
1.myUnderTakeR, 26.07: 903 / 1841 / 5265 1.Daniel B., 27.07 (5:39): 974 / 1975 / 5681 1.Alf Ator, 27.07 (17:13): 680 / 1757 / 5672 1.gfoidl, 27.07 (22:56): 572 / 1356 / 4512 1.ProgrammierTroll, 28.07: 708 / 1688 / 5426

3. Gewinner der Aufgabe

Laut den von herbivore angesprochenen Regeln gilt derjenige als Gewinner, der die erste gültige Lösung postet.
Daher erkläre ich myUnderTakeR zum Gewinner und überlasse ihm die nächste Aufgabe 😉 Die Anzahl der Versuche ist auf jeden Fall zufriedenstellend und entspricht in etwa der von mir erwarteten Lösung.

Nichtsdestotrotz möchte ich eine "besondere Anerkennung" an Alf Ator und gfoidl aussprechen (auch wenn Alf Ator's zweite Lösung nicht fehlerlos funktioniert ^^), da die Algorithmen deutlich optimiert und umfangreicher ausgefallen sind.

Freue mich auf die nächste Aufgabe.

Gruß
stes

Ok, dann hier die nächste Aufgabe (hoffe sie ist nicht zu einfach^^):

Aufgabe

Gegeben sind zwei Klassen:

        class StringFinder
        {
            private StringHider stringHider;

            public StringFinder(StringHider s)
            {
              // ....
            }

            public void FindString()
            {
              // Hier seid ihr gefragt! 
            }
        }

        class StringHider
        {
            private string value;
            private int minLength, maxLength;
            public int Tries { get; private set; }

            public StringHider(int minLength, int maxLength)
            {
              // ....
            }

            public void GenerateString()
            {
               // ....
            }
            /// <returns>-2: Die Zeichenfolge stimmt
            ///          -1: Die Zeichenfolge hat die falsche Länge
            ///          0-... Die Zeichenfolge hat die richtige Länge, ist aber noch nicht korrekt.
            ///          Die Nummer gibt die Anzahl der richtig platzierten Zeichen an.
            ///</returns>
            public int Ask(string guess)
            {
               // ....
            }
        }

(Hinweis: Den Code habe ich nicht gepostet, sonst wäre es zu lang geworden - siehe Anhang!)

Der StringHider erstellt eine Zeichenfolge einer Länge zwischen minLength und maxLength, die aus zufällig ausgewählten Zeichen (Großbuchstaben, d. h. alle Zeichen von A bis Z, ohne Umlaute etc.) besteht.

Eure Aufgabe: Ergänzt die FindString() Methode des StringFinders dergestalt, dass diese mit möglichst wenigen Aufrufen der Ask(string guess)-Methode die Zeichenfolge "erraten" kann.

WICHTIG: Ich möchte nicht, dass hier mit irgendwelchen Tricks gearbeitet wird; einziges Hilfsmittel soll die Rückgabe des StringHiders sein, sprich:*-2: Die Zeichenfolge stimmt *-1: Die Zeichenfolge hat die falsche Länge *0-... Die Zeichenfolge hat die richtige Länge, ist aber noch nicht korrekt. Die Nummer gibt die Anzahl der richtig platzierten Zeichen an.

Zu beachten: JEDE Ausführung der Ask-Methode setzt den Zähler im StringHider hoch, verschlechtert also das Endergebnis. Setzt sie daher mit Bedacht ein 😉

(Zugegeben, das ganze hat etwas von Mastermind ^^)

Zum Testen eurer Methode habe ich eine passende Main-Methode geschrieben, die das ganze für eine festgelegte Anzahl an Versuchen simuliert. Diese wird, in der Form wie unten angegeben, ausschlaggebend für die Bestimmung des Gewinners sein. Wer bei 10.000 Durchläufen (evtl. auch mehr, mal sehen) die kleinste durchschnittliche Anzahl an Versuchen benötigt, gewinnt dieses Programmierspiel.

Hier die Main-Methode in voller Länge:

        public const int SIMULATION_QUANTITY = 10000;

        static void Main(string[] args)
        {
            Console.WriteLine("Starte Simulation");
            // Zur Bestimmung des Gewinners werde ich 3 verschiedene (nicht bekannt gegebene)
            // Wertepaare für die Stringlänge benutzen!
            StringHider s = new StringHider(50, 100);
            StringFinder sf = new StringFinder(s);
            int tries = 0;
            for (int i = 0; i < SIMULATION_QUANTITY; i++)
            {
                if (i%(SIMULATION_QUANTITY/10) == 0)
                    Console.WriteLine(i*100 / SIMULATION_QUANTITY + "%");
                sf.FindString();
                tries += s.Tries;
                if (s.Ask(s.lastGuess) != -2)
                {
                    Console.WriteLine("Fehler: Deine FindString-Methode liefert falsche Ergebnisse!");
                    break;
                }
                s.GenerateString();
            }
            Console.WriteLine("Durchschnitt: {0} Versuche", tries / SIMULATION_QUANTITY);
            Console.ReadLine();
        }

Hinweise zur Lösung:
Bitte NUR die FindString()-Methode als Lösung posten! (evtl. noch die Anzahl der Versuche bei einem Probelauf - aber wenn, dann ehrlich^^)

Ende der Aufgabe

Hinweis:"Leider" bin ich bis nächsten Freitag (29. 07) im Urlaub und kann u. U. den Gewinner nicht schnell genug bekannt geben. Wenn möglich, soll die Aufgabe bis zum genannten Datum laufen, danach gewinnt derjenige, der den besten Algorithmus entwickelt hat; hierzu werde ich alle bis dahin geposteten Lösungen testen.
Wenn der Zeitraum zu lang ist (was ich nicht hoffe), kann ja notfalls ein Moderator einen Gewinner festlegen...

Ansonsten wünsche ich viel Erfolg!

Hallo Floste und herbivore,

erstmal danke für eure Antworten.

@Floste:

bzgl. 1) Den genauen Pfad kann man ja beliebig auf seine Bedürfnisse anpassen, meinetwegen lagert man das ganze in einen zusätzlichen Ordner aus.
bzgl. 2) Das ist auf jeden Fall richtig, dann ist es eben ein "Downloader" ^^
bzgl. 3) Für "bekanntere Software" ist es sicherlich auch nicht empfehlenswert, ein solch simples Code-Snippet als vollwertigen Updater (oder: Downloader 😉 ) darzustellen.

Alles in allem ist das hier ein simples Snippet, an das man keine allzu großen Anforderungen stellen sollte. Natürlich gibt es etliche Möglichkeiten, das Programm zu verbessern (Downloadstatus & Dateigröße anzeigen, nur neuere Versionen downloaden etc.)

Um auf herbivores "Prinzipielle Bedenken" einzugehen: Ich stimme Dir in einigen Punkten zu (ich nutze z. B. auch öfters ältere Programmversionen). Persönlich habe ich das Programm bisher (leicht abgewandelt) für kleinere Projekte (in der Entwicklungsphase) genutzt, um nicht ständig manuell die Dateien runterladen zu müssen. Es handelte ich hierbei vorwiegend um Anwendungen, die in irgendeiner Form etwas mit Netzwerk zu tun hatten (z. B. ein Chat oder auch ein Multiplayer Spiel). Für sowas ist ein solcher Updater meiner Meinung nach ganz nützlich.

Gruß
stes

Beschreibung:

Ein kleines Code-Snippet zum Aktualisieren von Programmen.
Zur Benutzung wird das eigentliche Programm auf einem öffentlichen Server abgelegt (ich nutze hierzu meine Dropbox). Die URL der Datei wird der Konstanten "URL" zugewiesen.

Zum Starten des Programms wird dann zunächst der Updater ausgeführt, der die aktuelle Version vom Server lädt und anschließend ausführt.
Wer eine ausführlichere Lösung sucht, sollte sich vielleicht das updateSystem.NET anschauen.

using System;
using System.Net;
using System.Windows.Forms;
using System.Diagnostics;

namespace Updater
{
    class Program
    {
        const string URL = "insert url here";
        const string APPLICATION_NAME = "filename.exe";

        static string fullPath = Application.StartupPath + "\\" + APPLICATION_NAME;

        static void Main(string[] args)
        {
            Console.WriteLine("Downloading file...");
            WebClient myClient = new WebClient();
            try
            {
                myClient.DownloadFile(URL, fullPath);
            }
            catch (WebException e)
            {
                Console.WriteLine("Download failed. Try again later.\n"+
                                  "Press ENTER to exit");
                Console.ReadLine();
                return;
            }
            Console.WriteLine("Successfully downloaded file, press ENTER to continue");
            Console.ReadLine();
            Process.Start(fullPath);
        }
    }
}

Schlagwörter: Update, Download, Aktualisieren, WebClient

Hallo zusammen,

hier meine Lösung der Aufgabe von Daniel:

Zunächst die Klasse zur Darstellung von Binärzahlen:
(Achtung: Die Klasse ist relativ lang geworden, daher habe ich sie zusätzlich als Anhang hinzugefügt; der eingefügte Code lässt sich ja zum Glück minimieren ^^)

using System;

namespace Binary
{
    public struct BinaryNumber
    {
        public const int BIT_QUANTITY = 8;

        public bool this[int i]
        {
            get { return Bits[i]; }
            set { Bits[i] = value; }
        }
        /// <summary>
        /// least significant bit
        /// </summary>
        public bool LSB
        {
            get { return Bits[0]; }
        }
        /// <summary>
        /// most significant bt
        /// </summary>
        public bool MSB
        {
            get { return Bits[Bits.Length - 1]; }
        }

        private bool[] bits;
        public bool[] Bits
        {
            get { return bits; }
            set { bits = value; }
        }

        #region constructors

        public BinaryNumber(int fromInt)
        {
            bits = new bool[BIT_QUANTITY];
            if (fromInt > pow2(BIT_QUANTITY-1)-1 || fromInt < -pow2(BIT_QUANTITY-1))
                throw new ArgumentOutOfRangeException();
            else
            {
                if (fromInt >= 0)
                    Bits = convertInt(fromInt);
                else if (fromInt < 0)
                {
                    Bits = convertInt(-fromInt);
                    Bits = this.Neg().Bits;
                }
            }

        }

        public BinaryNumber(string fromString)
        {
            bits = new bool[BIT_QUANTITY];
            if (fromString.Length != BIT_QUANTITY)
                throw new ArgumentException();
            for (int n = 0; n < BIT_QUANTITY; n++)
            {
                Bits[n] = (fromString[BIT_QUANTITY - 1 - n] == '1');
            }
        }

        #endregion

        private bool[] convertInt(int x)
        {
            bool[] buffer = new bool[BIT_QUANTITY];
            for (int i = 0; i < buffer.Length; i++)
            {
                int pot = (int)Math.Pow(2, i);
                buffer[i] = ((x & pot) == pot);
            }
            return buffer;
        }

        private int pow2(int e)
        {
            return (e == 0) ? 1 : (2 << e - 1);
        }

        #region calculations

        public BinaryNumber Neg()
        {
            BinaryNumber b = new BinaryNumber(0);
            for (int n = 0; n < Bits.Length; n++)
            {
                b.Bits[n] = !Bits[n];
            }
            return b.Add(1);
        }

        public BinaryNumber Abs()
        {
            return MSB ? this.Neg() : this;
        }

        public BinaryNumber Add(BinaryNumber b)
        {
            BinaryNumber newB = new BinaryNumber(0);
            bool carry = false;
            for (int i = 0; i < newB.Bits.Length; i++)
            {
                newB.Bits[i] = Bits[i] ^ b.Bits[i] ^ carry;
                carry = (Bits[i] & b.Bits[i]) | (Bits[i] & carry) | (b.Bits[i] & carry);
            }
            return newB;
        }

        public BinaryNumber Add(int i)
        {
            return this.Add(new BinaryNumber(i));
        }

        public BinaryNumber Subtract(int i)
        {
            return this.Subtract(new BinaryNumber(i));
        }

        public BinaryNumber Subtract(BinaryNumber b)
        {
            return this.Add(b.Neg());
        }

        public BinaryNumber Multiply(BinaryNumber b)
        {
            if (b == 1)
                return this;
            else
                return this + this.Multiply(b - 1);
        }

        public BinaryNumber Multiply(int b)
        {
            return this.Multiply(new BinaryNumber(b));
        }

        public BinaryNumber Divide(BinaryNumber b)
        {
            if (b == 0)
                throw new DivideByZeroException();
            if (!MSB && !b.MSB)
            {
                // positive number
                if (this < b)
                    return new BinaryNumber(0);
                else
                    return (this - b).Divide(b) + 1;
            }
            else if (MSB && b.MSB)
            {
                return this.Abs().Divide(b.Abs());
            }
            else
            {
                // negative number
                return this.Abs().Divide(b.Abs()).Neg();
            }
        }

        public BinaryNumber Divide(int i)
        {
            if (this < new BinaryNumber(i))
                return new BinaryNumber(0);
            else
                return new BinaryNumber(1) + (this - new BinaryNumber(i)).Divide(i);
        }
        
        #endregion

        #region operator overloads

        public static BinaryNumber operator +(BinaryNumber a, BinaryNumber b)
        {
            return a.Add(b);
        }

        public static BinaryNumber operator +(BinaryNumber a, int b)
        {
            return a.Add(b);
        }

        public static BinaryNumber operator -(BinaryNumber a, BinaryNumber b)
        {
            return a.Subtract(b);
        }

        public static BinaryNumber operator -(BinaryNumber a, int b)
        {
            return a.Subtract(b);
        }

        public static BinaryNumber operator *(BinaryNumber a, int b)
        {
            return a.Multiply(b);
        }

        public static BinaryNumber operator *(BinaryNumber a, BinaryNumber b)
        {
            return a.Multiply(b);
        }

        public static BinaryNumber operator /(BinaryNumber a, BinaryNumber b)
        {
            return a.Divide(b);
        }

        public static BinaryNumber operator /(BinaryNumber a, int b)
        {
            return a.Divide(new BinaryNumber(b));
        }

        public static bool operator ==(BinaryNumber a, BinaryNumber b)
        {
            return a.Equals(b);
        }

        public static bool operator !=(BinaryNumber a, BinaryNumber b)
        {
            return !a.Equals(b);
        }

        public static bool operator >(BinaryNumber a, BinaryNumber b)
        {
            return a.isBigger(b);
        }

        public static bool operator <(BinaryNumber a, BinaryNumber b)
        {
            return b.isBigger(a);
        }

        public static bool operator ==(BinaryNumber a, int b)
        {
            return a.Equals(b);
        }

        public static bool operator !=(BinaryNumber a, int b)
        {
            return !a.Equals(b);
        }

        public static bool operator >(BinaryNumber a, int b)
        {
            return a.isBigger(b);
        }

        public static bool operator <(BinaryNumber a, int b)
        {
            return !a.isBigger(b) && (a != b);
        }

        #endregion

        #region converting methods
        public override string ToString()
        {
            string buffer = "";
            for (int n = Bits.Length-1; n >= 0; n--)
            {
                buffer += Bits[n] ? "1" : "0";
            }
            return buffer;
        }

        public int ToInt()
        {
            int i = 0;
            bool[] bits = null;
            int sign = 0;
            if (Bits[Bits.Length - 1])
            {
                sign = -1;
                bits = this.Neg().Bits;
            }
            else
            {
                sign = 1;
                bits = this.Bits;
            }
            for (int n = 0; n < bits.Length; n++)
            {
                if (bits[n])
                    i += pow2(n);
            }
            return i*sign;
        }
        #endregion

        public override bool Equals(object obj)
        {
            if (obj is BinaryNumber)
            {
                BinaryNumber comp = (BinaryNumber)obj;
                for (int n = 0; n < Bits.Length; n++)
                {
                    if (Bits[n] != comp.Bits[n])
                    {
                        return false;
                    }
                }
                return true;
            }
            else if (obj is int)
            {
                return Equals(new BinaryNumber((int)obj));
            }
            else
            {
                return false;
            }
        }

        public bool isBigger(BinaryNumber b)
        {
            for (int n = Bits.Length - 1; n >= 0; n--)
            {
                if (Bits[n] == b.Bits[n])
                {
                    continue;
                }
                else if (Bits[n] && !b.Bits[n])
                {
                    return true;
                }
                else if (!Bits[n] && b.Bits[n])
                {
                    return false;
                }
            }
            // numbers are equal
            return false;
        }

        public bool isBigger(int b)
        {
            return isBigger(new BinaryNumber(b));
        }
    }
}

Zum Testen der drei Grundrechenarten hier ein kleines Hauptprogramm für die Konsole:

using System;

namespace Binary
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                // input
                Console.Write("Zahl 1: ");
                int a = Convert.ToInt32(Console.ReadLine());
                Console.Write("Zahl 2: ");
                int b = Convert.ToInt32(Console.ReadLine());

                // converting to binary numbers
                BinaryNumber bin1 = new BinaryNumber(a);
                BinaryNumber bin2 = new BinaryNumber(b);

                // output
                Console.WriteLine("Summe:\t\t{0}", (bin1 + bin2).ToInt());
                Console.WriteLine("Differenz:\t{0}", (bin1 - bin2).ToInt());
                Console.WriteLine("Produkt:\t{0}", (bin1 * bin2).ToInt());
                Console.WriteLine("Quotient:\t{0}", (bin1 / bin2).ToInt());

                Console.ReadLine();
                Console.Clear();
            }
        }
    }
}

Kleine Beschreibung:

Die Binärzahlen werden durch ein Array aus mehreren bools dargestellt. Mit der Konstanten BIT_QUANTITY wird festgelegt, aus wie vielen Bits die Binärzahl besteht. WICHTIG: Ich bin grundsätzlich von einer Zahl MIT Vorzeichen ausgegangen, daher führen z. B. 4 Bits zu einem Zahlenbereich von 1000 (- 8) bis 0111 (7).

Weitere Anmerkung: Die pow2-Methode, an einigen Stellen zur Berechnung von 2er-Potenzen genutzt, habe ich anstelle der Math.Pow-Funktion verwendet:

        private int pow2(int e)
        {
            return (e == 0) ? 1 : (2 << e - 1);
        }

ist gleichbedeutend mit

Math.Pow(2, e)

Habe das so implementiert da in der Aufgabenstellung stand man solle intern alles bitweise ausrechnen, bei höheren Werten für die BIT_QUANTITY führt das allerdings zu StackOverflowExceptions; im Zweifelsfall also ggf. durch die Pow-Funktion aus der Math-Klasse ersetzen 😉

Hallo zusammen!

Um den Thread mal wieder etwas aufleben zu lassen, hier mal meine "Hello World" Version (in Python):

def xhl                     (r, n, i):
 if i==1:                 return (  r)
 else:return           (( n -  1)*(xhl
 (r,n,(i-1)))**     n+r ) / ( n *( xhl
 (r, n   ,( i-1)) )** (n    -   1)  );
x =  "48656c6c6f20576f726c64"; s = ""; 
for i in  range(int("85", ((((int(ord(
'\x0b') + 1 - xhl(int("1", 1/ 2 * 2**
5)**ord('H')+ord(hex(int(str((5)/ (ord
('\x16') )), (((int(ord('\x0b')+1-xhl
(int("1", 16)**ord('H')+ord(hex(int(
str((5)/(ord('\x16'))), 10))[1]), 2, 5
)), 10)[1])) ))[1]), 2, 5)),10)[1]))+5
\*(ord('\x0b' ) + 1 - xhl(int("1", 16)
\**ord('H')+ord(hex(int(str((5)/(ord('\
\x16'))), 10))[1]), 2, 5))))-(int("0x\
55",int((hex(ord('Q')))[3]+(hex(ord('\
l')))[xhl(abs(ord('S')-ord('s')),5,15
)], 10))),ord('\x16'),int(chr(2*25))):\
s+=chr(int(str((int(x[i],int((hex(ord(
'Q')))[3]+(hex(ord('l')))[2], 10))))+x
[i+(int("80",int((hex(ord('Q')))[3]+ (
hex(ord('l')))[2], (((int(ord('\x0b')+
1-xhl(int("1",(((int(ord('5')+1-xhl(
int("1", 8)**ord('H')+ord(hex(int(str(
(5)/(ord('\x16'))), 3))[1]),(2),5)),10
)[0])/(7*(3)))**4)**ord('H')+ ord(hex(
int(str((5)/(ord('\x16'))), 10))[1]),2
, 5)),5*(((int(ord('5')+1-xhl(int("1",
8)**ord('H')+ord(hex(int(str((5)/(ord
('\x16'))), 3))[1]), (2), 5)), 10)[0])
/(7*(3))))[1]))))/ord('\x80'))], int((
hex(ord('Q')))[0+3]+(hex(ord('l')))[2-
0], (((int(ord('\x0b') + 1 - xhl(int(
"1", 16)**ord('H')+ord(hex(int(str((5)
/(ord('\x16'))),(((int(ord('\x0b')
+1-xhl(int ("1" , 16)**ord('H'
)+ord(hex(int(str((5)/(ord
('\x16'))), 10))[1]),2
, 5)), 10) [1]))))
[1]),2,5)),10)
[1]) )) ));
print  s

Recht sinnlos, sieht als Wallpaper aber gar nicht mal schlecht aus (siehe Anhang).
Das Zitat unten habe ich bei http://www.lustigestories.de/stories/gleichsagen.php gefunden. Ziemlich zutreffend, wenn ihr mich fragt 😄

So, hier ist meiner, schön aufgeräumt (nur der Müll müsste mal wieder weg 😁 )

Hallo markus111,

ich kann deine Frage nur indirekt beantworten und meine Antwort ist noch nicht einmal positiv 😁

Zunächst solltest du dir im klaren darüber sein, ob es überhaupt möglich ist, auf dem entsprechenden Endgerät ein neues System aufzuspielen. Denn wenn es kein kompatibles Handy gibt, macht ein Emulator wohl eher wenig Sinn 😁

Außerdem würde mich interessieren, was für ein Betriebssystem du dann aufspielen möchtest? Ich habe selbst mal für mein LG nach einer Möglichkeit, Android zu installieren, gesucht, leider erfolglos..
Der Grund: Wenn du ein neues OS installieren oder gar Komponenten selbst schreiben möchtest (was unter low-level-Programmierung fallen würde), muss das Betriebssystem mit der Hardware kommunizieren können. Da das Betriebssystem allerdings für eine andere Hardware ausgelegt ist, gibt es ein Problem; Lösung: Du müsstest fleißig Treiber schreiben 😉

Der letzte Ausweg, ein anderes Handy-Betriebssystem zu benutzen, ist wohl sich ein neues Handy zu kaufen..

Gruß
stes

Mm.. schade, PAN unterstützt mein Handy nämlich net..

Naja, vllt finde ich ja doch noch nen Weg, und sooo wichtig ist es dann ja auch net 😄

Aber beles dich doch noch mal genauer zu DUN und poste deine ergebnisse

Ok werde ich tun 😄

würde mich auch interessieren wenn ich mich täusche

Ich will mal hoffen dass du dich nicht täuscht ^^

lg stes

[EDIT]

Bluetooth dial-up networking (DUN) is a wireless internet technology that refers to connecting to the internet using a Bluetooth enabled cell phone as a modem. Bluetooth DUN offers a low band alternative where there are no local hotspots to provide high speed wireless internet access. (Quelle: http://www.tech-faq.com/bluetooth-dun.html)

Nicht sehr vielversprechend 😕
[/EDIT]

Hi Smou,

als ich weiß das die nur für palm ist...

Ich wollte dir nicht unterstellen das du das übersehen hast, sry 😉

Dein Handy müsste PAN oder DUN unterstützen damit eine verbindung ins internet über bluetooth möglich wäre.

Also PAN kann ich nicht finden, DUN scheint es zu unterstützen. Aber ich dachte das würde man dann verwenden um das Handy als Modem für den PC zu verwenden, sprich: genau die falsche Richtung?

Gruß
stes

Hallo zusammen,

erstmal danke für eure Antworten.

@Smou: Die Seite hatte ich auch schon 😄 Leider nur für Palm..

Aber ich werd mal probieren was sich so mit ActiveSync machen lässt 😉

Gruß
stes

Hallo zusammen,

ich suche schon länger einen Weg, wie ich auf meinem Handy (LG KU990i, Java-fähig, Opera mini installiert, KEIN WLAN) über Bluetooth ins Internet komme.
Sprich: Statt der kostenpflichtigen GPRS-Verbindung möchte ich das Internet meines PCs nutzen.

Wisst ihr vielleicht eine Lösung bzw. kennt ihr eine Software mit dem man auf dem PC eine Art Zugangspunkt für das Handy einrichten kann?

Gruß
stes

Hallo NeuroCoder,

danke für die Tipps, ich werde mich demnächst mal dransetzen 😉
Besonders die Verlagerung der benutzerspezifischen Verhaltensweisen in DLLs halte ich für eine gute Idee.
Die aktualisierte Version werde ich dann demnächst hier posten..

Gruß
stes

Also ich hab C# mit nem galileo openbook (Visual C# 2008 - Das umfassende Handbuch) gelernt. Allgemein find ich diese openbooks genial, ich habe nämlich erstmal mit C++ angefangen und dann schnell gemerkt, dass C# für meine Zwecke viel besser passt. Und dann immer nen neues Buch kaufen ist auch nicht wirklich schön 😄

Also ich habe nen Acer Aspire 7740G Notebook,
Intel i5 430M mit 2,26 MHz (+ Turbo Boost)
ATI Mobility Radeon HD 5470
4GB Arbeitsspeicher (reicht eig vollkommen aus)
HDD: 640 GB
CD/DVD Brenner
17,3" HD+ LED Display vom Notebook + nen alten hp 1502 à 1024x768
und Windows 7 64-bit Home Premium (womit ich sehr zufrieden bin)

Und ich hab noch nen zweiten PC, etwa das Gegenteil von gfoidl's Screenshot 😄
Haltet euch fest:

• Windows 95 (Nutze aber eigentlich nur DOS Modus, da keine RS 232 Maus 😄 )
• 2111,8 MB (!) Festplatte
• 32 kByte RAM
• irgend nen schneller Intel Pentium Prozessor (1 Kern 😉 )
• keine USB-Ports, aber: CD-Laufwerk 😉

mit diesen Features können moderne Rechner dann nicht mehr mithalten:

• Diskettenlaufwerk 3,5" und 5,25"
• Laufwerk für Magnetbandspeicher (für Datensicherungen)

[der zweite PC wird übrigens nur noch zum "Basteln" benutzt, denn für Steuerungszwecke und Messungen kann man so alte Kisten noch richtig gut verwerten]

NClass kann ich ebenfalls empfehlen, außerdem ist in der aktuellen Version von #Devolop (4.0) einer drin (besonders empfehlenswert, wenn du noch nachträglich aus Code Diagramme erzeugen willst)
Ich kanns irgendwie auch nicht verstehen, dass Microsoft in VS 2010 Express den integrierten Designer rausgelassen hat...

Hör ich eigentlich immer, außer wenns komplizierter wird 😉
Meistens 1live oder von simfy.de (nur zu empfehlen!!)

Green Day - Rise Against - Nickelback
..und allgemein Punk & Rock, hin und wieder Techno/House

Hallo,

ich programmiere nun seit etwa einem 3/4 Jahr mit C#.
Als ich mit dem Programmieren angefangen habe, habe ich erstmal ausschließlich Programme für die Konsole programmiert, eben um sich aufs Wesentliche zu beschränken.

Mittlerweile programmiere ich etwas umfangreichere Forms-Anwendungen. Für mein Backup-Programm (siehe Signatur) habe ich beispielsweise etwa einen Monat gebraucht. Soll heißen, dass ich eher nebenbei (eben hobbymäßig) das Programm schrittweise erweitert habe. Grundsätzlich ist dazu eine einigermaßen gute Struktur nötig, und die kann man sich mit Konsolenanwendungen recht gut aneignen (auch wenns schonmal langweilig werden kann..)
Es gibt allerdings auch Projekte, die ich für einen längeren Zeitraum angesetzt habe (mehrere Monate bis ein Jahr).

Außerdem kann ich dir für später empfehlen, deine Programme auf Plattformen wie myCSharp hochzuladen um dir auch Meinungen erfahrener Programmierer einzuholen. Mir jedenfalls hat das immer etwas gebracht, oft habe ich dabei eine neue Technik oder Programmstruktur gelernt, die mir vorher noch unbekannt war.

Viele Grüße
stes