Was macht man, wenn Zahlenfolgen zu komplex werden, um sie mit Schleifen zu erzeugen?

Thilo87 · 26. August 2013, 13:43

Hallo,

es gibt ja z.B. einfache Schleifenkonstruktionen, wie z.B. welche, die jedes Element eines 2D-Arrays durchgehen

VB.NET-Quellcode

Dim MyArray(9,4) As String
For i As Integer = 0 to 9
For j As Integer = 0 to 4
MyArray(i,j) ...
Next
Next

Dann gibt es auch z.B. noch welche, wo jedes Element mit jedem in einem 1D-Array verglichen werden kann

VB.NET-Quellcode

Dim MyArray(5) As String
For i As Integer = 0 to 5
For j As Integer = i+1 to 5
If MyArray(i) = MyArray(j) Then ...
Next
Next

Was macht man aber bei wirklich komplexen Schleifenkonstruktionen?
Zum Beispiel habe ich ein Array

VB.NET-Quellcode

Dim MyArray As Integer(,) = {(0,0,1,2}, {1,2,1,1}, {0,0,0,0}, {1,2,1,2}}

und ich möchte nun (0,0) mit (0,1); (0,0) mit (1,0); (0,0) mit (1,1); (0,0) mit (2,0); ... ; (0,1) mit (1,0); (0,1) mit (1,1); (0,1) mit (2,0) usw. vergleichen. Das wären max. 4 ineinander verschachtelte Schleifen und de innerste Schleife müsst 0,0,0,1, dann 0,0,1,0, dann 0,0,2,0, ..., dann 0,1,1,0 usw. hervorbringen, was, wie ich finde, schon eine schwierige Zahlenfolge ist, die auch folglich mit Schleifen nur mühsam zu realisieren ist.
Was macht man also, wenn die Schleifenkonstruktion zu kompliziert wird, um eine bestimmte Zahlenfolge zu erstellen?

Mir fällt da nur ein, die Zahlenfolge in ein Array einzugeben und von diesem dann jedes Element nacheinander abzurufen.

Kennt ihr noch weitere Methoden? Gibt es Methoden, wie man Schleifen analysieren kann, etc?

Danke,

Thilo

sonne75 · 26. August 2013, 13:56

Wie kommst du von dem

Thilo87 schrieb:

Zum Beispiel habe ich ein Array

VB.NET-Quellcode

Dim MyArray As Integer(,) = {{0,0,1,2}, {1,2,1,1}, {0,0,0,0}, {1,2,1,2}}

und ich möchte nun (0,0) mit (0,1); (0,0) mit (1,0); (0,0) mit (1,1); (0,0) mit (2,0); ... ; (0,1) mit (1,0); (0,1) mit (1,1); (0,1) mit (2,0) usw. vergleichen.

zu dem

Thilo87 schrieb:

und de innerste Schleife müsst 0,0,0,1, dann 0,0,1,0, dann 0,0,2,0, ..., dann 0,1,1,0 usw. hervorbringen

? Für mich sieht es nach einem Zickzackmuster aus.

Thilo87 schrieb:

Mir fällt da nur ein, die Zahlenfolge in ein Array einzugeben und von diesem dann jedes Element nacheinander abzurufen.

Und was verstehst du an dieser Stelle unter "Zahlenfolge"?

Thilo87 · 26. August 2013, 14:06

Achso, da hat sich ein kleiner Fehler eingeschlichen. Es sollte

"und de innerste Schleife müsst 0,0,0,1, dann 0,0,1,0, dann 1,1,0,0, dann 0,0,2,0, ..., dann 0,1,1,0 usw. hervorbringen" heißen.

Ich wollte ja z.B. Array(0,0) mit Array(0,1) vergleichen (im ersten Schritt). Da muss ich ja irgendwas mit

VB.NET-Quellcode

If Array(0,0) = Array(0,1) Then ...
' bzw.
If Array(i,j) = Array(k,l) Then ...

in der innersten Schleife sein.

Aber das war ja auch nur ein Beispiel. Man könnte auch in der innersten Schleife eine Zahlenfolge wie (0,1), (0,3), (1,3), (1,0) haben wollen oder (2,3), (5,7), (11,13), (17,19), (23,29), (31,37) (die Primzahlen ^^). Letzteres wäre wohl eine so komplexe Zahlenfolge, dass nichts anderes mehr möglich ist, als es in ein Array zu speichern und nacheinander abzurufen.

ErfinderDesRades · 26. August 2013, 14:09

Verstehe ich recht, dass du jeden Punkt mit jedem anneren abgleichen willst?

Das wären max. 4 ineinander verschachtelte Schleifen

Ja und - wäre das besonders schlimm?

Edit: Hmm - scheint eine abstrakte Frage ohne konkretes Problem zu sein.
Hat ich finde keinen Sinn, sich mit zu beschäftigen. Nur soviel: Ja, beim Permutieren muss man sich oft listenreiche Lösungen einfallen lassen, und: meist ist es möglich.

sonne75 · 26. August 2013, 14:12

Ach so, ich dachte, da stehen schon die Werte drin (aus deinem Array), übrigens, es soll dann nicht 1,1,0,0 heißen, sondern 0,0,1,1 (du vergleichst doch (0,0) der Reihe nach mit seinen Nachbarn).

Gerade die letzte Variante könnte man doch über die Primzahlen super realisieren.

Ich stelle mir die Frage, in welchem Fall würde man es brauchen?
Wann soll man ein Array nach einem Muster ohne innere Struktur durchsuchen wollen? Ich denke mir, es wird immer irgendeinen Grund für die Suche geben, eine Struktur dahinter, und anhand dieser Struktur erstellt man die Schleifendurchlaufmuster.

Artentus · 26. August 2013, 14:44

Die Primzahlen kann man nicht optimal herausfinden, das ist bis heute ein ungelöstes Problem der Mathematik. Man kann sie nur berechnen, indem man alle Zahlen von 1 bis n durchläuft und eine Primfaktorzerlegung auf sie anwendet. Dies ist aber natürlich extrem rechenaufwändig, da die Zahlen sehr schnell sehr groß werden.

sonne75 · 26. August 2013, 14:49

@Artentus
Ich habe angenommen, dass man schon bei der Programmierung weiß, dass man Primzahlen verwenden will. Dafür kann man sie vorher schon zur Verfügung stellen (in einem Array), bevor man anfängt das Array zu durchlaufen.
Und man muss die Zahlen ja nicht durch alle Zeilen zu teilen versuchen sondern durch die jeweils vorher ermittelnden Primzahlen, das beschleunigt die Suche. Abgesehen davon, dass man sie gar nicht im Programm jedes Mal rechnen muss, sondern in einer Textdatei oder als Const-Array im Code ablegen kann.

Mir ging es darum: man hat einen Grund, wieso man auf diese Weise ein Array durchsuchen will, und genau diesen Grund kann man in den Schleifen abbilden.

Artentus · 26. August 2013, 14:53

Das war nicht auf deinen Post bezogen, sondern auf den von Thilo. Und das Teilen durch alle vorherige Primzahlen ist die Primfaktorzerlegung.

sonne75 · 26. August 2013, 14:55

Artentus schrieb:

Und das Teilen durch alle vorherige Primzahlen ist die Primfaktorzerlegung.

Ah, danke, ich kannte den Begriff nicht, habe es mir nur logisch überlegt.

Thilo87 · 26. August 2013, 14:56

@ErfinderDesRades

Edit: Hmm - scheint eine abstrakte Frage ohne konkretes Problem zu sein.

Ja, das ist richtig

Es ist eben so, dass ich mit komplexen Schleifenkonstruktionen oft nicht klarkomme. Ich sitze dann davor, schreibe eine Schleife nach der anderen und am Ende stimmt die Zahlenfolge trotzdem nicht. Ich finde das bei mehrdimensionalen Arrays sehr schwierig. Das letzte Problem, woran ich verzweifelt bin, war dieses, dass ich ein 2D-Array gefüllt mit den Feldern eines Sudokus hatte und eine Funktion schreiben wollte, die zurückgibt, ob das Sudoku richtig ausgefüllt ist. Es ist ja leicht, die waagerechten und senkrechten Felder darauf zu überprüfen, ob sie jede Zahl nur einmal enthalten. Aber bei den Blöcken bin ich echt verzweifelt, sie alle in einer Schleifenkonstruktion zu überprüfen. Vielleicht kann man es sich vereinfachen, indem man alle Zahlen in einem Block in einer Liste zwischenspeichert und diese Liste dann darauf überprüft, ob ein Element darin doppelt vorkommt, dann wäre der Block nicht korrekt ausgeführt. Aber das ist sicher nicht so performant, wie wenn man die Blöcke direkt in einer Schleife überprüfen würde.

Aber stelle dir doch mal ein 3D-Sudoku oder soetwas vor. Die Schleifenkonstruktion würde etliche ineinander verschachtelte Schleifen enthalten. Da würde ich vollends zusammenbrechen

Ich hatte ja auch schon diesen Thread hier geschrieben: [VB.NET] 2-dimensionales Array diagonal durchlaufen
Das fand ich auch schon sehr schwer und es hat so einige Anläufe von anderen Usern gegeben, bis es endlich richtig war (danke dir ^^).

Es muss doch einen allgemeinen Ansatz geben, wie man Schleifenkonstruktionen für bestimmte Zwecke erstellen kann. Eine Reihenfolge, in der man die Schleifen konstruiert und worauf man achten muss... Hoffe ich

@Artentus:

Die Primzahlen kann man nicht optimal herausfinden, das ist bis heute
ein ungelöstes Problem der Mathematik. Man kann sie nur berechnen, indem
man alle Zahlen von 1 bis n durchläuft und eine Primfaktorzerlegung auf
sie anwendet. Dies ist aber natürlich extrem rechenaufwändig, da die
Zahlen sehr schnell sehr groß werden.

Ja eben, deswegen gibt es auch keine einfache Schleifenkonstruktion, die diese Folge erzeugt, woraus man auch folgern kann, dass es nicht für jede Zahlenfolge eine Schleifenkonstruktion geben kann, manchmal ist es also schlicht nicht möglich.

Artentus · 26. August 2013, 15:01

Zu dem Sudoku: da braucht man überhaupt keine komplizierten Schleifenkonstrukte, nur ein bisschen Mathematik. Schau mal her, hier ist ein Sudoku-Code von mir:

Spoiler anzeigen

VB.NET-Quellcode

Public Class Sudoku
Protected data As SudokuData
Protected isSolving As Boolean
''' <summary>
''' Erstellt ein neues Sudoku.
''' </summary>
''' <remarks></remarks>
Public Sub New()
'initialisieren
data = New SudokuData
isSolving = False
End Sub
''' <summary>
''' Gibt das diesem Sudoku zu Grunde liegende SudokuData-Objekt zurück.
''' </summary>
''' <returns></returns>
''' <remarks></remarks>
Public Function GetData() As SudokuData
'wenn möglich Rückgabe
If Not isSolving Then Return data
'ansonsten Fehler
Throw New InvalidOperationException("Während des Lösevorgangs kann nicht auf das SudokuData-Objekt zugegriffen werden.")
End Function
''' <summary>
''' Löst das Sudoku, wenn möglich.
''' </summary>
''' <returns>Gibt einen Wahrheitswert zurück, der aussagt, ob das Sudoku gelöst werden konnte.</returns>
''' <remarks></remarks>
Public Function Solve() As Boolean
'Status setzen
isSolving = True
'lösen
Dim retVal = SolveInner()
'Status zurücksetzen
isSolving = False
'Ergebnis zurückgeben
Return retVal
End Function
Protected Function SolveInner() As Boolean
'Anzahl leerer Felder speichern
Dim emptyFields = data.EmptyFields
'wiederholen bis alle Felder gesetzt sind
Do While emptyFields > 0
'lösen
For y = 0 To 8
For x = 0 To 8
SolveField(x, y)
Next
Next
'leere Felder aktualisieren
Dim oldEmpty = emptyFields
emptyFields = data.EmptyFields
'keine Felder in dieser Iteration gesetzt -> Sudoku nicht lösbar
If oldEmpty = emptyFields Then Return False
Loop
'Erfolg
Return True
End Function
Protected Function SolveField(x As Integer, y As Integer) As Boolean
'ist das Feld schon gelöst?
If data(x, y) > 0 Then Return True
'List für beschränkende Werte erstellen
Dim vals As New List(Of Integer)
vals.AddRange(GetRegionValues(x, y))
vals.AddRange(GetColumnValues(x))
vals.AddRange(GetRowValues(y))
'übrige Werte berechnen
Dim remaining = GetRemainingValues(vals)
'wenn möglich lösen
If remaining.Count = 1 Then
data(x, y) = remaining.First
Return True 'gelöst
End If
'nicht gelöst
Return False
End Function
Protected Function GetRemainingValues(l As IEnumerable(Of Integer)) As IEnumerable(Of Integer)
'Liste erstellen
Dim allVals() = {1, 2, 3, 4, 5, 6, 7, 8, 9} 'alle Werte
Return allVals.Except(l) 'vorhandene Werte aussortieren
End Function
Protected Function GetRegionValues(x As Integer, y As Integer) As IEnumerable(Of Integer)
'Index der Region ermitteln
Dim rIndex = data.GetRegionOfField(x, y)
'alle Felder der Region auflisten
Dim vals() = data.GetRegion(rIndex)
'alle vorhandenen Werte zurückgeben
Return From val In vals Where val <> 0
End Function
Protected Function GetColumnValues(x As Integer) As IEnumerable(Of Integer)
'alle Felder der Spalte auflisten
Dim vals() = data.GetColumn(x)
'alle vorhandenen Werte zurückgeben
Return From val In vals Where val <> 0
End Function
Protected Function GetRowValues(y As Integer) As IEnumerable(Of Integer)
'alle Felder der Zeile auflisten
Dim vals() = data.GetRow(y)
'alle vorhandenen Werte zurückgeben
Return From val In vals Where val <> 0
End Function
End Class
Public Class SudokuData
Protected fields(,) As Integer 'Spielfeld
''' <summary>
''' Die Felder in diesem Sudoku.
''' </summary>
''' <param name="x">Die X-Koordinate des Feldes.</param>
''' <param name="y">Die Y-Koordinate des Feldes.</param>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Default Public Property Field(x As Integer, y As Integer) As Integer
Get
Return fields(x, y)
End Get
Set(value As Integer)
If value < 0 OrElse value > 9 Then Throw New ArgumentException("Ein Feld kann nur mit den Zahlen 0 bis 9 befüllt werden.")
fields(x, y) = value
End Set
End Property
''' <summary>
''' Gibt die Anzahl freier Felder in diesem Sudoku an.
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public ReadOnly Property EmptyFields As Integer
Get
Return fields.Cast(Of Integer).Count(Function(item) item = 0)
End Get
End Property
''' <summary>
''' Konstruktor. Nur innerhalb des Projekts verfügbar.
''' </summary>
''' <remarks></remarks>
Protected Friend Sub New()
'Spielfeld erstellen
fields = New Integer(8, 8) {}
End Sub
''' <summary>
''' Setzt alle Felder auf 0.
''' </summary>
''' <remarks></remarks>
Public Sub Clear()
'alle Felder durchlaufen
For x = 0 To 8
For y = 0 To 8
'auf 0 setzen
fields(x, y) = 0
Next
Next
End Sub
''' <summary>
''' Gibt alle Felder mit der selben X-Koordinate als Array zurück.
''' </summary>
''' <param name="columnIndex">Die gemeinsame X-Koordinate aller Felder.</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function GetColumn(columnIndex As Integer) As Integer()
'Fehler vermeiden
If columnIndex >= 9 Then Throw New ArgumentException("Der Index muss kleiner 9 sein.", "columnIndex", New IndexOutOfRangeException)
'Array initialisieren
Dim vals(8) As Integer
'Array füllen
For y = 0 To 8
vals(y) = fields(columnIndex, y)
Next
'Rückgabe
Return vals
End Function
''' <summary>
''' Gibt alle Felder mit der selben Y-Koordinate als Array zurück.
''' </summary>
''' <param name="rowIndex">Die gemeinsame Y-Koordinate aller Felder.</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function GetRow(rowIndex As Integer) As Integer()
'Fehler vermeiden
If rowIndex >= 9 Then Throw New ArgumentException("Der Index muss kleiner 9 sein.", "rowIndex", New IndexOutOfRangeException)
'Array initialisieren
Dim vals(8) As Integer
'Array füllen
For x = 0 To 8
vals(x) = fields(x, rowIndex)
Next
'Rückgabe
Return vals
End Function
''' <summary>
''' Gibt alle Felder innerhalb einer Region zurück.
''' </summary>
''' <param name="regionIndex">Der Index der Region.</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function GetRegion(regionIndex As Integer) As Integer()
'Array initialisieren
Dim vals(8) As Integer
'Startpunkt berechnen
Dim rX, rY As Integer
GetRegionPos(regionIndex, rX, rY)
'Array füllen
For y = 0 To 2
For x = 0 To 2
Dim i = x + y * 3 'Index im Array berechnen
vals(i) = fields(rX + x, rY + y) 'Wert zuweisen
Next
Next
'Rückgabe
Return vals
End Function
''' <summary>
''' Berechnet den Index der Region, in der sich ein Feld befindet.
''' </summary>
''' <param name="x">Die X-Koordinate des Feldes.</param>
''' <param name="y">Die Y-Koordinate des Feldes.</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function GetRegionOfField(x As Integer, y As Integer) As Integer
'Fehler vermeiden
If x >= 9 Then Throw New ArgumentException("Der Index muss kleiner 9 sein.", "x", New IndexOutOfRangeException)
If y >= 9 Then Throw New ArgumentException("Der Index muss kleiner 9 sein.", "y", New IndexOutOfRangeException)
'Koordinaten der Region berechnen
Dim rX, rY As Integer
rX = x \ 3
rY = y \ 3
'Index berechnen und zurückgeben
Dim i = rX + rY * 3
Return i
End Function
''' <summary>
''' Bestimmt die Position eines Feldes in Abhängigkeit seiner Region.
''' </summary>
''' <param name="regionIndex">Der Index der Region.</param>
''' <param name="fieldIndex">Der Index des Feldes innerhalb der Region.</param>
''' <param name="x">Rückgabewert. Die X-Koordinate des Feldes.</param>
''' <param name="y">Rückgabewert. Die Y-Koordinate des Feldes.</param>
''' <remarks></remarks>
Protected Sub GetPosInRegion(regionIndex As Integer, fieldIndex As Integer, ByRef x As Integer, ByRef y As Integer)
'falscher Index
If fieldIndex >= 9 OrElse fieldIndex < 0 Then Throw New ArgumentException("Der Index des Feldes muss kleiner 9 sein.", "fieldIndex")
'Position der Region berechnen
Dim rX, rY As Integer
GetRegionPos(regionIndex, rX, rY)
'Koordinate des Feldes berechnen
Dim fX = fieldIndex Mod 3
Dim fY = fieldIndex \ 3
fX += rX 'relative X-Position zur Region
fY += rY 'relative Y-Position zur Region
'Rückgabe
x = fX
y = fY
End Sub
''' <summary>
''' Bestimmt die Position der linken oberen Ecke einer Region im Sudoku.
''' </summary>
''' <param name="regionIndex">Der Index der Region.</param>
''' <param name="x">Rückgabewert. Die X-Koordinate der Region.</param>
''' <param name="y">Rückgabewert. Die Y-Koordinate der Region.</param>
''' <remarks></remarks>
Protected Sub GetRegionPos(regionIndex As Integer, ByRef x As Integer, ByRef y As Integer)
'falscher Index
If regionIndex >= 9 OrElse regionIndex < 0 Then Throw New ArgumentException("Der Index der Region muss kleiner 9 sein.", "regionIndex")
'linke obere Ecke der Region berechnen
Dim rX = regionIndex Mod 3
Dim rY = regionIndex \ 3
rX *= 3 'mit breite multiplizieren
rY *= 3 'mit höhe multiplizieren
'Rückgabe
x = rX
y = rY
End Sub
End Class

sonne75 · 26. August 2013, 15:03

Thilo87 schrieb:

Das fand ich auch schon sehr schwer

Dafür fand ich es sehr interessant.

Ich habe danach noch gegoogelt (weil ich wissen wollte, wie die anderen es gemacht haben) und fand eine Menge Lösungen (die auf dem Konzept vom EDR basierten). Man muss das Rad nicht immer neu erfinden, es gibt schon viele fertige Lösungen, wenn man gerade keine Lust hat sich den Kopf über das aktuelle Problem zu zermattern.

Thilo87 schrieb:

Es muss doch einen allgemeinen Ansatz geben, wie man Schleifenkonstruktionen für bestimmte Zwecke erstellen kann. Eine Reihenfolge, in der man die Schleifen konstruiert und worauf man achten muss...

Ich glaube nicht, dass es sowas gibt, denn die Muster sind doch alle total unterschiedlich und man muss schauen, wo die Schleife jeweils anfängt, wo sie aufhört, wie die Länge der jeweiligen Schleife bestimmt wird, welche Abhängigkeiten die Anfänge und Enden der anderen Schleifen untereinander haben usw. Das ist immer problembezogen und lässt sich m.M.n. nicht pauschalisieren.

Quadsoft · 26. August 2013, 15:05

Artentus schrieb:

Die Primzahlen kann man nicht optimal herausfinden, das ist bis heute ein ungelöstes Problem der Mathematik. Man kann sie nur berechnen, indem man alle Zahlen von 1 bis n durchläuft und eine Primfaktorzerlegung auf sie anwendet. Dies ist aber natürlich extrem rechenaufwändig, da die Zahlen sehr schnell sehr groß werden.

Primzahlen Finden: O(n) (Erathostenes) bzw. O(n/log log n) (Atkin)
Das ist optimal.

Zahl faktorisieren: de.wikipedia.org/wiki/Faktorisierungsverfahren (ungleich aufwändiger)

Wäre es schwierig, Primzahlen zu finden, so würden RSA usw. nicht funktionieren. Primzahlen finden ist einfach (bzw. Primzahlen zu multiplizieren (RSA)), von einer Zahl ihre Primfaktoren zu finden, nicht.

Artentus · 26. August 2013, 15:23

@Quadsoft
Aber auch der Sieb von Atkin benötigt einige Überprüfungen. Optimal wäre O(k), wobei k die Anzahl aller Primzahlen in n ist, und das ist nach heutiger Sicht schlicht unmöglich.

RodFromGermany · 26. August 2013, 17:09

Artentus schrieb:

Die Primzahlen kann man nicht optimal herausfinden, das ist bis heute ein ungelöstes Problem der Mathematik.

Das Sieb des Eratosthenes findet alle Primzahlen von 1 bis n.

Artentus · 26. August 2013, 17:14

@RodFromGermany
Aber nicht optimal, sieh Post über deinem.

RodFromGermany · 26. August 2013, 18:15

@Artentus:: Ist schon klar.
Sneakers, die Lautlosen. Leider konnte er es uns nicht mitteilen.

ErfinderDesRades · 26. August 2013, 20:22

Thilo87 schrieb:

Es muss doch einen allgemeinen Ansatz geben, wie man Schleifenkonstruktionen für bestimmte Zwecke erstellen kann. Eine Reihenfolge, in der man die Schleifen konstruiert und worauf man achten muss... Hoffe ich

nö - da gibts nix allgemeingültiges für alle denkbaren Zwecke.
Die einzige allgemeine Konvention mit Eselsbrücke ist eine für 2d-Arrays, aber sinngemäß auch auf höhere Dimensionen übertragbar:
"Zeile zuerst, Spalte später".
Das kann dich davor bewahren, ein 2d-Array zeilenweise (horizontal) vollzuschreiben, und dann irrtümlich spaltenweise (vertikal) auszulesen.
Und ich stell mir immer Schachbretter vor, oder das Koordinatensystem, also meine Laufvariablen heißen bei sowas immer y, x.
Aber komplexe schleifen sind einfach schwierig.

Was macht man, wenn Zahlenfolgen zu komplex werden, um sie mit Schleifen zu erzeugen?

Was macht man, wenn Zahlenfolgen zu komplex werden, um sie mit Schleifen zu erzeugen?

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

Thilo87 schrieb:

VB.NET-Quellcode

Thilo87 schrieb:

Thilo87 schrieb:

VB.NET-Quellcode

Artentus schrieb:

VB.NET-Quellcode

Thilo87 schrieb:

Thilo87 schrieb:

Artentus schrieb:

Artentus schrieb:

Thilo87 schrieb:

Benutzer online 1

Tags

Ähnliche Themen

5 Benutzer haben hier geschrieben