Kartenlegen - Anfänger mit knackigem Problem

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Zwonimir
User
Beiträge: 4
Registriert: Samstag 14. April 2018, 01:11

Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Zwonimir » Samstag 14. April 2018, 02:12

Erstmal möchte ich mich kurz vorstellen, ich bin Mechatroniker aus Wien und lerne seit einigen Wochen zum Spaß Python 3.

Derzeit habe ich ein Real-Life-Problem, welches ich gerne nutzen würde, um meine Python-Kenntnisse zu vertiefen. An richtigen Problemen knobelt es sich einfach lieber, als an Beispielen aus dem Lehrbuch.
Ich habe ein Kartenspiel, welches ich nicht schaffe zu lösen. Langsam beschleicht mich das Gefühl, dass es keine Lösung geben kann. Wieso also nicht alle Permutationen durchrechnen?

Bild

Zur Vereinfachung versuche ich meine Überlegungen nur anhand der vier Karten oben links zu veranschaulichen:
Ich vergebe Front und Heck der Flugzeuge in den verschieden Farben Primzahlen, positiv und negativ:

Front weiß = +2
Heck weiß = -2
Front gelb = +3
Heck gelb = -3
Front grün = +5
Heck grün = -5
Front blau = +7
Heck blau = -7

Karte 1 oben links stelle ich also von oben beginnend im Uhrzeigersinn als Liste dar=

Code: Alles auswählen

card1 = [-7, -2, 5, 3]


Die Idee ist, dass im Layout die Summe der benachbarten Flugzeugteile so 0 ergeben müsste.
Jetzt kann jede Karte an 9 Positionen liegen, und jeweils 4 Lagen einnehmen. Somit gebe es also 9!*9^4 Möglichkeiten soweit ich richtig rechne, wenn wir nicht in Betracht ziehen, dass zwei Hecks und zwei Fronten nicht zusammen passen.

Wenn wir jetzt der Einfachheit halber nur die vier Karten oben links ansehen, habe ich mal sowas hier fabriziert:

Code: Alles auswählen

card1 = [-7, -2, 5, 3]
card2 = [-3, -5, 7, 2]
card3 = [-5, -3, 5, 2]
card4 = [-7, -2, 7, 3]
result = 1
iteration = 0
drehung = 0


while result != 0 and drehung <4:
    result = card1[1] + card2[3] + card3[1] + card4[3] + card1[2] + card3[0] + card2[2] + card4[0]
    iteration = iteration + 1
   
    if result == 0:
        print ("Bingo! Summe ist",result,"bei Durchlauf",iteration,".")
        print ("Lösung:\nKarte 1:", card1, "\nKarte 2:", card2, "\nKarte 3:", card3, "\nKarte 4:", card4)
    else:
        print (iteration)
        card1.append(card1.pop(0))
        drehung = drehung + 1


Ich drehe die erste Karte maximal vier Mal und berechne jedesmal die Summe der Schnittstellen. Zuerst addiere ich horizontal, danach vertikal. Hier im Code-Beispiel liegen die Karten wie oben im Bild richtig.
Jetzt stehe ich aber vor dem Problem, dass ich Karte 2 um 90 Grad weiter drehen will und dann Karte 1 wieder einmal rundum rotieren muss, usw.
Ich könnte jetzt für jede Karte eine neue Schleife anlegen, aber dass muss doch übersichtlicher gehen?

Meine Idee ist, dass ich alle Karten in eine Liste packe, und dann für jede Karte mit einer Drehungsvariablen arbeite:

Code: Alles auswählen

cards = [[-7, -2, 5, 3],[-3, -5, 7, 2],[-5, -3, 5, 2],[-7, -2, 7, 3]]


Aber was dann?
Wenn die Lage aller Karten einmal durch ist, muss ich eine Positionspermutation durchführen. Dafür habe ich mir schon die Itertools Bibliothek angesehen, damit könnte es vielleicht klappen.

Hat jemand einen Tipp oder eine Idee? Ich bin mir nicht sicher ob ich das nicht zu kompliziert angehe, vielleicht bin ich komplett am Holzweg?

Wenn es keine Lösung für das Game geben sollte, möchte ich es hieb und stichfest wissen. Ich hoffe ihr versteht das? :wink:
Benutzeravatar
kbr
User
Beiträge: 806
Registriert: Mittwoch 15. Oktober 2008, 09:27
Wohnort: Düsseldorf

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon kbr » Samstag 14. April 2018, 08:57

Wenn ich mich nicht verrechnet habe, sollten es n! * 4^n Kombinationen sein.
Benutzeravatar
kbr
User
Beiträge: 806
Registriert: Mittwoch 15. Oktober 2008, 09:27
Wohnort: Düsseldorf

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon kbr » Samstag 14. April 2018, 11:46

Habe mich wohl tatsächlich verrechnet und komme jetzt auf n!^2 * 4^n Permutationen.

Vielleicht stimmt ja auch das nicht und es gibt sicher zudem mehrere Wege die Lösung anzugehen. Mein Ansatz wäre:

  1. import itertools
  2. from enum import Enum
  3.  
  4.  
  5. class Plane(Enum):
  6.     blue_front = 1
  7.     green_front = 2
  8.     yellow_front = 3
  9.     white_front = 4
  10.     blue_tail = -1
  11.     green_tail = -2
  12.     yellow_tail = -3
  13.     white_tail = -4
  14.    
  15.  
  16. # ORDER: top, right, bottom, left
  17. CARDS = [
  18.     [Plane.blue_tail, Plane.white_tail, Plane.green_front, Plane.yellow_front],
  19.     [Plane.yellow_tail, Plane.green_tail, Plane.blue_front, Plane.white_front],
  20.     [Plane.green_tail, Plane.yellow_tail, Plane.green_front, Plane.white_front],
  21.     [Plane.blue_tail, Plane.white_tail, Plane.blue_front, Plane.yellow_front]
  22. ]
  23.  
  24.  
  25. class Tile:
  26.    
  27.     def __init__(self, top, right, bottom, left):
  28.         self.__dict__.update(
  29.             {k:v for k, v in locals().items() if k != 'self'})
  30.        
  31.     def rotate(self):
  32.         self.top, self.right, self.bottom, self.left = (
  33.             self.left, self.top, self.right, self.bottom)
  34.        
  35.     def __str__(self):
  36.         return '{}, {}, {}, {}'.format(
  37.             self.top.name, self.right.name, self.bottom.name, self.left.name)
  38.        
  39.  
  40. class Board:
  41.    
  42.     def __init__(self, tileset):
  43.         self.tileset = tileset
  44.    
  45.     @property
  46.     def is_solution(self):
  47.         # to implement
  48.         return False
  49.    
  50.    
  51. def tileset_variations(tileset):
  52.     # TODO: for every tileset do the proper rotations
  53.     yield Board(tileset)
  54.  
  55.    
  56. def boards(tiles):
  57.     for tileset in itertools.permutations(tiles):
  58.         yield from tileset_variations(tileset)
  59.  
  60.        
  61. def find_solution(tiles):
  62.     for board in boards(tiles):
  63.         if board.is_solution:
  64.             print(board)
  65.             break
  66.     else:
  67.         print("no solution found")
  68.        
  69.        
  70. def main():
  71.     tiles = [Tile(*card) for card in CARDS]
  72.     find_solution(tiles)
  73.    
  74.    
  75. if __name__ == '__main__':
  76.     main()


Vielleicht kannst Du diesen Ansatz nutzen oder findest etwas geeigneteres.
Zwonimir
User
Beiträge: 4
Registriert: Samstag 14. April 2018, 01:11

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Zwonimir » Samstag 14. April 2018, 14:21

Ich muss gestehen, ich bin mit deinem Code erstmal überfordert. Trotzdem danke für die Hilfe, ich schaue mir das sofort an.
Sirius3
User
Beiträge: 7439
Registriert: Sonntag 21. Oktober 2012, 17:20

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Sirius3 » Samstag 14. April 2018, 14:55

@kbr: Du willst den Preis für das kryptischste Programm gewinnen?
  1. class Tile:
  2.     def __init__(self, top, right, bottom, left):
  3.         self.top = top
  4.         self.right = right
  5.         self.bottom = bottom
  6.         self.left = left


Da Du sowieso left, top, usw. nicht verwendest, kannst Du Tile einfach durch »collections.deque« ersetzen. Das hat schon eine »rotate«-Methode.
Benutzeravatar
kbr
User
Beiträge: 806
Registriert: Mittwoch 15. Oktober 2008, 09:27
Wohnort: Düsseldorf

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon kbr » Samstag 14. April 2018, 17:24

@Sirius3: sicher, etwas kryptisch. Aber nützlich bei sehr vielen Parametern. Etwas abgewandelt in eine externe Funktion ausgelagert, genügt dann oft ein Einzeiler zur Initialisierung. Ob ein solches Programmdesign (das 'explicit is better than implicit' nicht einhält) gewünscht wird ist eine andere Frage, wie es dokumentiert wird die nächste, und ob es Dir gefällt wieder eine andere.

Da die Tiles später auf korrekte Orientierung geprüft werden müssen, sind deques dafür nicht gut geeignet.
Sirius3
User
Beiträge: 7439
Registriert: Sonntag 21. Oktober 2012, 17:20

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Sirius3 » Samstag 14. April 2018, 18:43

@kbr: wenn ein Initialisierer viele Parameter hat, dann hat man schon ein Problem. Wenn man etwas anderes macht, außer Parameter zu kopieren, dann hat man einen schwer zu findenden Fehler. Wenn in Deiner Implementierung deques Probleme macht (ich finde gar keine) dann wären Namedtuple eine Alternative.
Benutzeravatar
kbr
User
Beiträge: 806
Registriert: Mittwoch 15. Oktober 2008, 09:27
Wohnort: Düsseldorf

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon kbr » Sonntag 15. April 2018, 10:27

@Sirius3:
wenn ein Initialisierer viele Parameter hat, dann hat man schon ein Problem. Wenn man etwas anderes macht, außer Parameter zu kopieren, dann hat man einen schwer zu findenden Fehler.

Schön und gut, nichts anderes wird gemacht.

Wenn in Deiner Implementierung deques Probleme macht (ich finde gar keine) dann wären Namedtuple eine Alternative.

Natürlich kannst Du keine Probleme finden, schließlich ist die Prüfung der Tiles noch nicht implementiert. Ich weiß auch nicht, ob ich das tun werde. Du kannst es aber gerne mit deques vormachen, wenn Du willst.
Sirius3
User
Beiträge: 7439
Registriert: Sonntag 21. Oktober 2012, 17:20

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Sirius3 » Sonntag 15. April 2018, 18:23

@kbr: ich habe es mit einfachen Strings gelöst. Wobei es, wie der OP schon richtig vermutet, gar keine Lösung gibt.


@Zwonimir: am einfachsten implementiert man das mit einer rekursiven Funktion. Man legt an die erste Position alle Karten in allen Rotationen und ruft die Funktion mit der zweiten Position auf und probiert dort alle restlichen Karten in allen Rotationen und ruft wieder die Funktion mit der dritten Position auf, usw.
bords0
User
Beiträge: 168
Registriert: Mittwoch 4. Juli 2007, 20:40

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon bords0 » Montag 16. April 2018, 16:46

Sirius3 hat geschrieben:@kbr: ich habe es mit einfachen Strings gelöst. Wobei es, wie der OP schon richtig vermutet, gar keine Lösung gibt.

Oh, wie schade. Insbesondere, da ich mehrere ganz ähnliche Puzzles kenne (mit Schildkröten statt Flugzeugen z.B.), die Lösungen haben. Verdammt schwer zu finden.
Benutzeravatar
kbr
User
Beiträge: 806
Registriert: Mittwoch 15. Oktober 2008, 09:27
Wohnort: Düsseldorf

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon kbr » Montag 16. April 2018, 21:07

Habe mir das Puzzle noch einmal angesehen. Statt der theoretisch möglichen n!^2 * 4^n Möglichkeiten kommen nur 4 n! in Betracht, da alle Lösungen mit nicht einheitlichen Kartenausrichtungen ausscheiden. Verbleiben also n! Möglichkeiten multipliziert mit vier, da alle Karten gemeinsam rotiert werden müssen, bevor die nächsten Permutationen durchgerechnet werden. Aber auch dies ist überflüssig, da sich alle diese Rotationen ineinander überführen lassen. Zudem braucht aufgrund der definierten Ausrichtung der Karten nicht unterschieden werden, ob bei gleichfarbigen Kanten Front- oder Heckteile vorliegen. Das vereinfacht die Umsetzung weiter.

Also habe ich meinen Ansatz einmal laufen lassen und wenn man die Ausgangsposition des Puzzles mit

123
456
789

bezeichnet, dann ergibt sich ohne Rotation die Lösung

623
981
547
Zwonimir
User
Beiträge: 4
Registriert: Samstag 14. April 2018, 01:11

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Zwonimir » Dienstag 17. April 2018, 00:26

@kbr
Stimmt, an das gemeinsame rotieren habe ich gar nicht gedacht! Und ja, damit entfällt natürlich auch die Unterscheidung zwischen Front- und Heck... irre, ich sah den Wald vor lauter Bäumen nicht.
Kannst du mir trotzdem beim code ein wenig unter die Arme greifen, ich verstehe im obigen Beispiel nur Bahnhof... Bei der Anwendung der Permutationen habe ich noch leichte Verständnis-Probleme. Außerdem habe ich noch ein weiteres Puzzle, von welchem ich die Lösung zwar kenne, aber es wäre auch interessant ob es mehrere Lösungen gibt. :D
Vielen lieben Dank, ich bin an dem Ding schon verzweifelt. Python ist für die Lösung solcher Alltagsprobleme echt klasse, da macht es gleich viel mehr Spaß, gefällt mir immer besser.

Bild
Benutzeravatar
kbr
User
Beiträge: 806
Registriert: Mittwoch 15. Oktober 2008, 09:27
Wohnort: Düsseldorf

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon kbr » Dienstag 17. April 2018, 09:28

@Zwonimir: Das neue Puzzle scheint aufwendiger zu lösen, da hier einzelne Karten wohl doch rotiert werden können und dadurch nicht nur auf Farbe, sondern auch auf Besen oder Kopf getestet werden muss. Insbesondere aber erhöht sich die Zahl der Permutationen u.U. beträchtlich. Wenn Du zudem wissen möchtest, ob es mehrere Lösungen gibt, musst Du diese alle durchrechnen. Das kann ein Problem werden: Nehmen wir an, die Zahl der möglichen Permutationen beträgt n!^2 * 4^n, dann ergibt dies für n=9 ca. 3,45 * 10^16 Varianten. Das sind zu viele. Du musst also Regeln finden, welche die Zahl der zu betrachtenden Varianten einschränken. Im Falle des Flugzeug-Puzzles war es möglich die Zahl der sinnvollen Kombinationen auf n! einzugrenzen. Bei n = 9 sind dies immer noch 362.880 Varianten.

Meinen Code für die Lösung des Flugzeug-Puzzles füge ich unten an. Diesen kannst Du gerne als Vorlage nutzen.

  1. import itertools
  2.  
  3.  
  4. # ORDER: top, right, bottom, left
  5. CARDS = [
  6.     ['blue', 'white', 'green', 'yellow'],
  7.     ['yellow', 'green', 'blue', 'white'],
  8.     ['white', 'yellow', 'blue', 'green'],
  9.     ['green', 'yellow', 'green', 'white'],
  10.     ['blue', 'white', 'blue', 'yellow'],
  11.     ['yellow', 'white', 'green', 'blue'],
  12.     ['green', 'white', 'blue', 'yellow'],
  13.     ['blue', 'yellow', 'green', 'white'],
  14.     ['green', 'white', 'blue', 'yellow']
  15. ]
  16.  
  17. # assume square board:
  18. SHAPE = int(len(CARDS) ** 0.5)
  19.  
  20.  
  21. class Tile:
  22.    
  23.     def __init__(self, top, right, bottom, left):
  24.         self.top = top
  25.         self.right = right
  26.         self.bottom = bottom
  27.         self.left = left
  28.        
  29.     @property
  30.     def colors(self):
  31.         return ', '.join([self.top, self.right, self.bottom, self.left])
  32.    
  33.  
  34. class Board:
  35.    
  36.     def __init__(self, tileset):
  37.         self.tileset = tileset
  38.                
  39.     def get_neighbours(self, index):
  40.         right = index + 1
  41.         try:
  42.             right_tile = self.tileset[right] if right % SHAPE else None
  43.         except IndexError:
  44.             right_tile = None
  45.         bottom = index + SHAPE
  46.         try:
  47.             bottom_tile = self.tileset[bottom]
  48.         except IndexError:
  49.             bottom_tile = None
  50.         return right_tile, bottom_tile
  51.            
  52.     @property
  53.     def is_solution(self):
  54.        
  55.         def match_right(tile, right_tile):
  56.             return True if not right_tile else tile.right == right_tile.left
  57.            
  58.         def match_bottom(tile, bottom_tile):
  59.             return True if not bottom_tile else tile.bottom == bottom_tile.top
  60.            
  61.         for index, tile in enumerate(self.tileset):
  62.             right_tile, bottom_tile = self.get_neighbours(index)
  63.             if not (match_right(tile, right_tile) and match_bottom(tile, bottom_tile)):
  64.                 return False
  65.         return True
  66.  
  67.     def __str__(self):
  68.         return '\n'.join([tile.colors for tile in self.tileset])
  69.  
  70.    
  71. def boards(tiles):
  72.     for tileset in itertools.permutations(tiles):
  73.         yield Board(tileset)
  74.  
  75.        
  76. def find_solution(tiles):
  77.     for board in boards(tiles):
  78.         if board.is_solution:
  79.             return board
  80.     return "no solution found"
  81.        
  82.        
  83. def main():
  84.     tiles = [Tile(*card) for card in CARDS]
  85.     result = find_solution(tiles)
  86.     print(result)
  87.    
  88.    
  89. if __name__ == '__main__':
  90.     main()
Zwonimir
User
Beiträge: 4
Registriert: Samstag 14. April 2018, 01:11

Re: Kartenlegen - Anfänger mit knackigem Problem

Beitragvon Zwonimir » Dienstag 17. April 2018, 12:52

@kbr

Vielen Dank, das hilft mir definitiv weiter. Aufbauend auf dieser Problemstellung fallen mir jede Menge anderer Dinge ein, die ich später, sobald ich mit Python besser vertraut bin, angehen kann. Danke nochmals! 8)

Wer ist online?

Mitglieder in diesem Forum: Bing [Bot], Sirius3