Add slider_puzzle with tests

skamp91 · skamp91 · commit db42c25931be · 2025-12-05T08:20:45.000+01:00
diff --git a/.coverage b/.coverage
diff --git a/Schieberaetsel/slider_puzzle.py b/Schieberaetsel/slider_puzzle.py
@@ -0,0 +1,164 @@
+import random
+
+SIZE = 4  # 4x4 Feld
+
+
+def print_board(board):
+    """Zeigt das Spielfeld 4x4 in der Konsole an."""
+    for row in range(SIZE):
+        line = []
+        for col in range(SIZE):
+            value = board[row * SIZE + col]
+            if value == 0:
+                line.append(" . ")
+            else:
+                line.append(f"{value:2d}")
+        print(" ".join(line))
+    print()
+
+
+def is_solved(board):
+    """Prüft, ob das Puzzle gelöst ist: 1..15 und 0 (leer) am Ende."""
+    return board == list(range(1, 16)) + [0]
+
+
+def inversion_count(board):
+    """Zählt die Inversionen (für Lösbarkeitsprüfung)."""
+    flat = [x for x in board if x != 0]  # 0 (leer) ignorieren
+    inv = 0
+    for i in range(len(flat)):
+        for j in range(i + 1, len(flat)):
+            if flat[i] > flat[j]:
+                inv += 1
+    return inv
+
+
+def is_solvable(board):
+    """
+    Prüft, ob ein 4x4-Puzzle lösbar ist.
+    Regel für gerade Breite (4):
+    - Board-Breite gerade
+    - Zähl Inversionen (ohne 0)
+    - Bestimme Zeile des leeren Felds von unten (1..4)
+    - Wenn diese Zeile von unten ungerade: Inversionen müssen gerade sein
+    - Wenn diese Zeile von unten gerade: Inversionen müssen ungerade sein
+    """
+    inv = inversion_count(board)
+    zero_index = board.index(0)
+    row_from_top = zero_index // SIZE
+    row_from_bottom = SIZE - row_from_top  # 1..4
+
+    if SIZE % 2 == 0:  # 4 ist gerade
+        if row_from_bottom % 2 == 1:
+            # leere Kachel in Zeile 1,3 von unten -> Inversionen gerade
+            return inv % 2 == 0
+        else:
+            # leere Kachel in Zeile 2,4 von unten -> Inversionen ungerade
+            return inv % 2 == 1
+    else:
+        # Für ungerade Breite: Inversionen müssen gerade sein
+        return inv % 2 == 0
+
+
+def generate_shuffled_board():
+    """Erzeugt ein zufällig gemischtes, aber lösbares Board, das nicht direkt gelöst ist."""
+    board = list(range(1, 16)) + [0]
+    while True:
+        random.shuffle(board)
+        if is_solvable(board) and not is_solved(board):
+            return board
+
+
+def can_move(board, from_index, to_index):
+    """Prüft, ob die Tile an from_index auf die leere Tile an to_index verschoben werden darf."""
+    if to_index < 0 or to_index >= len(board):
+        return False
+    fr_row, fr_col = divmod(from_index, SIZE)
+    to_row, to_col = divmod(to_index, SIZE)
+    # Nachbarschaft in 4er-Manhattan-Distanz
+    return abs(fr_row - to_row) + abs(fr_col - to_col) == 1
+
+
+def move_tile(board, direction):
+    """
+    Versucht, das LEERFELD (0) mit w/a/s/d zu bewegen.
+
+    w = leer nach oben  (tauscht mit Feld darüber)
+    s = leer nach unten (tauscht mit Feld darunter)
+    a = leer nach links (tauscht mit Feld links daneben)
+    d = leer nach rechts (tauscht mit Feld rechts daneben)
+
+    Wenn das Leerfeld am Rand ist (oben/links/rechts/unten) und
+    man in diese Richtung drückt, passiert nichts (False).
+    """
+    zero_index = board.index(0)
+    row, col = divmod(zero_index, SIZE)
+
+    if direction == "w":
+        # oben geht nicht weiter hoch
+        if row == 0:
+            return False
+        target_row, target_col = row - 1, col
+
+    elif direction == "s":
+        # unten geht nicht weiter runter
+        if row == SIZE - 1:
+            return False
+        target_row, target_col = row + 1, col
+
+    elif direction == "a":
+        # links geht nicht weiter nach links
+        if col == 0:
+            return False
+        target_row, target_col = row, col - 1
+
+    elif direction == "d":
+        # rechts geht nicht weiter nach rechts
+        if col == SIZE - 1:
+            return False
+        target_row, target_col = row, col + 1
+
+    else:
+        # ungültige Taste
+        return False
+
+    target_index = target_row * SIZE + target_col
+
+    # Hier sind wir sicher im Grid und der Nachbar liegt direkt an
+    board[zero_index], board[target_index] = board[target_index], board[zero_index]
+    return True
+
+
+def main():
+    print("4x4 Schieberätsel (15-Puzzle)")
+    print("Ziel: 1-15 sortiert, leeres Feld unten rechts.\n")
+    print("Steuerung: w = hoch, s = runter, a = links, d = rechts, q = beenden\n")
+
+    board = generate_shuffled_board()
+    moves = 0
+
+    while True:
+        print_board(board)
+        if is_solved(board):
+            print(f"Glückwunsch! Du hast das Puzzle in {moves} Zügen gelöst!")
+            break
+
+        cmd = input("Zug (w/a/s/d/q): ").strip().lower()
+        if cmd == "q":
+            print("Spiel beendet.")
+            break
+
+        if cmd in ("w", "a", "s", "d"):
+            if move_tile(board, cmd):
+                moves += 1
+            else:
+                print("Ungültiger Zug!")
+        else:
+            print("Bitte w, a, s, d oder q eingeben.")
+
+
+# ✨ Ohne diesen Block startet das Programm NICHT!
+if __name__ == "__main__":
+    main()
+else:
+    print("TEST")
diff --git a/Schieberaetsel/test_slider_puzzle.py b/Schieberaetsel/test_slider_puzzle.py
@@ -0,0 +1,140 @@
+# test_slider_puzzle.py
+import slider_puzzle as sp
+
+
+def test_is_solved_true_for_solved_board():
+    board = list(range(1, 16)) + [0]
+    assert sp.is_solved(board) is True
+
+
+def test_is_solved_false_for_unsolved_board():
+    board = [1,2,3,4,5,6,7,8,9,10,11,12,13,15,14,0]
+    assert sp.is_solved(board) is False
+
+
+def test_inversion_count_solved_board_zero():
+    board = list(range(1, 16)) + [0]
+    assert sp.inversion_count(board) == 0
+
+
+def test_inversion_count_simple_inversion():
+    board = [1,2,3,4,5,6,7,8,9,10,11,12,13,15,14,0]
+    assert sp.inversion_count(board) == 1
+
+
+def test_is_solvable_for_solved_board():
+    board = list(range(1, 16)) + [0]
+    assert sp.is_solvable(board) is True
+
+
+def test_is_solvable_false_for_known_unsolvable():
+    board = [1,2,3,4,5,6,7,8,9,10,11,12,13,15,14,0]
+    assert sp.is_solvable(board) is False
+
+
+def test_generate_shuffled_board_properties():
+    board = sp.generate_shuffled_board()
+    assert len(board) == 16
+    assert sorted(board) == list(range(16))  # 0..15
+    assert sp.is_solvable(board) is True
+    assert sp.is_solved(board) is False
+
+
+def test_can_move_neighbors_true():
+    board = [1,2,3,4,
+             5,6,7,8,
+             9,10,0,11,
+             13,14,15,12]
+    # leeres Feld Index 10
+    assert sp.can_move(board, 9, 10) is True
+    assert sp.can_move(board, 11, 10) is True
+    assert sp.can_move(board, 6, 10) is True
+    assert sp.can_move(board, 14, 10) is True
+
+
+def test_can_move_diagonal_false():
+    board = [1,2,3,4,
+             5,6,7,8,
+             9,10,0,11,
+             13,14,15,12]
+    assert sp.can_move(board, 5, 10) is False  # diagonal
+
+
+def test_can_move_wrap_around_false():
+    board = [1,2,3,4,
+             5,6,7,8,
+             9,10,0,11,
+             13,14,15,12]
+    assert sp.can_move(board, 7, 8) is False
+
+
+def test_move_tile_valid_and_board_changes():
+    board = [1,2,3,4,
+             5,6,7,8,
+             9,10,0,11,
+             13,14,15,12]
+    zero_before = board.index(0)
+    moved = sp.move_tile(board, "a")  # versucht, 0 nach rechts zu bewegen
+    assert moved is True
+    assert board.index(0) != zero_before
+
+
+def test_move_tile_invalid_direction():
+    board = list(range(1, 16)) + [0]
+    copy = board.copy()
+    moved = sp.move_tile(board, "x")
+    assert moved is False
+    assert board == copy
+
+def test_move_tile_blocked_at_edges():
+    # Leerfeld oben links: 'w' und 'a' dürfen nichts tun
+    board_top_left = [
+        0,  2,  3,  4,
+        5,  6,  7,  8,
+        9, 10, 11, 12,
+        13,14, 15, 1
+    ]
+    copy_top_left = board_top_left.copy()
+    assert sp.move_tile(board_top_left, "w") is False
+    assert board_top_left == copy_top_left
+    assert sp.move_tile(board_top_left, "a") is False
+    assert board_top_left == copy_top_left
+
+    # Leerfeld oben rechts: 'w' und 'd' dürfen nichts tun
+    board_top_right = [
+        1,  2,  3,  0,
+        5,  6,  7,  8,
+        9, 10, 11, 12,
+        13,14, 15, 4
+    ]
+    copy_top_right = board_top_right.copy()
+    assert sp.move_tile(board_top_right, "w") is False
+    assert board_top_right == copy_top_right
+    assert sp.move_tile(board_top_right, "d") is False
+    assert board_top_right == copy_top_right
+
+    # Leerfeld unten links: 's' und 'a' dürfen nichts tun
+    board_bottom_left = [
+        1,  2,  3,  4,
+        5,  6,  7,  8,
+        9, 10, 11, 12,
+        0, 14, 15, 13
+    ]
+    copy_bottom_left = board_bottom_left.copy()
+    assert sp.move_tile(board_bottom_left, "s") is False
+    assert board_bottom_left == copy_bottom_left
+    assert sp.move_tile(board_bottom_left, "a") is False
+    assert board_bottom_left == copy_bottom_left
+
+    # Leerfeld unten rechts: 's' und 'd' dürfen nichts tun
+    board_bottom_right = [
+        1,  2,  3,  4,
+        5,  6,  7,  8,
+        9, 10, 11, 12,
+        13,14, 15, 0
+    ]
+    copy_bottom_right = board_bottom_right.copy()
+    assert sp.move_tile(board_bottom_right, "s") is False
+    assert board_bottom_right == copy_bottom_right
+    assert sp.move_tile(board_bottom_right, "d") is False
+    assert board_bottom_right == copy_bottom_right
