Maximale Zügezahl beim Springerschachspiel

1 Lösung

#166

Fortgeschrittener - Python von hollst - 02.09.2017 um 16:50 Uhr

Wir betrachten ein vom Schachspiel abgeleitetes Spiel, bei dem
lediglich die vier Springer mitwirken (Abb. 1). Das Spiel hat
weder Gewinner noch Verlierer (wird manchmal als Lernübung für das
Schachspiel verwendet, insbesondere, um die eigenartige Gangart
des Springers zu verinnerlichen). Die vier Springer stehen in ihrer
normalen Ausgangsstellung und können in der beim Schach üblichen
Art ziehen und schlagen. Weitere Figuren sind auf dem Schachbrett
nicht vorhanden. Weiß und Schwarz ziehen abwechselnd, Weiß beginnt.

Eine Partie ist beended, wenn eine der zwei folgenden Bedingungen
erfüllt ist:

1. Einer der zwei Spieler hat lediglich nur noch einen Springer
- in diesem Fall könnte man auch vereinbaren, dass der Spieler
mit den zwei Springern als Sieger gewertet wird.
2. Es ist mit dem letzten Zug eine Stellug entstanden, die im
Verlaufe des Spieles breits einmal zuvor auf dem Brett war.

Die Programmieraufgabe besteht darin, die hinsichtlich der
Zügezahl längst mögliche Zugfolge(n) zu ermitteln.

Bitte melden Sie sich an um zur Aufgabenbeschreibung eine Frage zu stellen.

Frage stellen

Bitte melden Sie sich an um eine Lösung einzureichen.

Lösung einreichen

von satn1241 (3090 Punkte) - 15.05.2020 um 21:23 Uhr

Python-Code

# Das Proramm führt das Spiel 100.000 Mal mit zufälligen Zügen durch 
# und gibt die höchste Anzahl an Zügen ohne Wiederholung und Schlagen an.
# Mein Rekord liegt bei 357

def ziehen():
    from random import randint
    zahl = randint(1, 8)
    if zahl == 1:
        zug = (-2, -1)
    if zahl == 2:
        zug = (-2, 1)
    if zahl == 3:
        zug = (2, -1)
    if zahl == 4:
        zug = (2, 1)
    if zahl == 5:
        zug = (-1, -2)
    if zahl == 6:
        zug = (-1, 2)
    if zahl == 7:
        zug = (1, -2)
    if zahl == 8:
        zug = (1, 2)
    return zug


def test_zug_imfeld(figur, zug):
    if figur[0] + zug[0] < 0:
        return False
    if figur[0] + zug[0] > 7:
        return False
    if figur[1] + zug[1] < 1:
        return False
    if figur[1] + zug[1] > 8:
        return False
    else:
        return True


def test_feld_besetzt(figur1, figur2, zug):
    if figur1[0] + zug[0] == figur2[0] and figur1[1] + zug[1] == figur2[1]:
        return False


def neue_position(figur1, figur2):
    while True:
        zug = ziehen()
        if test_zug_imfeld(figur1, zug):
            break
        if test_feld_besetzt(figur1, figur2, zug):
            break
    figur1[0] += zug[0]
    figur1[1] += zug[1]
    return figur1


def figur_wahl(figur1, figur2):
    from random import randint
    springer_wahl = randint(1, 2)
    if springer_wahl == 1:
        return figur1
    if springer_wahl == 2:
        return figur2


def spiel_W():  # noch eigene Figur schlagen herausnehmen
    global SW1, SW2
    figur = figur_wahl(SW1, SW2)
    if figur == SW1:
        SW1 = neue_position(SW1, SW2)
    if figur == SW2:
        SW2 = neue_position(SW2, SW1)


def spiel_S():
    global SS1, SS2
    figur = figur_wahl(SS1, SS2)
    if figur == SS1:
        SS1 = neue_position(SS1, SS2)
    if figur == SS2:
        SS2 = neue_position(SS2, SS1)


def check_schlagen(stellung):
    if stellung[0] == stellung[2]:
        return False
    if stellung[0] == stellung[3]:
        return False
    if stellung[1] == stellung[2]:
        return False
    if stellung[1] == stellung[3]:
        return False
    else:
        return True



def spielen():
    from copy import deepcopy
    neue_stellung1 = deepcopy(stellung)
    alle_stellungen.append(neue_stellung1)
    zuege = 0
    while True:
        spiel_W()
        zuege += 1
        if alle_stellungen.count(stellung) > 0:
            # print("Wiederholung")
            alle_stellungen.append(stellung)
            break
        if not check_schlagen(stellung):
            # print("Weiß gewinnt")
            alle_stellungen.append(stellung)
            break
        neue_stellung1 = deepcopy(stellung)
        alle_stellungen.append(neue_stellung1)
        spiel_S()
        zuege += 1
        if alle_stellungen.count(stellung) > 0:
            # print("Wiederholung")
            alle_stellungen.append(stellung)
            break
        if not check_schlagen(stellung):
            # print("Schwarz gewinnt")
            alle_stellungen.append(stellung)
            break
        neue_stellung2 = deepcopy(stellung)
        alle_stellungen.append(neue_stellung2)

    # print(zuege)
    # print(alle_stellungen)
    return zuege


anzahl_zuege = []

for i in range(0, 100000):
    #               SW1     SW2    SS1    SS2
    stellung = [[7, 2], [7, 7], [0, 2], [0, 7]]
    alle_stellungen = []
    SW1 = stellung[0]
    SW2 = stellung[1]
    SS1 = stellung[2]
    SS2 = stellung[3]
    anzahl_zuege.append(spielen())

print(anzahl_zuege)
print(max(anzahl_zuege))