myCSharp.de - DIE C# und .NET Community
Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 
 | Suche | FAQ

» Hauptmenü
myCSharp.de
» Startseite
» Forum
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Suche
» Regeln
» Wie poste ich richtig?
» Forum-FAQ

Mitglieder
» Liste / Suche
» Wer ist wo online?

Ressourcen
» openbook: Visual C#
» openbook: OO
» Microsoft Docs

Team
» Kontakt
» Übersicht
» Wir über uns

» myCSharp.de Diskussionsforum
Du befindest Dich hier: Community-Index » Diskussionsforum » Gemeinschaft » Smalltalk » Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch
Letzter Beitrag | Erster ungelesener Beitrag Druckvorschau | Thema zu Favoriten hinzufügen

Seiten (19): [1] 2 3 4 5 nächste » ... letzte » Antwort erstellen
Zum Ende der Seite springen  

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

 
Autor
Beitrag « Vorheriges Thema | Nächstes Thema »
myCSharp.de
Moderationshinweis von herbivore (18.01.2010 10:01):

Bitte beachtet folgenden Hinweise und Regeln:

So ein Thread erfordert Disziplin! Bitte nur Aufgaben und Lösungen posten! Keine Kommentare!

Denn wenn zu jeder Lösung 20 Beiträge kommen, die auf irgendwelche Kleinigkeiten hinweisen, die man anders machen könnte oder sogar alles in eine endlose prinzipielle Diskussion über Programmierstil (sagen wir z.B. über den Gebrauch von goto) abgleitet, wird der Thread vollkommen unübersichtlich. Also bleibt streng bei der Sache. Eine Aufgabe gilt als gelöst, wenn der Code das vorgegebene Problem löst, egal wie wie gut oder schlecht der Programmierstil ist.

Postet nur eine Lösung, wenn ihr schon eine neue Aufgabe in petto habt. Nach 24 Stunden ohne neue Aufgabe durch den ersten, der die Aufgabe gelöst hat, darf auch jemand anders die neue Aufgabe stellen.

Bitte postet nur Aufgaben zur Unterhaltung der anderen und nicht welche zu eurem Vorteil. Die Aufgaben sollten in nicht mehr als 50 Zeilen gelöst werden können.

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

Schreibt mir (herbivore) bitte eine PM, wenn euch noch was einfällt, das geregelt sein sollte.



Hier noch eine Liste der bisher gespielten Aufgaben. Herzlichen Dank an m0rius, der sich diese Mühe - für alle Aufgaben bis zum 1.6.2011 - gemacht hat. Links auf spätere Aufgaben und Lösungen wurden von verschiedenen Moderatoren ergänzt.
  1.  Zeichen-Pyramide gelöst von dN!3L
  2.  Römische Zifferndarstellung gelöst von edsplash
  3.  Sierpinski-Dreieck auf der Konsole ausgeben gelöst von michlG
  4.  Tromino Tiling Algorithmus implementieren gelöst von zommi
  5.  Berechnung der Quadratzahl ohne Verwendung von * und / gelöst von Corpsegrinder
  6.  Rekursive Implementation der Russian Peasant Multiplication / Ancient Egyptian Multiplication gelöst von der-schlingel
  7.  Iterativer Durchlauf eines Binärbaums in Inorder-Reihenfolge gelöst von herbivore
  8.  Iterative Lösung für die "Türme von Hanoi" gelöst von dechavue
  9.  Iterative Implementierung des Quicksort-Sortieralgorithmus' gelöst von F.Z.
  10.  Pascal'sches Dreieck generieren gelöst von winSharp93
  11.  Algorithmus zur Primfaktorzerlegung implementieren gelöst von Uwe81
  12.  Test eines Integers auf Zweierpotenz gelöst von herbivore
  13.  Erweiterter euklidischer Algorithmus (rekursiv oder iterativ) gelöst von F.Z.
  14.  Erweiterter euklidischer Algorithmus (iterativ) gelöst von LuckyGeorge
  15.  Lückenlosen Kreis auf der Konsole zeichnen gelöst von MarsStein
  16.  Mastermind-Zwischenschritt-Bewertung gelöst von m0rius
  17.  Schiffe-Versenken Spielfeldgenerierung gelöst von Floste
  18.  Rectangle Invaders gelöst von MarsStein
  19.  Queue ohne Collections-Namespaces implementieren gelöst von Corpsegrinder
  20.  Listenklasse als binären Differenzbaum implementieren gelöst von herbivore
  21.  SyncQueue<T> erweitern: Enqueue blockiert bei voller Queue gelöst von Corpsegrinder
  22.  Eigene, threadsafe Matrix-Klasse implementieren gelöst von Floste
  23.  Berechnung der TCP/IP-Checksumme über ein Array gelöst von markus111
  24.  Sinuskurve auf der Konsole ausgeben gelöst von m0rius
  25.  Glückliche Zahlen berechnen gelöst von Kaji
  26.  Liste von Strings sortieren und ohne GUI-Block in einer ListBox anzeigen gelöst von edsplash
  27.  Bijektives (eineindeutiges) IMap-Objekt erstellen gelöst von inflames2k
  28.  Interpreter bzw. Parser für mathematische Formeln entwickeln gelöst von MarsStein
  29.  Galton-Brett auf der Konsole gelöst von talla
  30.  Umsetzung eines gegebenen syntaktischen Konstrukts in C# möglich? gelöst von Corpsegrinder
  31.  List<T> um FoldLeft() erweitern gelöst von herbivore
  32.  Baum depth-first in-order iterativ durchlaufen gelöst von Tarion
  33.  Russisch Roulette gelöst von dN!3L
  34.  Abstand von Zahlenzwillingen in einer Auflistung natürlicher Zahlen gelöst von herbivore
  35.  Zahlenfolgen möglichst kompakt darstellen gelöst von JAck30lena
  36.  Conway's Game of Life gelöst von MarsStein
  37.  Wegfindung im Irrgarten gelöst von edsplash
  38.  Pi mit dem Monte-Carlo-Algorithmus approximieren gelöst von prakti08
  39.  Gültige Lösung für gegebenes Sudoku ermitteln gelöst von Campac68
  40.  Parser entwickeln gelöst von MarsStein
  41.  Bit-Arithmetik zum Indizieren mehrerer Werte gelöst von zommi
  42.  Größte, nicht aus gegebenen Zahlen zusammensetzbare Zahl ermitteln gelöst von Floste
  43.  ISharpPixelShader — Programm zur Erzeugung von Bildern mit C# gelöst von dN!3L
  44.  Left Outer Join einer flüchtigen, beliebig großen Enumeration gelöst von gfoidl
  45.  Methode verändern, sodass Tests bestanden werden gelöst von Lennart
  46.  Erweiterungsmethoden-Knobelei gelöst von Corpsegrinder
  47.  Kleinstes gemeinsames Vielfache mehrerer Zahlen ermitteln gelöst von zommi
  48.  CLR-Internas: unsafe-Pointer-Arithmetik für SubArray-Binding gelöst von Floste
  49.  Kniffel-Spiel: mögliche Ergebnis-Punktzahlen für gegebenen Wurf ermitteln gelöst von TheBrainiac
  50.  Einfachen Kompressions-Algorithmus entwickeln gelöst von herbivore
  51.  Polygonzug auf Offenheit überprüfen gelöst von Floste
  52.  Alle Zahlenkombinationen aus {1, 2, 3, 4, 5, 6, 7, 8, 9} ermitteln gelöst von gfoidl
  53.  Zahlenrätsel: Ich denke an 2 Zahlen ... gelöst von Spontifixus
  54.  Lokalsierten Texteditor mit den Befehlen Cut, Copy, Paste, Undo, Redo in XAML umsetzen gelöst von Spontifixus
  55.  Eigenen Cache mit Schlüssel-Zugriff erstellen gelöst von gfoidl
  56.  Code ohne unsafe-Schlüsselwort oder Marshal-Klasse ergänzen gelöst von zommi
  57.  Kollisionsfindung für Hashfunktion implementieren gelöst von Xander
  58.  Wochentag zu gegebenem Datum berechnen gelöst von inflames2k
  59.  Eigene Liste ohne Collections-Namespaces implementieren gelöst von winSharp93
  60.  Eigene Liste um Reverse()-Methode ergänzen gelöst von MarsStein
  61.  Prinzip der Kapselung in .NET aushebeln gelöst von Scavanger
  62.  Programm zum Feuern von Mitarbeitern manipulieren gelöst von zommi
  63.  Geheimen Text aus .NET-Applikation entschlüsseln gelöst von Joetempes
  64.  Anwendung dazu bringen, "korrekt" auszugeben gelöst von Scavanger
  65.  Lösungsstrategie für Stapel-Kartentrick implementieren gelöst von Daniel B.
  66.  Leveleditor: Zielpunkt vom Startpunkt aus erreichbar? gelöst von Scavanger
  67.  Iterative Lösung für das 8-Damen-Problem gelöst von Floste
  68.  Konsolenanwendung dazu bringen, "richtig" auszugeben gelöst von Scavanger
  69.  Probabilistischen Algorithmus zur Primzahlfindung implementieren gelöst von Daniel B.
  70.  Conway's Game of Life mit grafischer Ausgabe gelöst von Sekkiy
  71.  Konsolenanwendunganwendung so ergänzen, dass "Gelöst" ausgegeben wird gelöst von zommi
  72.  string-search Algorithmus á la Boyer-Moore — gelöst von niemand
  73.  Ostersonntag eines Jahres ermitteln gelöst von ProGamer
  74.  Doppelte Zeilen entfernen gelöst von Alf Ator
  75.  Ship & Asteroid gelöst von Daniel B.
  76.  4 Grundrechnungsarten mit Binärzahlen gelöst von stes
  77.  StringHider und -Finder gelöst von myUnderTakeR
  78.  Anzahl der Permutationen unter Nebenbedingung gelöst von Daniel B.
  79.  Generischer Binärbaum — gelöst von niemand
  80.  Sichere Nachrichtenübermittlung gelöst von Floste
  81.  Synthesizer mit OpenAL gelöst von Floste
  82.  Ausgabe eines 2D-Arrays, aber schön gelöst von stes
  83.  MouseBall - kleines Ball-Spiel gelöst von Mao
  84.  Keyword-Highlighter gelöst von Alf Ator und  gelöst von herbivore
  85.  Regex-Pattern in normalen Code ausprogrammieren gelöst von dN!3L
  86.  Regex-Pattern mit dem Readable Regular Expressions API aufbauen teilweise gelöst von pdelvo,  eigene Lösung von dN!3L
  87.  Termine im Kalender grafisch anordnen gelöst von herbivore
  88.  Dutch national flag problem gelöst von dN!3L
  89.  Vigenère-Verschlüsselung knacken gelöst von Taipi88
  90.  Permutations-Chiffre knacken gelöst von Scavanger
  91.  Pseudozufallsgenerator in (max.) 1,5 Programmzeilen gelöst von MarsStein
  92.  Erweiterungsmethode für rekursives Durchlaufen eines Baums gelöst von DerKleineTomy
  93.  Nichtdeterministischer Kellerautomat gelöst von DerKleineTomy
  94.  Mandelbrot-Menge zeichnen — ungelöst
  95.  Binärzahlen addieren gelöst von Scavanger
  96.  Zufälliges Element aus einer Auflistung (IEnumerable) mit linearem Aufwand auswählen gelöst von Darth Maim
  97.  Quine gelöst von Quadsoft
  98.  in Zahl verstecktes Wort ermitteln gelöst von Alf Ator
  99.  Zahlen in Zahlworte umwandeln gelöst von jannemann13
  100.  Zahlworte in Zahlen umwandeln — ungelöst
  101.  Code für Generierung eines gegebenen Bildes ermitteln gelöst von Alf Ator
  102.  Schach: Pferd und Rösselsprung gelöst von xxxprod
  103.  FullMatch - Prüfen ob ein Pattern auf einen Text passt (ohne Regex) gelöst von xxxprod
PS: Wenn euch die Aufgaben in diesem Thread nicht reichen: Auf  http://pexforfun.com/, einer Art "automatisiertem Programmierspiel", gibt es noch viele weitere interessante Aufgaben.

Dort bekommt man einen Quellcode-Rahmen angezeigt, den man entsprechend der Aufgabe ausfüllen muss, nur dass die Aufgabe nicht als Text vorgeben ist, sondern man den Code auf Verdacht ändert und sich nach jeder Code-Änderung anzeigen lassen kann, mit welchen Testdaten der White-Box-Testdatengenerator PEX das eigene Programm füttert, welche Ausgabe es daraus errechnet und was das jeweils erwünschte Ergebnis ist. Das Prinzip hat ein bisschen was von Mastermind, wo man auch eine mögliche Lösung ausprobiert und vom Gegenüber Hinweise bekommt, was schon stimmt und was noch nicht.

 
abra_joe
myCSharp.de-Mitglied

Dabei seit: 04.12.2008
Beiträge: 23


abra_joe ist offline

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

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hier soll von nun an ein Programmierspiel gestartet werden.

Es wird eine kleine Aufgabe vorgegeben, die der nachfolgende Poster zu bewältigen hat. Wie er die Problemlösung damit umsetzt, ist egal.
Hauptsache der Code liefert das gewünschte Ergebnis.

Derjenige, der die Aufgabe am schnellsten löst, darf dann eine eigene stellen.

Regeln:
Lediglich kleine Aufgaben, keine "Projekte" wie: Programmiere ein Gästebuch.
Jegliche Quellen müssen angegeben werden. Wer kann, sollte jedoch darauf verzichten.
Ein schön eingerückter Code, sodass es anderen Usern möglich ist, zu sehen, wie man an das Ergebnis gekommen ist.

Also hier mal die erste Aufgabe:

Eine Pyramide soll je nach Benutzereingabe erstellt werden.
Diese Benutzereingabe soll die Basis für die Pyramide sein:
Benutzereingabe "H":


A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA

Viel spaß

Dieser Beitrag wurde 6 mal editiert, zum letzten Mal von abra_joe am 18.01.2010 08:52.

18.01.2010 08:46 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
zommi zommi ist männlich
myCSharp.de-Mitglied

avatar-2617.png


Dabei seit: 14.11.2007
Beiträge: 1.361
Entwicklungsumgebung: VS 2005+2010
Herkunft: Berlin


zommi ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Also ich find die Idee doch nett.

C#-Code:
static void Main(string[] args)
{
    int end = Console.ReadKey().KeyChar - 'A';
    char[] s = new String(' ', end*2+1).ToCharArray();
    Console.Clear();
    for (int c = 0; c <= end; c++)
    {
        s[end + c] = s[end - c] = (char)('A' + c);
        Console.WriteLine(new String(s));
    }
}

//EDIT: DAMN! Die Pyramide ist genau falschrum ! *gruml* :D


Ich find den schon relativ elegant. Vielleicht geht aber noch besser ? (=kürzer, schöner, cooler)

Ich versuch mal was auszudenken (kann aber etwas dauern ;) )

beste Grüße
zommi

Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von zommi am 18.01.2010 09:55.

18.01.2010 09:53 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
dN!3L dN!3L ist männlich
myCSharp.de-Poweruser/ Experte

avatar-2985.png


Dabei seit: 13.08.2004
Beiträge: 2.891


dN!3L ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von zommi:
Vielleicht geht aber noch besser ? (=kürzer, schöner, cooler)

Hehe:

C#-Code:
private static string foo(char target)
{
    return String.Join("\r\n",
             Enumerable
                 .Range(1,target-'A'+1)
                 .Select(count => Enumerable
                     .Range('A',count)
                     .Select(index => (char)index))
                 .Select(sequence => sequence.Concat(sequence.Reverse().Skip(1)))
                 .Select(sequence => "".PadLeft(target-'A'-sequence.Count()/2)+new String(sequence.ToArray()))
                 .ToArray());
}

Gruß,
dN!3L
18.01.2010 10:00 Beiträge des Benutzers | zu Buddylist hinzufügen
dN!3L dN!3L ist männlich
myCSharp.de-Poweruser/ Experte

avatar-2985.png


Dabei seit: 13.08.2004
Beiträge: 2.891


dN!3L ist offline

Römische Zifferndarstellung

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von abra_joe:
dN!3L darf die nächste Aufgabe stellen

Hm... also:

Eine Zahl soll in eine Zeichenkettenrepräsentation überführt werden, die diese Zahl in römischen Ziffern darstellt.
Einschränkungen: Ziffern I bis M. Subtraktionsregel.
Beispiel: 1984 -> MCMLXXXIV
18.01.2010 11:15 Beiträge des Benutzers | zu Buddylist hinzufügen
edsplash edsplash ist männlich
myCSharp.de-Mitglied

avatar-3111.jpg


Dabei seit: 19.04.2008
Beiträge: 390
Entwicklungsumgebung: VS2010


edsplash ist offline Füge edsplash Deiner Kontaktliste hinzu

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

C#-Code:
static void Main(string[] args)
    {
      int originalNumber = 1984;
      StringBuilder romNumber = new StringBuilder();

      Queue<KeyValuePair<string, int>> queue = new Queue<KeyValuePair<string, int>>();
      queue.Enqueue(new KeyValuePair<string, int>("M", 1000));
      queue.Enqueue(new KeyValuePair<string, int>("D", 500));
      queue.Enqueue(new KeyValuePair<string, int>("C", 100));
      queue.Enqueue(new KeyValuePair<string, int>("L", 50));
      queue.Enqueue(new KeyValuePair<string, int>("X", 10));
      queue.Enqueue(new KeyValuePair<string, int>("V", 5));
      queue.Enqueue(new KeyValuePair<string, int>("I", 1));

      foreach (KeyValuePair<string, int> pair in queue)
      {
        int times = (int)Math.Round((double)(originalNumber / pair.Value), 0);
        originalNumber -= pair.Value * times;

        for (int k = 0; k < times; k++)
        {
          romNumber.Append(pair.Key);
        }
      }

      Console.WriteLine(romNumber.ToString());
    }

[edit] Mist, hab ich doch glatt das mit der Subtraktionsregel übersehen

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von edsplash am 18.01.2010 12:31.

18.01.2010 11:50 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
dN!3L dN!3L ist männlich
myCSharp.de-Poweruser/ Experte

avatar-2985.png


Dabei seit: 13.08.2004
Beiträge: 2.891


dN!3L ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top



Zitat von zommi:
//EDIT: DAMN! Die Pyramide ist genau falschrum!

Zitat von edsplash:
[edit] Mist, hab ich doch glatt das mit der Subtraktionsregel übersehen

Hehe, das wäre hier doch der ideale Platz, um mal TDD zu üben.
Der Fragensteller gibt zur Aufgabenstellung ein Interface und einen Test (oder mehrere vor), die bestanden werden müssen... großes Grinsen

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von dN!3L am 18.01.2010 12:36.

18.01.2010 12:35 Beiträge des Benutzers | zu Buddylist hinzufügen
edsplash edsplash ist männlich
myCSharp.de-Mitglied

avatar-3111.jpg


Dabei seit: 19.04.2008
Beiträge: 390
Entwicklungsumgebung: VS2010


edsplash ist offline Füge edsplash Deiner Kontaktliste hinzu

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von dN!3L:

Hehe, das wäre hier doch der ideale Platz, um mal TDD zu üben.

Da kann man sich mal über die Effizienz amüsieren ;) Zwei Aufgaben und zweimal in der ersten Lösung die gepostet wurde ein elementarer Fehler, der mit einer Überprüfung der Aufgabenstellung vor dem Post hätte gesehen werden können.

Nichtsdestotrotz meine endgültige Lösung:

C#-Code:
private static string DecimalToRoman(int originalNumber)
    {
      string romanNumber = string.Empty;

      Dictionary<int, char> digits = new Dictionary<int, char>();
      digits.Add(1000, 'M');
      digits.Add(500, 'D');
      digits.Add(100, 'C');
      digits.Add(50, 'L');
      digits.Add(10, 'X');
      digits.Add(5, 'V');
      digits.Add(1, 'I');

      int[] decades = new int[4];
      decades[0] = originalNumber % 10;
      decades[1] = originalNumber % 100 - decades[0];
      decades[2] = originalNumber % 1000 - decades[1] - decades[0];
      decades[3] = originalNumber % 10000 - decades[2] - decades[1] - decades[0];

      for (int k = 3; k >= 0; k--)
      {
        int decadeValue = decades[k];
        int decadeFloor = (int)Math.Pow(10, k);
        int times = decadeValue / decadeFloor;
        Action standardConvert = () =>
        {
          for (int i = 0; i < times; i++)
            romanNumber += digits[decadeFloor];
        };

        if (times >= 5)
        {
          if (times == 9)
          {
            romanNumber += digits[decadeFloor];
            romanNumber += digits[10 * decadeFloor];
          }
          else
          {
            decadeValue -= 5 * decadeFloor;
            romanNumber += digits[5 * decadeFloor];
            times = decadeValue / decadeFloor;
            standardConvert();
          }
        }
        else
        {
          if (times == 4)
          {
            if (decadeFloor == 1000)
              standardConvert();
            else
            {
              romanNumber += digits[decadeFloor];
              romanNumber += digits[5 * decadeFloor];
            }
          }
          else
            standardConvert();
        }
      }
      return romanNumber;
    }

Wäre wohl mit weniger Code gegangen, aber ist das was mir auf die Schnelle so gelungen ist ;)

EDIT: ujr hat mich auf einen 'kleinen' Bug in meiner Lösung aufmerksam gemacht, welchen ich mittlerweile beseitigt habe. Das alte Beispiel mit dem Fehler wurde durch ein neues ersetzt ;)

Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von edsplash am 19.01.2010 16:57.

18.01.2010 13:54 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
edsplash edsplash ist männlich
myCSharp.de-Mitglied

avatar-3111.jpg


Dabei seit: 19.04.2008
Beiträge: 390
Entwicklungsumgebung: VS2010


edsplash ist offline Füge edsplash Deiner Kontaktliste hinzu

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo Zusammen

Hier meine Aufgabe:

Ziel ist folgendes Konstrukt dynamisch auf der Konsole auszugeben

Code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
#
##
# #
####
#   #
##  ##
# # # #
########
#       #
##      ##
# #     # #
####    ####
#   #   #   #
##  ##  ##  ##
# # # # # # # #
################
#               #
##              ##
# #             # #
####            ####
#   #           #   #
##  ##          ##  ##
# # # #         # # # #
########        ########
#       #       #       #
##      ##      ##      ##
# #     # #     # #     # #
####    ####    ####    ####
#   #   #   #   #   #   #   #
##  ##  ##  ##  ##  ##  ##  ##
# # # # # # # # # # # # # # # #
################################

Die gesetzten Pixel/Buchstaben ergeben sich jeweils aus dem direkt über diesem liegendem Feld und dem links darüberligendem.
Die Linke obere Ecke ist als Ausgangspunkt bekannt.

Viel Spass und Vielen Dank an Floste für den Tipp

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von edsplash am 18.01.2010 19:10.

18.01.2010 19:08 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
michlG michlG ist männlich
myCSharp.de-Poweruser/ Experte

avatar-2909.png


Dabei seit: 26.07.2007
Beiträge: 3.430
Entwicklungsumgebung: VS 2010 PRO
Herkunft: Naturns - Südtirol - Italien


michlG ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo Leute,

hier die Lösung dazu

C#-Code:
    private static void PrintTriangles(int count)
    {
      bool[,] arr = new bool[count,count];
      arr[0, 0] = true;
      Console.WriteLine("#");

      for (int i = 1; i < count; i++)
      {
        arr[i, 0] = true;
        Console.Write("#");
        for (int j = 1; j < count; j++)
        {
          arr[i, j] = arr[i - 1, j] ^ arr[i - 1, j - 1];
          Console.Write(arr[i,j] ? "#" : " ");
        }
        Console.WriteLine();
      }
    }

Einfach PrintTriangles(32) aufrufen dann gibts die geforderte Ausgabe

Die neue Aufgabe folgt gleich

Gruss
Michael
18.01.2010 19:51 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
michlG michlG ist männlich
myCSharp.de-Poweruser/ Experte

avatar-2909.png


Dabei seit: 26.07.2007
Beiträge: 3.430
Entwicklungsumgebung: VS 2010 PRO
Herkunft: Naturns - Südtirol - Italien


michlG ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo,

hier die neue Aufgabe.

Erstellt einen sog. Tromino Tiling Algorithmus.
Der ein 2^n mal 2^n großen Array mit den einzelnen Trominos aufteilt.

Ein Tromino wäre also sowas

Code:
1:
2:
3:
4:
0000
0220
0210
0000

Am Anfang muss ein Loch (1) an einer beliebigen Position gesetzt werden.
Dann wird die ganze Fläche schön mit den Trominos ausgefüllt.
Gestartet wird mit der 2, weiter gehts mit der 3 usw. Am Ende muss es halt schön foll sein.

Am Bild seht ihr wie der Array zu beginn aussieht. Also nur das Loch (1) ist bekannt.
Am Ende muss es dann so wie rechts gezeigt ausgegeben werden

Die Ausgabe sollte in der Konsole sein (wenn sich das Zeug aufgrund der unterschiedlichen Zeichenlänge nicht zusehr verschiebt).

Viel Spass damit

Gruss
Michael

michlG hat dieses Bild (verkleinerte Version) angehängt:
Capture.png
Volle Bildgröße

18.01.2010 20:31 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
trib trib ist männlich
myCSharp.de-Mitglied

Dabei seit: 22.04.2008
Beiträge: 654
Entwicklungsumgebung: C#


trib ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Da ich überhaupt nicht verstanden habe was MichlG mir mit den Trominos sagen wollte, habe ich mal Google konsultiert und eine grafische Erklärung gefunden.
Die wollte ich euch nicht vorenthalten:

 http://oneweb.utc.edu/~Christopher-Mawata/trominos/

Gruß
TriB
19.01.2010 12:00 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Floste
myCSharp.de-Mitglied

avatar-2376.jpg


Dabei seit: 13.06.2007
Beiträge: 1.130
Entwicklungsumgebung: VS 2008
Herkunft: Norddeutschland


Floste ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Ganz schön schwer, wenn man sich selbst was ausdenkt.
Ich hab einfach mal brute force try und error gemacht, braucht ewig für n>=5, aber die in dem bild da sind eh nur n=3:

C#-Code:
public static void Main()
        {
            while (true)
            {
                int xpos, ypos, n;
                do { Console.Write("X="); }
                while (!int.TryParse(Console.ReadLine(), out xpos));
                do Console.Write("Y=");
                while (!int.TryParse(Console.ReadLine(), out ypos));
                do Console.Write("N=");
                while (!int.TryParse(Console.ReadLine(), out n));
                int num = 1 << (byte)n;
                int[,] feld = new int[num, num];
                feld[xpos, ypos] = -1;
                if (!BruteForce(feld, num, 1))
                {
                    Console.WriteLine("Nicht gelöst");
                }
                else
                {
                    for (int y = 0; y < num; y++)
                    {
                        for (int x = 0; x < num; x++)
                        {
                            Console.Write(feld[x, y].ToString().PadRight(3));
                        }
                        Console.WriteLine();
                        Console.WriteLine();
                    }
                }
            }
        }


        private static bool BruteForce(int[,] feld, int num, int tiefe)
        {
            for (int y = 0; y < num; y++)
                for (int x = 0; x < num; x++)
                    if (feld[x, y] == 0)
                    {
                        Point[] points = new Point[3];
                        for (int square = 0; square < 4; square++)
                        {
                            int sx = (square & 1) + x - 1;
                            int sy = ((square & 2) >> 1) + y - 1;
                            for (int ep = 0; ep < 4; ep++)
                            {
                                int i = 0;
                                for (int p = 0; p < 4; p++)
                                {
                                    if (p != ep)
                                        points[i++] = new Point(
                                            (p & 1) + sx,
                                            ((p & 2) >> 1) + sy);
                                    else if (((p & 1) + sx == x) && (((p & 2) >> 1) + sy) == y) goto bad_ep;
                                }
                                if (TrominoTesten(feld, num, tiefe, points)) return true;
                            bad_ep: { }
                            }
                        }
                        return false;
                    }
            return true;
        }

        private static bool TrominoTesten(int[,] feld, int num, int tiefe, IEnumerable<Point> points)
        {
            foreach (Point p in points)
            {
                if (p.X < 0 || p.X >= num) return false;
                if (p.Y < 0 || p.Y >= num) return false;
                if (feld[p.X, p.Y] != 0) return false;
            }
            foreach (Point p in points)
                feld[p.X, p.Y] = tiefe;
            if (BruteForce(feld, num, tiefe+1)) return true;
            foreach (Point p in points)
                    feld[p.X, p.Y] = 0;
            return false;
        }
20.01.2010 12:43 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Th69
myCSharp.de-Poweruser/ Experte

avatar-2578.jpg


Dabei seit: 01.04.2008
Beiträge: 3.308
Entwicklungsumgebung: Visual Studio 2015/17


Th69 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Unter  http://www.projektwoche.jku.at/2004/p4_1.pdf ist sowohl der Beweis als auch ein effizienter Algorithmus für das Tromino-Problem angegeben (2. Problem).
20.01.2010 15:10 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
zommi zommi ist männlich
myCSharp.de-Mitglied

avatar-2617.png


Dabei seit: 14.11.2007
Beiträge: 1.361
Entwicklungsumgebung: VS 2005+2010
Herkunft: Berlin


zommi ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Jea, ich habs!
Hab Floste Programmrahmen als Basis genommen.

C#-Code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace Tromino
{
    class Program
    {
        public static void Main()
        {
            while (true)
            {
                int xpos, ypos, n;
                do { Console.Write("X="); }
                while (!int.TryParse(Console.ReadLine(), out xpos));
                do Console.Write("Y=");
                while (!int.TryParse(Console.ReadLine(), out ypos));
                do Console.Write("N=");
                while (!int.TryParse(Console.ReadLine(), out n));
                int num = 1 << (byte)n;
                int[,] feld = new int[num, num];
                feld[xpos, ypos] = -1;

                globalCount = 0;
                tile(feld, new Point(xpos, ypos));

                char[,] res = renderOutlineOfField(feld);

                res[xpos * 2 + 1, ypos * 2 + 1] = 'X';

                {
                    for (int y = 0; y < res.GetLength(0); y++)
                    {
                        for (int x = 0; x < res.GetLength(1); x++)
                        {
                            Console.Write(res[x, y]);
                        }
                        //Console.WriteLine();
                        Console.WriteLine();
                    }
                }
            }
        }


        static int globalCount = 0;

        private static void tile(int[,] feld, Point hole)
        {
            tile(feld, Point.Empty, hole, new Size(feld.GetLength(0), feld.GetLength(1)));
        }

        // *********************************************************
        // *********************************************************
        // *********************************************************
        // Kern des Algos (gemäß Divide and Conquer)
        private static void tile(int[,] feld, Point fieldStart, Point hole, Size size)
        {
            int trominoSymbol = globalCount++;

            // Rekursionsabbruch bei trivialem Fall (Conquer)
            if (size == new Size(2, 2))
            {
                for (int x = fieldStart.X; x < (fieldStart + size).X; x++)
                    for (int y = fieldStart.Y; y < (fieldStart + size).Y; y++)
                    {
                        if (!(x == hole.X && y == hole.Y))
                        {
                            feld[x, y] = trominoSymbol;
                        }
                    }
                return;
            }

            // Divide-Schritt (in 4 Unterprobleme)
            Size halfSize = new Size(size.Width / 2, size.Height / 2);
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 2; j++)
                {
                    Point subFieldStart = fieldStart + new Size(halfSize.Width * i, halfSize.Height * j);
                    Point newHole = fieldStart + halfSize - new Size(1 - i, 1 - j);
                    if (new Rectangle(subFieldStart, halfSize).Contains(hole))
                    {
                        newHole = hole;
                    }
                    else
                    {
                        feld[newHole.X, newHole.Y] = trominoSymbol;
                    }
                    tile(feld, subFieldStart, newHole, halfSize);
                }
            }
        }
        // *********************************************************
        // *********************************************************
        // *********************************************************


        // Diese Method ist nur Deko, macht was hübsches, ansehliches draus
        static char[,] renderOutlineOfField(int[,] feld)
        {
            char[,] res = new char[feld.GetLength(0) * 2 + 1, feld.GetLength(1) * 2 + 1];
            //rand
            for (int x = 1; x < res.GetLength(0) - 1; x++)
                res[x, 0] = res[x, res.GetLength(1) - 1] = symbols[10];
            for (int y = 1; y < res.GetLength(1) - 1; y++)
                res[0, y] = res[res.GetLength(0) - 1, y] = symbols[5];
            //ecken
            res[0, 0] = symbols[6];
            res[res.GetLength(0) - 1, 0] = symbols[12];
            res[0, res.GetLength(1) - 1] = symbols[3];
            res[res.GetLength(0) - 1, res.GetLength(1) - 1] = symbols[9];

            for (int x = 1; x < res.GetLength(0) - 1; x++)
            {
                for (int y = 1; y < res.GetLength(1) - 1; y++)
                {
                    int selection = 0;
                    if (feld[(x - 1) / 2, (y - 1) / 2] != feld[(x - 0) / 2, (y - 1) / 2])
                        selection |= 1;
                    if (feld[(x - 0) / 2, (y - 1) / 2] != feld[(x - 0) / 2, (y - 0) / 2])
                        selection |= 2;
                    if (feld[(x - 1) / 2, (y - 0) / 2] != feld[(x - 0) / 2, (y - 0) / 2])
                        selection |= 4;
                    if (feld[(x - 1) / 2, (y - 1) / 2] != feld[(x - 1) / 2, (y - 0) / 2])
                        selection |= 8;
                    res[x, y] = symbols[selection];
                }
            }
            return res;
        }

        static char[] symbols = new char[] { ' ', '?', '?', '\u2514', '?', '\u2502', '\u250C', '\u251C', '?', '\u2518', '\u2500', '\u2534', '\u2510', '\u2524', '\u252C', '\u253C' };

    }
}

(benötigt wegen dem Drawing-Namespace nochn Verweis auf System.Drawing)

beste Grüße
zommi

zommi hat dieses Bild (verkleinerte Version) angehängt:
tromino.png
Volle Bildgröße

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von zommi am 20.01.2010 16:26.

20.01.2010 15:45 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Corpsegrinder
myCSharp.de-Mitglied

Dabei seit: 30.01.2007
Beiträge: 401
Entwicklungsumgebung: VS 2008 , .Net 3.5


Corpsegrinder ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Ja dann hau ma die nächste Aufgabe rein :D
20.01.2010 19:42 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
zommi zommi ist männlich
myCSharp.de-Mitglied

avatar-2617.png


Dabei seit: 14.11.2007
Beiträge: 1.361
Entwicklungsumgebung: VS 2005+2010
Herkunft: Berlin


zommi ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Also meine Aufgabe:

programmiere eine einzige Methode f(n) zum Berechnen der Quadratzahl n^2.
Allerdings sind * und / nicht zugelassen. Was als arithmetische Operation zugelassen ist, sind: + und - .
Ahso und lokale/temporäre Variablen sind natürlich auch nich zugelassen ;)

beste Grüße
zommi
20.01.2010 20:18 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Corpsegrinder
myCSharp.de-Mitglied

Dabei seit: 30.01.2007
Beiträge: 401
Entwicklungsumgebung: VS 2008 , .Net 3.5


Corpsegrinder ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von zommi:
Also meine Aufgabe:

programmiere eine einzige Methode f(n) zum Berechnen der Quadratzahl n^2.
Allerdings sind * und / nicht zugelassen. Was als arithmetische Operation zugelassen ist, sind: + und - .
Ahso und lokale/temporäre Variablen sind natürlich auch nich zugelassen ;)

beste Grüße
zommi

Also ich bezweifel, dass es mit nur einer Methode möglich ist ;-) du musst ja irgendwie ne Laufvariable und ne tmp mitgeben. Hab das aber mal in Scala gelöst mit nur "einer" Methode :D

Code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
def square(value: Int) = {
    def sq(value: Int, tmp: Int, count: Int): Int = {
      if(count == 0)
        tmp
      else
        sq(value, tmp + value, count-1)
    }
    sq(value, 0, value)
  }
20.01.2010 20:52 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
zommi zommi ist männlich
myCSharp.de-Mitglied

avatar-2617.png


Dabei seit: 14.11.2007
Beiträge: 1.361
Entwicklungsumgebung: VS 2005+2010
Herkunft: Berlin


zommi ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat:
Also ich bezweifel, dass es mit nur einer Methode möglich ist ;-)

Mit nur einer Methode!
Und mit keiner zusätzlichen Variable.
Und ohneMultiplikation.

cool

beste Grüße
zommi

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von zommi am 20.01.2010 20:58.

20.01.2010 20:57 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Corpsegrinder
myCSharp.de-Mitglied

Dabei seit: 30.01.2007
Beiträge: 401
Entwicklungsumgebung: VS 2008 , .Net 3.5


Corpsegrinder ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Okay... wieder was gelernt... den Weg kannte ich noch nicht :-)

C#-Code:
public static int square(int val)
{
  if (val == 1)
    return 1;
  else
    return val + (val - 1) + square(val - 1);
}

Achso... Quelle:  http://en.wikipedia.org/wiki/Square_(algebra)

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Corpsegrinder am 20.01.2010 21:07.

20.01.2010 21:06 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
zommi zommi ist männlich
myCSharp.de-Mitglied

avatar-2617.png


Dabei seit: 14.11.2007
Beiträge: 1.361
Entwicklungsumgebung: VS 2005+2010
Herkunft: Berlin


zommi ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Jup, perfekt Daumen hoch

(wobei ich bei n=0 die Abbruch-Bedingung gemacht hätte)
Ich lös es noch mit kurzer Erklärung auf:

Berechnung per Rekursion! Wir nutzen aus:

(n+1)² = n² + 2n + 1

Und mit n statt (n+1) ergibt sich dann

n² = (n-1)² + 2*(n-1) + 1
n² = (n-1)² + 2*n - 1
n² = (n-1)² + n + n - 1

Dann noch bei n=0 die Abbruchbedingung mit 0²=0 und fertig ist die Methode.
Als Einzeiler:

C#-Code:
square(int n)
{
     return (n==0)?0:square(n-1) + n + n - 1;
}

beste Grüße
zommi
20.01.2010 21:13 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
zommi zommi ist männlich
myCSharp.de-Mitglied

avatar-2617.png


Dabei seit: 14.11.2007
Beiträge: 1.361
Entwicklungsumgebung: VS 2005+2010
Herkunft: Berlin


zommi ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von Corpsegrinder:
Ja dann hau ma die nächste Aufgabe rein großes Grinsen

großes Grinsen
20.01.2010 21:15 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Corpsegrinder
myCSharp.de-Mitglied

Dabei seit: 30.01.2007
Beiträge: 401
Entwicklungsumgebung: VS 2008 , .Net 3.5


Corpsegrinder ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Jajaja... muss ja erstmal was überlegen...

Eine hübsche Rekursive Implementation der Russian Peasant Multiplication / Ancient Egyptian Multiplication...


Viel Spaß :-D
20.01.2010 21:20 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
der-schlingel der-schlingel ist männlich
myCSharp.de-Mitglied

avatar-3239.jpg


Dabei seit: 13.10.2007
Beiträge: 799
Entwicklungsumgebung: VS 2005/ 2008 Pro
Herkunft: Österreich/Wien


der-schlingel ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

C#-Code:
        static int RussianMultiply(int factor1, int factor2)
        {
            if (factor1 == 0 || factor2 == 0)
                return 0;

            int f1 = (int)Math.Floor((double)factor1 / 2);
            int f2 = factor2 * 2;

            return ( (factor1 % 2 == 0) ? 0 : factor2 ) + RussianMultiply(f1, f2);
        }
20.01.2010 22:26 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Floste
myCSharp.de-Mitglied

avatar-2376.jpg


Dabei seit: 13.06.2007
Beiträge: 1.130
Entwicklungsumgebung: VS 2008
Herkunft: Norddeutschland


Floste ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Geht das nicht *etwas* einfacher?

C#-Code:
int mul(int a,int b)
{
    if(a==0)return 0;
    return (((a&1)==0)?0:b)+mul(a>>1,b<<1);
}

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Floste am 20.01.2010 22:39.

20.01.2010 22:37 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
der-schlingel der-schlingel ist männlich
myCSharp.de-Mitglied

avatar-3239.jpg


Dabei seit: 13.10.2007
Beiträge: 799
Entwicklungsumgebung: VS 2005/ 2008 Pro
Herkunft: Österreich/Wien


der-schlingel ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat:
Derjenige, der die Aufgabe am schnellsten löst, darf dann eine eigene stellen.

Meine Aufgabe ist es einen iterativer Durchlauf eines Binärbaums in Inorder-Reihenfolge zu kreieren. Der rekursive Algorithmus sieht mit der angegebenen Datenstruktur so aus:

C#-Code:
public class Node
{
    public Node Left { get; set; }
    public Node Right { get; set; }
    public int Key { get; set; }

    public Node()
    {
       Left = null;
       Right = null;
    }
}


public void Inorder(Node n)
{
   if(n != null)
   {
     Inorder(n.Left);
     Console.WriteLine(n.Key);
     Inorder(n.Right);
   }
}

Eure Aufgabe ist es einen Algorithmus zu basteln der ohne rekursivem Aufruf auskommt. Sehr hilfreich sind dabei die Stack- sowie die Queue-Datenstrukturen.

Viel Spaß

Dieser Beitrag wurde 7 mal editiert, zum letzten Mal von der-schlingel am 21.01.2010 10:47.

21.01.2010 08:28 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
herbivore
myCSharp.de-Poweruser/ Experte

avatar-2627.gif


Dabei seit: 11.01.2005
Beiträge: 49.461
Entwicklungsumgebung: csc/nmake (nothing is faster)
Herkunft: Berlin


herbivore ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo der-schlingel,

ich liebe iterative Umsetzung von rekursiven Funktionen genauso wie rekursive Funktionen selbst. Deshalb habe ich mich mal ran gemacht.

Ich habe deine Node-Klasse für .NET 2.0 angepasst und eine Komfort-Änderung vorgenommen, aber das Prinzip ist gleich geblieben.

Hier meine Lösung:

C#-Code:
using System;
using System.Collections.Generic;

public class NodeDirection
{
   public NodeDirection (Node node)
   {
      _node = node;
      _fLeft = true;
   }

   public bool Left
   {
      get { return _fLeft; }
      set { _fLeft = value; }
   }
   private bool _fLeft;

   public Node Node
   {
      get { return _node; }
   }
   private Node _node;
}

public class Node
{
   public Node Left
   {
      get { return _nodeLeft; }
      set { _nodeLeft = value; }
   }
   private Node _nodeLeft;

   public Node Right
   {
      get { return _nodeRight; }
      set { _nodeRight = value; }
   }
   private Node _nodeRight;

   public int Key
   {
      get { return _iKey; }
      set { _iKey = value; }
   }
   private int _iKey;

   public Node (int iKey)
   {
      _nodeLeft  = null;
      _nodeRight = null;
      _iKey      = iKey;
   }

   public void Inorder ()
   {
      Stack <NodeDirection> stk = new Stack <NodeDirection> ();

      // Wurzel zur Bearbeitung setzen
      stk.Push (new NodeDirection (this));

      // Solange noch Knoten zu bearbeiten sind ...
      while (stk.Count > 0) {

         // Anstehenden Konten holen
         NodeDirection nd = stk.Peek ();

         // Prüfen, ob von dem anstehenden Knoten der linke oder rechte
         // Unterknoten bearbeitet werden muss.
         if (nd.Left) {

            // Linken Unterknoten als schon berücksichtigt kennzeichnen
            nd.Left = false;

            // Linken Unterknoten (falls vorhanden) zur Bearbeitung setzen
            if (nd.Node.Left != null) {
               stk.Push (new NodeDirection (nd.Node.Left));
            }
         } else {

            // Knoten selbst behandeln
            Console.WriteLine (nd.Node.Key);

            // Rechten Unterknoten als schon berücksichtigt kennzeichnen
            stk.Pop ();

            // Rechten Unterknoten (falls vorhanden) zur Bearbeitung setzen
            if (nd.Node.Right != null) {
               stk.Push (new NodeDirection (nd.Node.Right));
            }
         }
      }
   }
}

static class App
{
   public static void Main (string [] astrArg)
   {
      Node node = new Node (1);

      node.Left  = new Node (2);
      node.Right = new Node (3);

      node.Left.Right = new Node (4);

      node.Right.Left = new Node (5);

      node.Inorder ();
   }
}

herbivore
21.01.2010 11:22 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
der-schlingel der-schlingel ist männlich
myCSharp.de-Mitglied

avatar-3239.jpg


Dabei seit: 13.10.2007
Beiträge: 799
Entwicklungsumgebung: VS 2005/ 2008 Pro
Herkunft: Österreich/Wien


der-schlingel ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

So ähnlich hatte ich mir das auch gedacht. Dann darf Herbivore die nächste Aufgabe stellen.
21.01.2010 11:57 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
herbivore
myCSharp.de-Poweruser/ Experte

avatar-2627.gif


Dabei seit: 11.01.2005
Beiträge: 49.461
Entwicklungsumgebung: csc/nmake (nothing is faster)
Herkunft: Berlin


herbivore ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo zusammen,

dann hätte ich gerne ein iteratives Türme von Hanoi. Natürlich eine selbst entwickelte Lösung, möglichst ganz ohne Verwendung einer Stack(artigen)-Klasse (ja, das geht).

Zitat von Wikipedia:
Das Spiel besteht aus drei Stäben A, B und C, auf die mehrere gelochte Scheiben gelegt werden, alle verschieden groß. Zu Beginn liegen alle Scheiben auf Stab A, der Größe nach geordnet, mit der größten Scheibe unten und der kleinsten oben. Ziel des Spiels ist es, den kompletten Scheiben-Stapel von A nach C zu versetzen.

Bei jedem Zug darf die oberste Scheibe eines beliebigen Stabes auf einen der beiden anderen Stäbe gelegt werden, vorausgesetzt, dort liegt nicht schon eine kleinere Scheibe. Folglich sind zu jedem Zeitpunkt des Spieles die Scheiben auf jedem Feld der Größe nach geordnet.

EDIT: Die zu schreibenden Methode Move soll Ausgaben der Form

"Nr. 4 von 1 nach 3"

machen, was bedeutet, dass in diesem Zug, die Scheibe Nummer 4 von Stab 1 (bzw. A) auf Stab 3 (bzw. C) verschoben wird. Die Scheibe Nummer 1 ist die kleinste, die Scheibe Nummer n ist die größte, wobei die Höhe n des Ausgangsturms als Parameter an Move übergeben wird.

herbivore
21.01.2010 12:06 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
dechavue dechavue ist männlich
myCSharp.de-Mitglied

avatar-2999.png


Dabei seit: 12.09.2006
Beiträge: 179
Entwicklungsumgebung: VS .Net 2003 Pro ; VS 2005 Pro
Herkunft: Österreich


dechavue ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Als Fan von Türme von Hanoi musst ich es natürlich gleich probieren.

Hier meine Lösung:

C#-Code:
        static void Main(string[] args) {
            for (int i = 1; i < 7; i++) {
                Console.WriteLine("== {0} =============================", i);
                Move(i);
            }
        }

        static void Move(int n) {
            Stack<int>[] sticks = new Stack<int>[3];

            for (int i = 0; i < sticks.Length; i++) {
                sticks[i] = new Stack<int>();
            }
            //Fill Stick 1
            for (int i = n; i > 0; i--) {
                sticks[0].Push(i);
            }


            int lastTargetStick = -1;


            while (sticks[0].Count > 0 || sticks[1].Count > 0) {
                for (int i = 0; i < sticks.Length; i++) {
                    if (lastTargetStick != i && sticks[i].Count > 0) {
                        if (sticks[(i + 1) % sticks.Length].Count == 0 && sticks[(i + 2) % sticks.Length].Count == 0) {
                            if (sticks[i].Count % 2 == 0) {
                                lastTargetStick = (i + 1) % sticks.Length;
                            } else {
                                lastTargetStick = (i + 2) % sticks.Length;
                            }
                            Console.WriteLine("Nr. {0} von {1} nach {2}", sticks[i].Peek(), i+1, lastTargetStick+1);
                            sticks[lastTargetStick].Push(sticks[i].Pop());
                            break;
                        } else {
                            if (sticks[(i + 1) % sticks.Length].Count > 0 && sticks[i].Peek() > sticks[(i + 1) % sticks.Length].Peek() &&
                                sticks[(i + 2) % sticks.Length].Count > 0 && sticks[i].Peek() > sticks[(i + 2) % sticks.Length].Peek()) {
                                continue;
                            }
                            if ((sticks[(i + 1) % sticks.Length].Count == 0 || sticks[i].Peek()      < sticks[(i + 1) % sticks.Length].Peek())    &&
                                (sticks[(i + 1) % sticks.Length].Count > 0 && sticks[i].Peek() % 2 != sticks[(i + 1) % sticks.Length].Peek() % 2 ||
                                 sticks[(i + 2) % sticks.Length].Count > 0 && sticks[i].Peek() % 2 == sticks[(i + 2) % sticks.Length].Peek() % 2 ||
                                 sticks[(i + 2) % sticks.Length].Count > 0 && sticks[i].Peek()      > sticks[(i + 2) % sticks.Length].Peek())) {
                                lastTargetStick = (i + 1) % sticks.Length;
                            } else {
                                lastTargetStick = (i + 2) % sticks.Length;
                            }
                            Console.WriteLine("Nr. {0} von {1} nach {2}", sticks[i].Peek(), i+1, lastTargetStick+1);
                            sticks[lastTargetStick].Push(sticks[i].Pop());
                            break;
                        }
                    }
                }
            }

        }
    }

Ich hoffe Stacks als Repräsentation der Stäbe sind erlaubt, sonst baue ich es noch um auf Arrays.
21.01.2010 13:59 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
JAck30lena JAck30lena ist männlich
myCSharp.de-Team

avatar-2653.jpg


Dabei seit: 01.10.2006
Beiträge: 11.397
Entwicklungsumgebung: Visual Studio 05/08/10 Prof.


JAck30lena ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat:
Ich hoffe Stacks als Repräsentation der Stäbe sind erlaubt

siehe:

Zitat von bedingung von herbivore:
ohne Verwendung einer Stack(artigen)-Klasse
21.01.2010 14:05 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
dechavue dechavue ist männlich
myCSharp.de-Mitglied

avatar-2999.png


Dabei seit: 12.09.2006
Beiträge: 179
Entwicklungsumgebung: VS .Net 2003 Pro ; VS 2005 Pro
Herkunft: Österreich


dechavue ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Ich hatte es sinngemäs so verstanden: Keine Stacks um die Rekursive Variante iterativ zu implementieren.

Aber gut, dann hier das ganze mit Listen

C#-Code:
        static void Main(string[] args) {
            for (int i = 1; i < 7; i++) {
                Console.WriteLine("== {0} =============================", i);
                Move(i);
            }
        }

        static void Move(int n) {
            List<int>[] sticks = new List<int>[3];

            for (int i = 0; i < sticks.Length; i++) {
                sticks[i] = new List<int>();
            }
            //Fill Stick 1
            for (int i = n; i > 0; i--) {
                sticks[0].Add(i);
            }


            int lastTargetStick = -1;


            while (sticks[0].Count > 0 || sticks[1].Count > 0) {
                for (int i = 0; i < sticks.Length; i++) {
                    if (lastTargetStick != i && sticks[i].Count > 0) {
                        if (sticks[(i + 1) % sticks.Length].Count == 0 && sticks[(i + 2) % sticks.Length].Count == 0) {
                            if (sticks[i].Count % 2 == 0) {
                                lastTargetStick = (i + 1) % sticks.Length;
                            } else {
                                lastTargetStick = (i + 2) % sticks.Length;
                            }
                            Console.WriteLine("Nr. {0} von {1} nach {2}", sticks[i][sticks[i].Count-1], i + 1, lastTargetStick + 1);
                            sticks[lastTargetStick].Add(sticks[i][sticks[i].Count-1]);
                            sticks[i].RemoveAt(sticks[i].Count - 1);
                            break;
                        } else {
                            if (sticks[(i + 1) % sticks.Length].Count > 0 && sticks[i][sticks[i].Count - 1] > sticks[(i + 1) % sticks.Length][sticks[(i + 1) % sticks.Length].Count -1] &&
                                sticks[(i + 2) % sticks.Length].Count > 0 && sticks[i][sticks[i].Count - 1] > sticks[(i + 2) % sticks.Length][sticks[(i + 2) % sticks.Length].Count - 1]) {
                                continue;
                            }
                            if ((sticks[(i + 1) % sticks.Length].Count == 0 || sticks[i][sticks[i].Count - 1] < sticks[(i + 1) % sticks.Length][sticks[(i + 1) % sticks.Length].Count - 1]) &&
                                (sticks[(i + 1) % sticks.Length].Count > 0 && sticks[i][sticks[i].Count - 1] % 2 != sticks[(i + 1) % sticks.Length][sticks[(i + 1) % sticks.Length].Count - 1] % 2 ||
                                 sticks[(i + 2) % sticks.Length].Count > 0 && sticks[i][sticks[i].Count - 1] % 2 == sticks[(i + 2) % sticks.Length][sticks[(i + 2) % sticks.Length].Count - 1] % 2 ||
                                 sticks[(i + 2) % sticks.Length].Count > 0 && sticks[i][sticks[i].Count - 1] > sticks[(i + 2) % sticks.Length][sticks[(i + 2) % sticks.Length].Count - 1])) {
                                lastTargetStick = (i + 1) % sticks.Length;
                            } else {
                                lastTargetStick = (i + 2) % sticks.Length;
                            }
                            Console.WriteLine("Nr. {0} von {1} nach {2}", sticks[i][sticks[i].Count - 1], i + 1, lastTargetStick + 1);
                            sticks[lastTargetStick].Add(sticks[i][sticks[i].Count - 1]);
                            sticks[i].RemoveAt(sticks[i].Count - 1);
                            break;
                        }
                    }
                }
            }

        }
21.01.2010 14:24 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
herbivore
myCSharp.de-Poweruser/ Experte

avatar-2627.gif


Dabei seit: 11.01.2005
Beiträge: 49.461
Entwicklungsumgebung: csc/nmake (nothing is faster)
Herkunft: Berlin


herbivore ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo dechavue,

Stacks zur Repräsentation des Inhalts der Stäbe sind schon ok. Daran habe ich gar nicht gedacht, weil der Inhalt der Stäbe für die Ausgabe der Zugfolge nicht benötigt wird. Oder anders ausgedrückt, um ausgeben zu können, welche Scheibe man im x-ten Zug von wo nach wo bewegen muss, braucht man keine Repräsentation des Inhalts der Stäbe, sondern kann das alleine aus der Nummer des Zugs (und der Höhe des Anfangsturms) ausrechnen. Siehe  Gibt es Rekursionen die sich nicht in eine Iteration umwandeln lassen?.

Insofern war schon deine erste Lösung ok. Du bist also mit der nächsten Aufgabe dran.

(Wobei ich noch verstehen muss, wie deine Lösung funktioniert. Ich habe erstmal nur die Ausgabe überprüft, um den Fortgang dieses Threads nicht zu bremsen. Vielleicht sagst du, wenn du deine Aufgabe stellst, nebenbei auch noch was zu der Idee deines Hanoi-Lösungsansatzes).

herbivore
21.01.2010 15:23 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
dechavue dechavue ist männlich
myCSharp.de-Mitglied

avatar-2999.png


Dabei seit: 12.09.2006
Beiträge: 179
Entwicklungsumgebung: VS .Net 2003 Pro ; VS 2005 Pro
Herkunft: Österreich


dechavue ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Gut, dann bleiben wir gleich bei Iterativen Varianten.
Ich hätte gerne eine iterative Implementierung des Quicksort

Zu meiner Lösung:
Ich am iPhone ein TvH Spiel, bei dem die Scheiben immer abwechseld gefärbt sind.
Mir ist dann mal aufgefallen, dass beim optimalen Lösen niemals 2 gleichfarbige Scheiben aufeinanderliegen.
Daraus, und aus der Start-Bedingung, dass bei einer geraden Stapelhöhe zuerst auf das "Nicht-Zielfeld" gelegt werden muss und bei einer Ungeraden Stapelhöhe der erste Zug auf das Zielfeld erfolgen muss, ergibt sich der Ablauf von selbst:
Das nächste Ziel ist immer der Stein, mit einer anderen Farbe, bei dem die Breite größer ist, oder ein leeres Feld.
Wichtig ist noch, dass wenn beide Ziele möglich wären, das nicht leere Feld bevorzugt wird.
Die Quelle ergibt sich daraus, dass der zuletzt umgelegte Stein nicht bewegt werden darf + welcher andere Stein umgelegt werden kann.
Die abwechselnden Farben repräsentieren bei mir die Scheibenbreite % 2

Ich habe noch einen Ablauf eines 3er und 4er turms in den Anhang gegeben, zum besseren Verständnis des "Farb - Systems"


Nachtrag: Ich sehe gerade, bei meinem algo könnte man den ersten Zweig des ifs ( if (sticks[(i + 1) % sticks.Length].Count == 0 && sticks[(i + 2) % sticks.Length].Count == 0) {) komplett aus den Schleifen herausziehen, da es nur beim ersten Durchlauf true sein kann. Dann wäre der Algo eventuell auch etwas verständlicher.


Dateianhang:
unknown Hanoi.zip (119 KB, 874 mal heruntergeladen)

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von dechavue am 21.01.2010 16:23.

21.01.2010 16:12 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
F.Z. F.Z. ist männlich
myCSharp.de-Mitglied

Dabei seit: 30.09.2009
Beiträge: 155
Entwicklungsumgebung: VS 2010


F.Z. ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo,

C#-Code:
private static int[] Quicksort(int[] ZuSortieren)
        {
            int[] Sortiert = new int[ZuSortieren.Length];
            int Pivot;
            List<List<List<int>>> Liste = new List<List<List<int>>>();
            List<List<int>> Startliste = new List<List<int>>();
            Startliste.Add(ZuSortieren.ToList());
            Liste.Add(Startliste);

            for (int AnzahlEbenen = 0; AnzahlEbenen < Liste.Count; AnzahlEbenen++)
            {
                List<List<int>> NeuEbene = new List<List<int>>();
                for (int AnzahlListen = 0; AnzahlListen < Liste[AnzahlEbenen].Count; AnzahlListen++)
                {
                    if (Liste[AnzahlEbenen][AnzahlListen].Count > 1)
                    {
                        List<int> Kleiner = new List<int>();
                        List<int> Groesser = new List<int>();
                        List<int> DoppelteWerte = new List<int>();

                        Pivot = Liste[AnzahlEbenen][AnzahlListen][(int)Liste[AnzahlEbenen][AnzahlListen].Count / 2];

                        for (int i = 0; i < Liste[AnzahlEbenen][AnzahlListen].Count; i++)
                        {
                            if (Liste[AnzahlEbenen][AnzahlListen][i] < Pivot)
                                Kleiner.Add(Liste[AnzahlEbenen][AnzahlListen][i]);
                            else if (Liste[AnzahlEbenen][AnzahlListen][i] > Pivot)
                                Groesser.Add(Liste[AnzahlEbenen][AnzahlListen][i]);
                            else
                            {
                                if (Groesser.Contains(Pivot))
                                {
                                    DoppelteWerte.Add(Liste[AnzahlEbenen][AnzahlListen][i]);
                                }
                                else
                                    if (Kleiner.Count > Groesser.Count)
                                        Groesser.Add(Pivot);
                                    else
                                        Kleiner.Add(Pivot);
                            }
                        }
                        NeuEbene.Add(Kleiner);
                        if(DoppelteWerte.Count>0)
                            NeuEbene.Add(DoppelteWerte);
                        NeuEbene.Add(Groesser);
                    }
                    else
                    {
                        NeuEbene.Add(Liste[AnzahlEbenen][AnzahlListen]);
                    }
                    if (Liste[AnzahlEbenen].Count == ZuSortieren.Length)
                    {
                        for (int i = 0; i < ZuSortieren.Length; i++)
                            Sortiert[i] = Liste[AnzahlEbenen][i][0];
                        return Sortiert;

                    }
                }
                Liste.Add(NeuEbene);
            }
            return null;
        }

Aufruf:

C#-Code:
            int[] ZuSortieren = {-1, 10, 4, 1, 9, 5, 3,2, 6, 7, 8 ,2};
            ZuSortieren= Quicksort(ZuSortieren);

Ich hoffe ich habe dich richtig verstanden.

Beste Grüße
FZ

EDIT: Es gab Probleme bei gleichen Werten

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von F.Z. am 21.01.2010 20:19.

21.01.2010 17:55 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
dechavue dechavue ist männlich
myCSharp.de-Mitglied

avatar-2999.png


Dabei seit: 12.09.2006
Beiträge: 179
Entwicklungsumgebung: VS .Net 2003 Pro ; VS 2005 Pro
Herkunft: Österreich


dechavue ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Deine Implementierung scheint Probleme zu haben wenn gleiche Werte vorkommen.

Da ich dann weg muss und heute nicht mehr dazukomme mir eine Alternativlösung anzuschauen, lass ichs mal durchgehen.

Dann stell deine Aufgabe
21.01.2010 18:33 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
F.Z. F.Z. ist männlich
myCSharp.de-Mitglied

Dabei seit: 30.09.2009
Beiträge: 155
Entwicklungsumgebung: VS 2010


F.Z. ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo,

Danke für den Hinweis, ich werds mir nochmal genauer ansehen.

Die nächste Aufgabe:
Das Pascalsche-Dreick bis zur n-ten Zeile ausgeben.

Code:
1:
2:
3:
4:
5:
z.B. n=3
      1
     1 1
    1 2 1
   1 3 3 1

Grüße
FZ
21.01.2010 19:56 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
tobho
myCSharp.de-Mitglied

Dabei seit: 21.01.2010
Beiträge: 2


tobho ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

C#-Code:
int wert = 3;
Console.Out.WriteLine("1");
for (int i = o; i <= wert; i++)
{
    Console.Out.Write("1");
    for (int a = 1; a <= i; a++)
    {
        Console.Out.Write(i+1);
    }
Console.Out.WriteLine("1");

Gruß Tobi
21.01.2010 21:17 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
winSharp93 winSharp93 ist männlich
myCSharp.de-Poweruser/ Experte

avatar-2918.png


Dabei seit: 19.01.2007
Beiträge: 5.742
Herkunft: Stuttgart


winSharp93 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von tobho:
Code:
1:
[...]

*Räusper*:  Pascalsches Dreieck

Geht sicherlich noch besser, aber egal Augenzwinkern

C#-Code:
int[] currentLine = new int[] { };
int[] previousLine;

int max = 5;
for (int n = 0; n < max; n++)
{
    previousLine = currentLine;
    currentLine = new int[previousLine.Length + 1];
    currentLine[0] = 1;
    currentLine[currentLine.Length - 1] = 1;
    for (int i = 1; i < currentLine.Length - 1; i++)
        currentLine[i] = previousLine[i - 1] + previousLine[i];

    Console.Write(new string(' ', max - currentLine.Length));
    for (int i = 0; i < currentLine.Length; i++)
        Console.Write(currentLine[i] + " ");

    Console.WriteLine();
}

Console.ReadLine();

//EDIT:
Ich wusste, ich habe was vergessen: smile

(Gar nicht so leicht irgendetwas zu finden, dann eben etwas Klassisches großes Grinsen )
Ein Programm, das eine Primfaktorzerlegung einer beliebigen Zahl durchführt.

Dieser Beitrag wurde 3 mal editiert, zum letzten Mal von winSharp93 am 21.01.2010 21:37.

21.01.2010 21:21 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Uwe81 Uwe81 ist männlich
myCSharp.de-Mitglied

Dabei seit: 26.07.2008
Beiträge: 282
Entwicklungsumgebung: Visual Studio 2010/13
Herkunft: Ludwigshafen


Uwe81 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

C#-Code:
class Primes {
    static IEnumerable<int> DividerSequence() {
        yield return 2;
        yield return 3;
        for(int i = 6; true; i+=6){
            yield return i - 1;
            yield return i + 1;
        }
    }

    public static ICollection<int> GetPrimeFactors(int number) {
        if (number <= 0) {
            throw new ArgumentException("Positive integer expected.", "number");
        }

        LinkedList<int> primeFactors = new LinkedList<int>();
        foreach (int factor in DividerSequence()) {
            while (number % factor == 0) {
                primeFactors.AddLast(factor);
                number /= factor;
            }
            if (factor * factor > number) {
                break;
            }
        }
        if (number > 1) {
            primeFactors.AddLast(number);
        }
        return primeFactors;
    }
}

class Program{
    static void Main(string[] args) {
        for (int number = 1; number < 100; number++) {
            ICollection<int> primeFactors = Primes.GetPrimeFactors(number);
            Console.WriteLine(
                "n={0}, Primes=[{1}]",
                number,
                string.Join(", ", primeFactors.Select(x => x.ToString()).ToArray()));
        }
    }
}

Neue Aufgabe:
Man teste ohne Verwendung der Logarithmusfunktion mit einem einzigen Statement, ob eine Integer eine Zweierpotenz ist.

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Uwe81 am 22.01.2010 00:24.

22.01.2010 00:16 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
edsplash edsplash ist männlich
myCSharp.de-Mitglied

avatar-3111.jpg


Dabei seit: 19.04.2008
Beiträge: 390
Entwicklungsumgebung: VS2010


edsplash ist offline Füge edsplash Deiner Kontaktliste hinzu

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

C#-Code:
(number & (number - 1)) == 0

Neue Aufgabe

Eine Implementierung des  erweiterten euklidischen Algorithmus
(Rekursiv oder Iterativ)
22.01.2010 08:52 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Seiten (19): [1] 2 3 4 5 nächste » ... letzte » Baumstruktur | Brettstruktur       | Top 
myCSharp.de | Forum Der Startbeitrag ist älter als 9 Jahre.
Der letzte Beitrag ist älter als ein Jahr.
Antwort erstellen


© Copyright 2003-2019 myCSharp.de-Team | Impressum | Datenschutz | Alle Rechte vorbehalten. | Dieses Portal verwendet zum korrekten Betrieb Cookies. 17.08.2019 15:12