Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch

Hallo,

so habe Fertig!

Das ganze ist nichts anders als den Weg durch ein Labyrinth suchen.
Ich habe einen einfachen Backtracking-Algorithmus (Versuch und Irrtum) mit einem Stack als Ariadnefaden (um wieder herauszufeinden) dafür verwendet.
Er findet nicht den kürzesten Weg, sondern macht unnötig viele Umwege, aber der kürzeste Weg war ja nicht gefragt.

Ich habe das ganze in eine eigen Klasse gesteckt damit es übersichtlicher ist, und habe auch nicht direkt auf dem Button Array gearbeitet, sonder mit einem eigenem, damit lässt sich leicher durch das Labyrinth laufen.

Hier die Methoden im Leveleditor:

C#-Code:

private void canPacmanAccessToolStripMenuItem_Click(object sender, EventArgs e)         {             if (IsAccessable(startPoint[0], startPoint[1], cageField[0], cageField[1]))                 MessageBox.Show("YES! Pacman can access!");             else                 MessageBox.Show("NO! Pacman can NOT access.");         }         private bool IsAccessable(int sourceX, int sourceY, int destX, int destY)         {             // Labyrinth aus dem Button Array erzugen             Pathfinder.Field[,] labyrinth = new Pathfinder.Field[11,8];             for (int i = 0; i < 11; i++)             {                 for (int j = 0; j < 8; j++)                 {                     Pathfinder.Field curField = new Pathfinder.Field();                     int curPacmanField_X = i == 0 ? 1 : i * 2 + 1;                     int curPacmanField_Y = j == 0 ? 1 : j * 2 + 1;                     // Feld oben geschlossen?                     if (pacmanField[curPacmanField_X, curPacmanField_Y - 1].BackColor == colorClosed)                         curField.WallAbove = true;                     // Feld rechts geschlossen?                     if (pacmanField[curPacmanField_X + 1, curPacmanField_Y].BackColor == colorClosed)                         curField.WallRight = true;                     // Feld unten geschlossen?                     if (pacmanField[curPacmanField_X, curPacmanField_Y + 1].BackColor == colorClosed)                         curField.WallBelow = true;                     // Feld links geschlossen?                     if (pacmanField[curPacmanField_X - 1, curPacmanField_Y].BackColor == colorClosed)                         curField.WallLeft = true;                     labyrinth[i, j] = curField;                 }             }             Pathfinder pathfinder = new Pathfinder(labyrinth, 11, 8);             return pathfinder.CanReach(ToRealIndex(sourceX), ToRealIndex(sourceY), ToRealIndex(destX), ToRealIndex(destY));         }         private int ToRealIndex(int index)         {             return (int)(index / 2);         }

Und meine Pathfinder-Klasse, die den eigentlichen Weg findet:

C#-Code:

using System; using System.Collections.Generic; namespace pacman {     class Pathfinder     {         /// <summary>         /// Ein Feld im Labyrinth         /// </summary>         public class Field         {             public bool WallAbove { get; set; }             public bool WallRight { get; set; }             public bool WallBelow { get; set; }             public bool WallLeft { get; set; }             public bool visited { get; set; }         }         /// <summary>         /// Ein Punkt im Labyrinth, für den "Faden" benötigt         /// </summary>         class Point         {             public int X { get; set; }             public int Y { get; set; }             public Point(int x, int y)             {                 X = x;                 Y = y;             }         }         /// <summary>         /// Das Labyrinth als 2D-Array         /// </summary>         private Field[,] labyrinth;         private int rows;         private int colums;         public Pathfinder(Field[,] labyrinth, int rows, int colums)         {             if (labyrinth.Length < 4 || labyrinth == null)                 throw new ArgumentException("No valid labyrinth");             if (rows < 2 || colums < 2)                 throw new ArgumentException("Invalid row or colums count.");             this.labyrinth = labyrinth;             this.rows = rows - 1;             this.colums = colums - 1;         }         private bool FieldAlreadyVisited(int x, int y)         {             // Oben raus, unten rein, rechts raus, links rein umd umgekehrt ;)             if (x < 0)                 x = rows;             if (x > rows)                 x = 0;             if (y < 0)                 y = colums;             if (y > colums)                 y = 0;             return labyrinth[x, y].visited;         }         public bool CanReach(int startX, int startY, int targetX, int targetY)         {             if (startX > rows || startY > colums || startX < 0 || startY < 0)                 throw new ArgumentException("No valid start point.");             if (targetX > rows || targetY > colums || targetX < 0 || targetY < 0)                 throw new ArgumentException("No valid target point.");             if (startX == targetX && startY == targetY)                 throw new ArgumentException("Start and target are equal.");             // Der Ariadnefaden um im Labyrinth wieder (aus Sackgasse) herauszufinden             Stack<Point> ariadne = new Stack<Point>();             // Startwerte setzten             int curFieldX = startX;             int curFieldY = startY;             while (true)             {                 // Ziel schon erreicht?                 if (curFieldX == targetX && curFieldY == targetY)                     return true;                 // In das nächte Feld gehen, wenn keine Wand im Weg oder nicht schon besucht                 if (!labyrinth[curFieldX, curFieldY].WallAbove && !FieldAlreadyVisited(curFieldX, curFieldY - 1))                 {                     if (curFieldY - 1 < 0)                         curFieldY = colums;                     else                         curFieldY--;                 }                 else if (!labyrinth[curFieldX, curFieldY].WallRight && !FieldAlreadyVisited(curFieldX + 1, curFieldY))                 {                     if (curFieldX + 1 > rows)                         curFieldX = 0;                     else                         curFieldX++;                 }                 else if (!labyrinth[curFieldX, curFieldY].WallBelow && !FieldAlreadyVisited(curFieldX, curFieldY +1 ))                 {                     if (curFieldY + 1 > colums)                         curFieldY = 0;                     else                         curFieldY++;                 }                 else if (!labyrinth[curFieldX, curFieldY].WallLeft && !FieldAlreadyVisited(curFieldX - 1, curFieldY))                 {                     if (curFieldX - 1 < 0)                         curFieldX = rows;                     else                         curFieldX--;                 }                 else // Sackgasse                 {                     // Wieder am Startpunkt angelangt oder eingesperrt -> Kein Weg                     if (ariadne.Count == 0)                         return false;                     // Ein Schritt zurück                     Point prev = ariadne.Pop();                     curFieldX = prev.X;                     curFieldY = prev.Y;                     continue;                 }                 // Aktuelles Feld als besucht markieren                 labyrinth[curFieldX, curFieldY].visited = true;                 // "Faden verlängern"                 ariadne.Push(new Point(curFieldX, curFieldY));             }         }     } }

Hier mein Vorschlag:

C#-Code:

using System; using System.Collections.Generic; class AchtDamen {     const int brettGröße = 8;     const int feldzahl = brettGröße * brettGröße;     static void Main(string[] args)     {         int[] angriffszahlen = new int[brettGröße * brettGröße];         int aktuellesFeld = 0;         Stack<int> schritte = new Stack<int>();         while (true)         {             if (aktuellesFeld < feldzahl)             {                 if (angriffszahlen[aktuellesFeld] == 0)                 {                     FürAlleErreichbarenFelder(aktuellesFeld % brettGröße, aktuellesFeld / brettGröße,                         (x, y) =>                         {                             angriffszahlen[x + y * brettGröße]++;                         });                     schritte.Push(aktuellesFeld);                     if (schritte.Count == 8)                         break;                     aktuellesFeld = 0;                 }                 else                     aktuellesFeld++;                 continue;             }             if (schritte.Count > 0)             {                 aktuellesFeld = schritte.Pop();                 FürAlleErreichbarenFelder(aktuellesFeld % brettGröße, aktuellesFeld / brettGröße,                     (x, y) =>                     {                         angriffszahlen[x + y * brettGröße]--;                     });                 aktuellesFeld++;                 continue;             }             Console.WriteLine("Keine Lösung gefunden!");             Console.ReadLine();             return;         }         char[] ausgabe = new char[feldzahl];         for (int i = 0; i < ausgabe.Length; i++)             ausgabe[i] = (((i + i / brettGröße) & 1) == 0) ? ' ' : 'ˆ';         foreach (int schritt in schritte)         {             ausgabe[schritt] = 'Q';         }         Console.WriteLine("##########");         for (int y = 0; y < brettGröße; y++)         {             Console.Write("#");             for (int x = 0; x < brettGröße; x++)                 Console.Write(ausgabe[x + y * brettGröße]);             Console.WriteLine("#");         }         Console.WriteLine("##########");         Console.ReadLine();     }     private static void FürAlleErreichbarenFelder(int xStart, int yStart, Action<int, int> aktion)     {         aktion(xStart, yStart);         int x, y;         for (x = 0; x < brettGröße; x++)//quer         {             if (x != xStart)                 aktion(x, yStart);         }         for (y = 0; y < brettGröße; y++)//senkrecht         {             if (y != yStart)                 aktion(xStart, y);         }         x = xStart; y = yStart;//links oben         while (x > 0 && y > 0)             aktion(--x, --y);         x = xStart; y = yStart;//rechts unten         while (x < brettGröße - 1 && y < brettGröße - 1)             aktion(++x, ++y);         x = xStart; y = yStart;//links unten         while (x > 0 && y < brettGröße - 1)             aktion(--x, ++y);         x = xStart; y = yStart;//rechts oben         while (x < brettGröße - 1 && y > 0)             aktion(++x, --y);     } }

Ich hab auch schon eine aufgabe der Kategorie

Zitat von Scavanger:

Kopf -> Tisch!

(Obwohl: Diesesmal ist es nur halb so lang^^)

Im Anhang ist eine .net exe. Es soll eine Eingabe gefunden werden, die zu folgender Ausgabe führt: richtig

Wie letztes mal:
1.) Es ist nicht ganz so offensichtlich, wie es den Anschein hat.
2.) Es gibt eine Lösung!!!!

Wie man unschwer erkennen kann, ist es diesesmal sehr wenig Code, also auch weniger Platz um etwas zu verstecken. Wissen um die Eigenheiten der Clr und Msil sollte zur Lösung sehr nützlich sein.

Also: Fröhliches "wtf?!"

(Wenn jemand sich wundert, kann er gerne seinen Kommentar abgeben )

Yeah! Ein echtes wtf!

Wie viel verwirrung ein par Zeilen Code stiften können.

Lösung:

Code: 1: 1337!

Wie ich darauf gekommen bin:

Das ulong Wert 15481342765760561 was damit zu tun hat und wird war klar (durch das Sequenzielle Layout der Klasse und dem Hack mit dem IL Keyword newslot in der ToString-Methode, überdeckt der Wert des Feldes, dessen Bytefolge dann als String ausgewertet wird, scheinbar das im Stack), also hab ich einfach mal die Bitfolge des Wertes in einen String konvertiert

C#-Code:

string s = Encoding.Unicode.GetString(BitConverter.GetBytes(15481342765760561ul));

Das ist aber nicht die Lösung. Irgendwann hab ich dann den Speicherbereich des Prozesses ausgelesen und festgestellt das hinter dem 1337 noch ein "!" steht.
So wie ich das verstehe überschriebt der Bytewert des Feldes den Speicherbereich des Strings nicht ganz und das "!" des Strings (wtf?!) bleibt erhalten.

@Floste:
Ich glaub Langsam hab ich hab ich deine "IL-Masche" raus.

P.S. Der GC hat damit nichts zu tun, ich hab mal spaßeshalber das "GC.KeepAlive" raus gepachet: Das Ergebnis bleibt das gleiche. Das "wtf?!.ToString()" bleibt natürlich.

Erstaunlich, dass ihr beiden jeweils um 0:24 bzw 25 antwortet, und beide richtig^^
Und Zommis Frage:

Zitat:

Warum ist das GC.KeepAlive nötig? Würde er sonst nicht internalisieren?

wurde auchnoch beantwortet, bevor sie gestellt wurde

Habt ihr euch wirklich nicht abgesproochen?

Ich hab mich wenigstens gut amüsiert heute moren, aber genug der String-Theorie, der nächste ist dran!

Hier mal mein Vorschlag (Miller-Rabin Methode):

Meine Klasse:

C#-Code:

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:

C#-Code:

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");                 }             }         }

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 :)

Hehe, ok - werd ich mir merken :P

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! :)

Mach doch bitte noch eine Standardintialisierung hinzu , bzw. zufälliges Befüllen der Felder. Eventuell noch die Grenzen etwas erhöhen - 12x12 ist mir irgendwie zu klein :P

Ich hab mir mal ne Aufgabe ausgedacht. Sie ist auf jeden Fall lösbar und das mit einer überschaubaren Zahl an Codezeilen. Ziel ist es, eigenen Code einzufügen, sodass Gelöst auf der Console ausgegeben wird.

C#-Code:

using System; using System.Runtime.InteropServices; class Program {     static void Main(string[] args)     {         string ShouldBe = "This String";         string IsAtStart= "R4nd0om data or somthing nobody cares about....";         IntPtr buffer = Marshal.StringToHGlobalUni(IsAtStart);         int hash = ShouldBe.GetHashCode();//Doppelte Prüfung hält besser         WriteToBuffer(buffer, ShouldBe);         string newString = Marshal.PtrToStringUni(buffer);         Marshal.FreeHGlobal(buffer);         if (newString == ShouldBe && newString.GetHashCode() == hash)             Console.WriteLine("Gelöst");         else             Console.WriteLine("Nicht gelöst, in \"buffer\" steht: "+newString);         Console.ReadLine();     }     //Hinter dem Ende dieses Kommentars darf der Code geändert werden.     //Der nachfolgende vorgegebene Code ist als Hinweis gedacht und darf gelöscht/bearbeitet werden.     //Folgende Ausdrücke dürfen dabei NICHT verwendet werden:     //unsafe, Marshal, DllImport, extern, Reflection, GetType, typeof, Type, Program, Console, Main     [StructLayout(LayoutKind.Explicit)]     struct SomeStruct     {         //TODO     }         //TODO     private static void WriteToBuffer(IntPtr buffer, string ShouldBe)     {         //TODO     } }

Hi,

vollständigkeitshalber noch das, woran Flotse wohl eher dachte:

C#-Code:

[StructLayout(LayoutKind.Explicit)]     struct SomeStruct     {         [FieldOffset(0)]         public IntPtrContainer A;         [FieldOffset(0)]         public CharacterContainer B;     }     [StructLayout(LayoutKind.Sequential)]     class IntPtrContainer     {         public IntPtr IntPtr;     }     [StructLayout(LayoutKind.Sequential)]     class CharacterContainer     {         public SingleCharacter SingleCharacter;     }     class SingleCharacter     {         public char Char;     }     private static void WriteToBuffer(IntPtr buffer, string ShouldBe)     {         for (int i = 0; i < ShouldBe.Length; i++)         {             WriteCharacter(buffer + i * sizeof(char), ShouldBe[i]);         }         WriteCharacter(buffer + ShouldBe.Length * sizeof(char), '\u0000');     }     private static void WriteCharacter(IntPtr buffer, char character)     {         SomeStruct s = new SomeStruct();         s.A = new IntPtrContainer() {IntPtr = buffer - IntPtr.Size}; // skip SyncBlock of object         s.B.SingleCharacter.Char = character;     }

abermals beste Grüße
zommi

Hallo zusammen,

Da hier seit langem nichts mehr los ist, würde ich gerne eine Aufgabe stellen.

Zitat:

Erstelle einen Algorithmus welches den Ostersonntag eines Jahres ermittelt.

Wem das zu einfach war kann ja mal versuchen noch folgende Tage zu ermitteln:

Code: 1: 2: 3: 4: 5: 6: KarFreitag OsterMontag ChristiHimmelfahrt PfingstSonntag PfingstMontag Fronleichnam

Viel spaß beim lösen!

Hier meine Lösung zu herbivores Aufgabe:

C#-Code:

public class RemoveDublicatesComparer : IEqualityComparer<string> {     RemoveDublicates.RemoveDuplicatesOptions options = new RemoveDublicates.RemoveDuplicatesOptions();     public RemoveDublicatesComparer(RemoveDublicates.RemoveDuplicatesOptions options)     {         this.options = options;     }     public bool Equals(string x, string y)     {         string tempx = "";         string tempy = "";         bool isMatch = false;         isMatch = Regex.IsMatch(x, y);         if(options.HasFlag(RemoveDublicates.RemoveDuplicatesOptions.IgnoreCase) && !isMatch)         {             isMatch = Regex.IsMatch(x, y, RegexOptions.IgnoreCase);         }         if (options.HasFlag(RemoveDublicates.RemoveDuplicatesOptions.IgnoreLeadingTrailingSpace) && !isMatch)         {             tempx = Regex.Replace(x, "^[ \t]+|[ \t]+$", "");             tempy = Regex.Replace(y, "^[ \t]+|[ \t]+$", "");             isMatch = Regex.IsMatch(tempx, tempy);         }         if (options.HasFlag(RemoveDublicates.RemoveDuplicatesOptions.IgnoreSpaceChange) && !isMatch)         {             tempx = Regex.Replace(x, "[ \t]*", " ");             tempy = Regex.Replace(y, "[ \t]*", " ");             isMatch = Regex.IsMatch(tempx, tempy);         }         if (options.HasFlag(RemoveDublicates.RemoveDuplicatesOptions.IgnoreAllSpace) && !isMatch)         {             tempx = Regex.Replace(x, "[ \t]*", "");             tempy = Regex.Replace(y, "[ \t]*", "");             isMatch = Regex.IsMatch(tempx, tempy);         }         return isMatch;     }     public int GetHashCode(string obj)     {         throw new NotImplementedException();     } } public class RemoveDublicates {     [Flags]     public enum RemoveDuplicatesOptions     {         IgnoreCase = 0x01,         IgnoreLeadingTrailingSpace = 0x02,         IgnoreSpaceChange = 0x04,         IgnoreAllSpace = 0x08,         RemoveBlankLines = 0x10,         KeepBlankLines = 0x20     }     public static List<String> RemoveDuplicates(String[] lines, RemoveDuplicatesOptions options)     {         List<String> resultStringList = new List<string>();         RemoveDublicatesComparer comparer = new RemoveDublicatesComparer(options);         foreach (string line in lines)         {             if (options.HasFlag(RemoveDublicates.RemoveDuplicatesOptions.RemoveBlankLines) && comparer.Equals("", line))                 continue;             if (options.HasFlag(RemoveDublicates.RemoveDuplicatesOptions.KeepBlankLines) && comparer.Equals("", line))             {                 resultStringList.Add(line);                 continue;             }             if (!resultStringList.Contains(line, comparer))             {                 resultStringList.Add(line);             }         }         return resultStringList;     } }

Sehr intressante Aufgabe. Habe viel dabei gelernt. Zerreisst mich bitte in der Luft, damit ich noch mehr lernen kann (Stichwort: Coding Horror)

Viele Grüße


PS: Das komplette Test-Programm gibts auf Anfrage

edit: Ok, Datei angehängt.

Hallo Alf Ator,

die Richtung ist schon mal nicht schlecht. Gut gefällt mir, dass du durch den Comparer die Komplexität geschickt verteilt hast. Leider habe ich noch ein paar Fehler gefunden. Deshalb sehe ich die die Aufgabe noch nicht als gelöst an.

Bei Regex.IsMatch(x, y) wird x als Regex-Pattern interpretiert. Eine Eingabezeile muss aber kein gültiger Pattern sein. Dann knallt es. Aber selbst wenn die Zeile ein gültiger Pattern ist, sagt das matchen nicht, ob die Zeilen gleich sind. Wäre x z.B. ".*", dann würde das auf beliebige y passen. String.Compare wäre wohl eher, was du suchst.

Auch bei den Regex-Operationen danach, stimmt nicht alles. Regex.Replace(x, "[ \t]*", " ") geht zwar in die richtige Richtung, aber bei einem Pattern, der durch * auch die Länge null akzeptiert, muss man immer aufpassen, weil er an jeder Stelle passt, auch da, wo keine Leerzeichen sind. Dadurch wäre auch "Hallo World" und "HalloWorld" gleich.

Hast du es wirklich mal mit einer Million Zeilen probiert? Sowie ich das sehe, müsste das ziemlich lange dauern. Wenn es mit einer Million doch zügig geht, probier es mal mit 10 Millionen Zeilen. Ich vermute, dass wird nicht ca. 10 sondern ca. 100 Mal solange dauern. Das liegt daran, dass List.Contains eine O(n)-Operation ist, die jedes Mal innerhalb einer Schleife über n Elemente aufgerufen wird. Das ergibt am Ende O(n^2). Mit dem Tipp im PS kommt man an eine Contains-Operation, die einen Aufwand von nur O(1) hat. Damit erreicht man am Ende das gewünschte O(n).

Und leider rächt sich sogar der an sich elegante Comparer, weil er für jedes Zeilenpaar aufgerufen wird. Damit wird jede einzelne Zeile n-fach neu aufbereitet (also z.B. die Leerzeichen entfernt). Es wäre schöner, wenn jede Zeile nur einmal aufbereitet werden müsste (und das kann man tatsächlich realisieren). Den Comparer ersetzt mal also besser durch eine Zeilenaufbereitungsmethode.

Dass du fast überall Dublicates statt Duplicates geschrieben hast, wäre zu verschmerzen gewesen. :-)

Also auf zu einem weiteren oder neuen Versuch. Von dir oder von jemand anderem.

herbivore

Hallo Alf Ator,

du bist wieder näher dran. Und darüber, dass die Blankline-Abfragen in dem Fall, dass eine Leerzeile ein oder mehrere Spaces enthält und zusätzlich zu einem Blankline-Flag nur das Flag IgnoreSpaceChange gesetzt ist, nicht richtig funktionieren, weil ProcessString für diese Zeilen (in sich korrekt, aber für die Abfrage nunmal unpassend) " " und nicht "" liefert, hätte ich sogar hinweggesehen.

Doch was nützt KeepBlankLines, wenn du dabei HashSet.Add verwendest, welche doppelte Zeilen eben nicht doppelt hinzufügt? Hier bräuchtest du List.Add.

Die größten Auswirkungen hat aber der Fehler, dass du HashSet.ToList zurückgibst, denn darin sind ja (an sich korrekt, aber für die Rückgabe nunmal unpassend) die aufbereiteten Zeilen und nicht die Originalzeilen. Da wundert mich schon ein bisschen, dass das beim Testen nicht aufgefallen ist. Meiner Ansicht nach brauchst du eine Liste und ein Hashset.

Dass du eine Zeile immer noch bis zu dreimal aufbereitest, tut der Linearität zwar keinen Abbruch (konstanter Faktor). Schöner wärs aber, wenn du das vermeiden würdest. Und tempx kannst du dir eigentlich komplett sparen. Spätestens da sind wir aber endgültig bei den Stilfragen angekommen.

Im Sinne des Dazulernens sind solche Iterationen vermutlich nicht schlecht. Dadurch steigt allerdings die Gefahr, dass dir doch noch jemand zuvorkommt. Auf die Idee, dass man durch diese Aufgabe viel lernen kann, sind bestimmt schon andere gekommen. :-)

herbivore

Hallo Alf Ator,

Zitat:

Ist " " eine Blankline? Und wie schauts mit "\t" aus oder " \t \t";

Sind alles Blanklines, wenn und nur wenn mindestens eine der Space-Optionen gesetzt ist. Was unter welchen Umständen als Blankline betrachtet werden soll, steht in der Aufgabe. :-)

Zitat:

Hier habe ich mich für den einfachsten Weg entschieden und definiert das nur "" = Blankline ist.

Nö, da du vor dem Abfragen auf "" die Zeile aufbereitest (ProcessLine), wird auch bei dir (bis auf die von mir beschriebene Ausnahme vollkommen korrekt) viel mehr als nur "" als Blankline betrachtet.

Zitat:

Das würde aber die Reihenfolge durcheinander bringen.

Wie schon gesagt, brauchst du wohl sowohl eine Liste als auch ein HashSet. Die Liste um die zu übernehmenden Zeilen zu sammeln und das HashSet für die Prüfung auf doppelte/mehrfache Zeilen.

Zitat:

In der Form, wie er als erstes aufgefunden wurde?

Ja, und genau so steht es auch in der Aufgabe. :-)

Zitat:

Das ist mir natürlich aufgefallen.

Du solltest eine Lösung nur dann posten, wenn du selber davon ausgehst, dass sie korrekt ist.

herbivore

Hallo Alf Ator,

Zitat:

Diesmal passt alles

fast alles. :-) Die Behandlung von BlankLines stimmt immer noch nicht ganz. Wenn z.B. keine Space-Option gesetzt ist, wird eine Zeile, die von vornherein nur ein einzelnes Blank enthält, fälschlicherweise trotzdem als Leerzeile erkannt. Statt " " in der Abfrage zu berücksichtigen, wäre es aus meiner Sicht eine korrekte Lösung, wenn du in ProcessString am Ende des Then-Teil der Abfrage auf IgnoreSpaceChange abfragst, ob das Ergebnis ein einzelnes Leerzeichen ist und wenn ja, x auf den leeren String setzt. Also

C#-Code:

if (x == " ") {    x = ""; }

Ich akzeptiere die Lösung trotzdem als korrekt. Du bist dran, die nächste Aufgabe zu stellen.

herbivore