C# Strings in Koordinaten wandeln

[Torben (Gast)]

Hallo, ich bin noch Anfänger in C# auf Windows Forms und lerne mit einem 
Projekt. Jetzt stehe ich mit einer Aufgabenstellung etwas auf dem 
Schlauch und zwar möchte ich eine Textdatei einlesen und die einzelnen 
Stringbuchstaben des kompletten Alphabets und nummerische Zeichen (case 
sensitive) in ein definiertes XY-Kooridnaten verbinden und an eine 
Funktion übergeben.

Textdatei:

Hallo

Ergibt in der Koordinatentabelle:
H = X: 12 Y:1
a = X: 15 Y:6
l = X: 18 Y:100
l = X: 18 Y:100
o = X: 200 Y:700

Die Datei einlesen über die Filestreammethode ist nicht das Problem, 
sondern wie ich jetzt die Buchstaben mit meinen Koordinaten verbinde. 
Also ich übergebe den kompletten String oder die Datei und das Programm 
weiss welche Koordinaten es sind.

Ich denke eine Lookuptabelle ist das richtige, aber irgendwie will der 
Groschen nicht fallen. Versteht mich nicht falsch, ich möchte kein 
fertiges Programm, sondern vielmehr ein Denkanstoss zur Lösung.

[Karl H. (kbuchegg)]

Torben schrieb:

> H = X: 12 Y:1
> a = X: 15 Y:6
> l = X: 18 Y:100
> l = X: 18 Y:100
> o = X: 200 Y:700


Du liest erst  mal eine zeile als einen String ein.

Dann zerlegst du die Zeile anhand bekannter Trennstellen (zb 
Leerzeichen, zb Doppelpunkt) in einzelne Strings. Sieh dir dazu die 
String Methode 'split' an.

Nachdem du die komplette Zeile in geeignete Teile zerlegt hast, wendest 
du auf die dich interessierenden Teile eine der 'Convert' oder 'Parse' 
Methoden an, die dir Strings zum Beispiel in echte Zahlen konvertieren. 
Und die speicherst du dann so, wie du das brauchst. Zum Beispiel, in dem 
du dir eine Klasse machst, in der du die Kombination aus zu malendem 
Buchstaben und den jeweiligen Koordinatenwerten in einem Objekt 
vereingst. Die Summe aller Buchstaben könntest du dann in einem Array 
aus derartigen Objekten ablegen oder eben welcher Container zur 
Objektspeicherung dir sonst noch so gefällt.


Details zu jedem der Schritte findest du in jedem C# Lehrbuch bzw. 
Tutorial.

[Torben (Gast)]

Hallo Karl Heinz,

ich hab mir ein Beispiel von MS abgeändert.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace ConsoleApplication3
{
    class Package
    {
        public string Letters;
        public int x;
        public int y;
    }

    class Program
    {

        

        public static void LookupExample()
        {
            // Create a list of Packages to put into a Lookup data structure.
            List<Package> packages = new List<Package> {    new Package { Letters = "Ha", x = 2, y = 2 },
                                                            new Package { Letters = "aa", x = 2, y = 3 },
                                                            new Package { Letters = "la", x = 2, y = 4 },
                                                            new Package { Letters = "la", x = 2, y = 5 },
                                                            new Package { Letters = "oa", x = 2, y = 6 }
                                                          };

            // Create a Lookup to organize the packages. Use the first character of Company as the key value.
            // Select Company appended to TrackingNumber for each element value in the Lookup.
            Lookup<char, string> lookup = (Lookup<char, string>)packages.ToLookup(p => Convert.ToChar(p.Letters.Substring(0, 1)),
                                                            p => p.Letters + " " + p.x + " " +p.y);

            // Iterate through each IGrouping in the Lookup and output the contents.
            foreach (IGrouping<char, string> packageGroup in lookup)
            {
                // Print the key value of the IGrouping.
                Console.WriteLine(packageGroup.Key);
                // Iterate through each value in the IGrouping and print its value.
                foreach (string str in packageGroup)
                    Debug.WriteLine("    {0}", str);
            }

            // Get the number of key-collection pairs in the Lookup.
            int count = lookup.Count;

            // Select a collection of Packages by indexing directly into the Lookup.
            IEnumerable<string> cgroup = lookup['H'];

            // Output the results.
            Debug.WriteLine("\nPackages that have a key of 'H':");
            foreach (string str in cgroup)
                Debug.WriteLine(str);
                                        

            // Determine if there is a key with the value 'G' in the Lookup.
            bool hasG = lookup.Contains('G');
        }




        static void Main(string[] args)
        {

            LookupExample();



        }



    }
}

Ich muss alle Zeichen in der Textdatei lesen, also auch Leerzeichen, 
Trenner gibt es nicht, aber das ist wohl nicht wild. Das Beispiel liesst 
noch nicht aus der Datei, aber das Verbinden der Buchstaben auf meine 
Kooridnaten klappt so. Ist natürlich mühselig das komplette Alpabet etc 
so zu wandeln, aber anders geht es wohl nicht.

Ist das ein guter Lösungsweg? Oder bin ich auf dem Holzweg?

[Karl H. (kbuchegg)]

Torben schrieb:


> Ist das ein guter Lösungsweg?

Kann ich so nicht sagen, weil ich nicht weiss was das ganze iegentlich 
werden soll.

Aber aus
> Zum Beispiel, in dem du dir eine Klasse machst, in der du die
> Kombination aus zu malendem Buchstaben und den jeweiligen
> Koordinatenwerten in einem Objekt vereingst.

auf der einen Seite und

    class Package
    {
        public string Letters;
        public int x;
        public int y;
    }

zusammen mit

H = X: 12 Y:1

aus dem Datenfile schliesse ich, dass es genau darum geht aus der Zeile 
aus dem Datenfile ein Package Objekt zu erzeugen, bei dem

  Letter gleich "H"
  x gleich 12
  y gleich 1

sein soll.

Und der Weg dazu führt über String.split und geeignete Convert bzw. 
Parse Methoden die auf eine einzelne von der Datei eingelesene Zeile 
angewendet werden. Man kann natürlich auch die Zeile Buchstabe für 
Buchstabe auseinander nehmen und sich die Einzelteile zusammenbauen, 
wenn man das will. Man kann sich aber auch das Leben erst mal sehr viel 
einfacher machen, indem man die offensichtliche Struktur, die in jeder 
einzelnen Zeile der Datei steckt, sich zunutze macht.

Was du dann mit dem Package Objekt weiter machst, zum Beispiel wie in 
deinem geposteten Code zu einer

List<Package> packages

hinzufügen, das musst du wissen.

[Karl H. (kbuchegg)]

Torben schrieb:

> Trenner gibt es nicht

natürlich gibt es sie. Oder woran erkennst du denn beim blossen 
Hinschauen, wie sich eine Zeile

l = X: 18 Y:100

strukturiert?

Ganz offensichtlich steht zwischen Buchstabe und den weiteren Angaben 
ein '='. Und ganz offensichtlich steht zwischen der 
Koordinatenbezeichnung und dem Zahlenwert ein ':'

Das sind deine Trenner, an denen man den String in Teile aufteilt.
Wenn aus dem aus dem File eingelesenen String

l = X: 18 Y:100

ein String Array geworden ist:

Array[0]  gleich "l"
Array[1]  gleich "X"
Array[2]  gleich "18"
Array[3]  gleich "Y"
Array[4]  gleich "100"

dann hast du alles beisammen um auf Array[2] und Array[4] jeweils die 
Convert Methode loszulassen und ein entsprechendes Package Objekt mit 
den Erkentnissen zu befüllen.

[Torben (Gast)]

Hallo Karl Heinz,

ok jetzt hab ich dich verstanden.

Die Textdatei welche in die Koordinaten gewandelt werden muss hat keine 
Trenner, sondern muss von Anfang bis Ende gewandelt werden.

Die Tabelle mit der Referenzierung hat natürlich Trenner und kann somit 
gewandelt werden. Die Tabelle ist eine Exceldatei und kann auch in XML 
gewandelt werden, aber das ist Jacke wie Hose.

Ich hab mir die Parse-Methode angeschaut und die Möglichkeit mein 
Buchstaben in eine z.B. uint32 Zahl zu wandeln. Ich vermute das ich nun 
die Parse.enum nutzen soll um die Buchstaben in meine Koordinatenzahlen 
zu wandeln, oder?

[Torben (Gast)]

Ok du warst schon ein paar Schritte weiter und nimmst die mühsellige 
Arbeit ab indem du die Tabelle in ein Package wandelst und dieses 
Package zum Parsen nimmst, dadurch wird es natürlich viel generischer 
als meine Lookuptabelle. Vielen Dank! Ich werd das mal ausprobieren.

[Karl H. (kbuchegg)]

Ach. Jetzt versteh ich dich!

Mir war nicht klar, was Eingabe und was Ausgabe ist.

Du sollst aus

Hallo

das hier

H = X: 12 Y:1
a = X: 15 Y:6
l = X: 18 Y:100
l = X: 18 Y:100
o = X: 200 Y:700

erzeugen!
Ich dachte die ganze Zeit letzteres wäre der Input für dein Programm.

Ok. vergiss alles was ich gesagt habe. Ich bin von einer anderen 
Aufgabenstellung ausgegangen.

[B. S. (bestucki)]

Karl H. schrieb:
>> Trenner gibt es nicht
>
> natürlich gibt es sie. Oder woran erkennst du denn beim blossen
> Hinschauen, wie sich eine Zeilel = X: 18 Y:100
> strukturiert?

Ich glaube, der TO will das Umgekehrte. 'H' ergibt ein X von 12 und ein 
Y von 1.

Eine einfache und sichere Methode ist ein switch. Dies ist jedoch mit 
viel Arbeit verbunden:

switch(Zeichen){
  case 'H': X = 12; Y = 1; break;
  /* usw... */
  default:
    /* Fehlerbehandlung */
}

Eine andere Möglichkeit ist, den numerischen Wert des Zeichens für eine 
Lookup-Tabelle zu verwenden:

X = X_Werte[Zeichen];
Y = Y_Werte[Zeichen];

Ich kenne deine genauen Werte nicht, aber evt. lassen sich diese zur 
Laufzeit berechnen.


Edit: zu langsam...

[Karl H. (kbuchegg)]

> und zwar möchte ich eine Textdatei einlesen und die einzelnen
> Stringbuchstaben des kompletten Alphabets und nummerische Zeichen
> (case sensitive) in ein definiertes XY-Kooridnaten verbinden

Da erhebt sich aber trotzdem immer noch die Frage:
woher weisst du, welche Koordinaten zu einem Buchstaben gehören?

Deine (bis jetzt einzige) Eingabe an das Programm lautet ja

Hallo

und mehr hast du bis jetzt nicht. Woher nimmst du die Information, dass 
zu einem 'H' die Koordinaten 12 und 1 gehören?

Das hier

            List<Package> packages = new List<Package> {    new Package { Letters = "Ha", x = 2, y = 2 },
                                                            new Package { Letters = "aa", x = 2, y = 3 },
                                                            new Package { Letters = "la", x = 2, y = 4 },
                                                            new Package { Letters = "la", x = 2, y = 5 },
                                                            new Package { Letters = "oa", x = 2, y = 6 }
                                                          };

ist zwar nett, aber willst du wirklich diesen Zusammenhang im Programm 
stehen haben? Oder ist das soweit in Ordnung wenn das so ist?

Dann allerdings verstehe ich das Problem wieder einmal nicht.
Das kann ja auch in C# nicht so schwer sein, einen einzelnen Buchstaben 
nach dem anderen aus einer Datei zu lesen, den gelesenen Buchstaben 
mittels

            IEnumerable<string> cgroup = lookup[ gelesener Buchstabe ];

auf die Package-Liste loszulassen, wobei wahrscheinlich im Idealfall nur 
1 Package übrig bleibt und aus dem darauf folgendem

           // Output the results.
            Debug.WriteLine("\nPackages that have a key of 'H':");
            foreach (string str in cgroup)
                Debug.WriteLine(str);

die enstprechende Umänderng zu machen, die dann in eine Datei schreibt 
anstatt auf den Debug Output

[B. S. (bestucki)]

Karl H. schrieb:
> Da erhebt sich aber trotzdem immer noch die Frage:
> woher weisst du, welche Koordinaten zu einem Buchstaben gehören?

Eine flexible Lösung wäre natürlich, die entsprechenden Werte aus einer 
Datei zu lesen. Damit kämen dann wieder deine Beiträge zum Zuge. Wenn 
die Werte jedoch für alle Zeiten hart in Stein gemeisselt sind, würde 
ich mir den Mehraufwand nicht antun.

[Karl H. (kbuchegg)]

be s. schrieb:

> Ich glaube, der TO will das Umgekehrte. 'H' ergibt ein X von 12 und ein
> Y von 1.

Ja, jetzt hab ichs auch kapiert.
Manchmal hat man aber auch Tomaten auf den Augen.

[Torben (Gast)]

Entschuldigung das ich mich so unpräzise Ausgedrückt habe. Richtig ich 
muss Hallo in die XY Koordinaten speichern. Die Werte hab ich ermittelt 
und in eine Exceltabelle abgelegt, deshalb hat deine Antwort mir 
geholfen.

Ich lese die Tabelle und wandle wie in meinem Beispiel Sie in ein 
Package, danach vergleiche ich die "Hallo"-Datei mit der Lockuptable.

Die Switchcase Anweisung finde ich nicht so schon zu pflegen und kostet 
viel Verarbeitungszeit. Ich glaube eine Tabelle dürfte schneller und 
pflegeleichter sein. Leider ist nie etwas in steingemeiselt, deshalb 
finde ich die Idee auch die Tabelle einzulesen echt gut.

[Kleiner Max (Gast)]

Torben schrieb:
> Ich lese die Tabelle und wandle wie in meinem Beispiel Sie in ein
> Package, danach vergleiche ich die "Hallo"-Datei mit der Lockuptable.

Das sieht ein wenig zu kompliziert aus (es geht da eher um die Erzeugung 
von Keys und die Gruppierung von Daten). Außerdem muss der Schlüssel - 
im Gegensatz zu deinem Schlüssel - in einem Lookup nicht eindeutig sein.

Man könnte es auch so ähnlich wie unten implementieren (falls ich das 
Problem richtig verstanden habe).

static class Extensions
{
  public static void ForEach<T>(this IEnumerable<T> value, Action<T> action)
  {
    foreach (T item in value) action(item);
  }
}

class Coordinate
{
  public Coordinate(int x, int y)
  {
    X = x;
    Y = y;
  }

  public Coordinate(string x, string y)
  {
    X = int.Parse(x);
    Y = int.Parse(y);
  }

  public override string ToString() => $"({X}, {Y})";

  public int X { get; }
  public int Y { get; }
}

class CoordinateTable
{
  public CoordinateTable(string path)
  {
    _dict = new Dictionary<char, Coordinate>();
    File.ReadLines(path).ForEach(line => AddTableEntry(line));
  }
  
  public int Count => _dict.Count;

  public Coordinate this[char key] => _dict[key];

  public IEnumerable<Coordinate> GetCoordinates(string s) => s.Select(c => _dict[c]);

  void AddTableEntry(string line)
  {
    if (!string.IsNullOrWhiteSpace(line))
    {
      var tokens = line.Split(Separators, StringSplitOptions.RemoveEmptyEntries);

      // Validieren ...

      _dict.Add(tokens[0][0], new Coordinate(tokens[1], tokens[2]));
    }
  }

  static readonly char[] Separators = { ',', ' ', '\t' };
  readonly Dictionary<char, Coordinate> _dict;
}

class Program
{
  static void Main(string[] args)
  {
    var table = new CoordinateTable("map.txt");
    
    Console.WriteLine(table['b']);
    Console.WriteLine();

    table.GetCoordinates("Hallo").ForEach(Console.WriteLine);

    Console.WriteLine();
  }
}

map.txt

A,    2,    3
B,    8,    2
C,    2, 3000
H,   12,    1
a,   15,    6
b, 1111,   42
c,   12,   99
l,   18,  100
o,  200,  700
0,    9,   23
1,    0,    0

Ausgabe

(1111, 42)

(12, 1)
(15, 6)
(18, 100)
(18, 100)
(200, 700)

Du kannst dir dann auch überlegen, was du machst, wenn der Schlüssel 
nicht vorhanden ist (hier wird eine Ausnahme geworfen, man könnte aber 
z.B. eine [0, 0]-Koordinate zurückgeben).

[Torben (Gast)]

Hallo Kleiner Max,

wow, danke. Ich hab den Code noch nicht ganz verstanden und muss mir das 
genauer zu gemüte führen, damit ich es verstehe. Ich danke Dir für dein 
Bespiel

[nicht"Gast" (Gast)]

Torben schrieb:
> wow, danke. Ich hab den Code noch nicht ganz verstanden und muss mir das
> genauer zu gemüte führen, damit ich es verstehe. Ich danke Dir für dein
> Bespiel

Kein Wunder. Kleiner Max schein aus der Pearl Ecke zu kommen. Was für 
eine furchtbar unübersichtliche Art zu programmieren ^^.

Grüße,