DNAmind.py

DNAmind.py

"""
Yornik Heyl 1084970 DNAmind
Een kloon van mastermind waar je probeert een DNA string.
van een variabele lengte tussen de 3 en 12 te raden.

"""

"""
Voor het willekeurig kiezen in een lijst en afsluiten
delen van modules importeren.

"""

from sys import exit as afsluit
from random import choice as kies

# Deze dict wordt gebruikt door meerdere functies dus is globaal.
DNADict = {"A": "T", "T": "A", "C": "G", "G": "C", "R": "Y", "Y": "R"}


def game_start():
    """
    Vraagt, valideert en geeft als return waarde een geldige lengte.

    gs_int_in -- de opgegeven lengte tussen 3 en 12

    """

    while True:
        print("\nDe lengte van de DNA-strand mag 4; 5; 6; 7; 8; 9 of 10 zijn.",
              "\nWat is de lengte van de keten?\n",
              "Typ een getal tussen de 3 en de 11 ",
              "of typ een “Q”om het spel te stoppen: ", sep="", end="")
        gs_str_in = input()
        gs_int_in = 0

        if gs_str_in.upper() == "Q":
            game_afsluit(False)

        try:
            gs_int_in = int(gs_str_in)
        except ValueError:
            pass

        if 3 < gs_int_in < 11:
            return gs_int_in
        else:
            print("Helaas, de keuze (", gs_str_in,
                  ") is niet toegestaan. ", sep="")


def game_maak_geheim(gmg_lengte):
    """
    Maakt en heeft als return waarde
    een random DNA string van lengte gmg_lengte.

    gmg_lengte -- De opgegeven lengte van de computer DNA.

    gmg_string -- De willekeurige DNA string.

    """

    gmg_string = ""

    while gmg_lengte:
        gmg_string += kies(list(DNADict.keys()))
        gmg_lengte -= 1

    return gmg_string


def game_main(gm_geheim):
    """
    Voert beurten uit en return uit de functie als kansen op zijn,
    of als de DNA string goed geraden is.

    gm_geheim -- Computer gegenereerde DNA string.

    """

    gm_lengte = len(gm_geheim)
    gm_WXf_dict = {"W": 0, "X": 0, "fout": 0}
    gm_kansen = gm_begin_kansen = {4: 12, 5: 14, 6: 18, 7: 24,
                                   8: 30, 9: 38, 10: 50}[gm_lengte]

    while gm_kansen:
        gm_invoer = game_invoer(gm_lengte)
        gm_hint = game_verglijk(gm_geheim, gm_invoer)
        gm_WXf_dict["X"] += gm_hint[0]
        gm_WXf_dict["W"] += gm_hint[1]
        gm_WXf_dict["fout"] += gm_lengte-(gm_hint[1]+gm_hint[0])

        if gm_geheim == gm_invoer:
            print("\nGefeliciteerd,",
                  "je hebt de complementaire keten geraden.\n",
                  "Het DNA stukje ziet er als volgt uit: \n",
                  "\t", "".join(DNADict[x] for x in gm_geheim),
                  "\n", "\t", gm_invoer,
                  "\n\nJe hebt ", gm_begin_kansen-gm_kansen+1,
                  " keren nodig gehad om alle basen allemaal ",
                  "op de correcte posities in de keten te plaatsen.\n",
                  "Statistiek:\n",
                  "Aantal keren correcte positie goed geraden: ",
                  gm_WXf_dict["X"], "\n"
                  "Aantal keren goed geraden: ",
                  gm_WXf_dict["X"]+gm_WXf_dict["W"], "\n"
                  "Aantal fout geraden: ", gm_WXf_dict["fout"], "\n", sep="")
            return

        print("Resultaat: ", "X"*gm_hint[0], "W"*gm_hint[1], sep="")
        gm_kansen -= 1

    print("\nHelaas je hebt de complementaire keten niet geraden.\n",
          "De keten die ik gemaakt had was: \n",
          "\t", "".join(DNADict[x] for x in gm_geheim), sep="")
    return


def game_invoer(gi_lengte):
    """
    Vraagt een geldige DNA string en valideert die string,
    waarna die ook als return waarde wordt gebruikt.

    gi_lengte -- De opgegeven lengte van de computer DNA.

    gi_str_in -- een gevalideerde string ingevoerd door de gebruiker.

    """

    while True:
        print("\nKies een combinatie. De volgende letters zijn toegestaan:",
              "A; T; C; G; R en\n",
              "Y. Typ alleen een “Q” in als je het spel wilt stoppen.",
              "Schrijf de combinatie\nals 1 woord: ", sep="", end="")
        gi_str_in = input()
        gi_fout_lijst = []

        if gi_str_in.upper() == "Q":
            game_afsluit(False)

        for gi_char_in in gi_str_in:
            if gi_char_in not in list(DNADict.keys()):
                gi_fout_lijst.append(gi_char_in)

        if len(gi_fout_lijst) > 1:
            print("De letters (", "; ".join(gi_fout_lijst),
                  ") zijn niet toegestaan.\nProbeer opnieuw.", sep="")
        elif gi_fout_lijst:
            print("De letter (", gi_fout_lijst[0],
                  ") is niet toegestaan.\nProbeer opnieuw.", sep="")
        elif len(gi_str_in) != gi_lengte:
            print("De lengte van je invoer (", len(gi_str_in),
                  ") en mijn keten (",
                  gi_lengte, ") is niet gelijk!\n",
                  "Probeer opnieuw.", sep="")
        else:
            return gi_str_in


def game_verglijk(gv_geheim, gv_invoer):
    """
    Vergelijkt invoer met pc en geeft list met keer x en w,
    als return.

    gv_geheim -- De computer gegenereerde DNA.
    gv_invoer -- De door gebruiker ingevoerde DNA.

    gv_X -- Hoe Vaak de juiste plek en de juiste letter.
    gv_W -- Hoe Vaak de juiste letter maar de verkeerde plek.

    """

    gv_W = gv_X = 0

    """
    Hier wordt als de letter op zelfde plek staat
    de letter vervangen met een spatie
    in de invoer string en het geheim zodat de lengte wel klopt en
    zodat hij die niet meer telt als verkeerde plek.

    """

    for gv_ind in range(len(gv_geheim)):
        if gv_geheim[gv_ind] == gv_invoer[gv_ind]:
            gv_invoer = gv_invoer.replace(gv_invoer[gv_ind], " ", 1)
            gv_geheim = gv_geheim.replace(gv_geheim[gv_ind], " ", 1)
            gv_X += 1

    """
    Bepalen of letters voorkomt maar niet in juiste plek,
    deze worden ook verwijderd van de invoer en geheim
    string zodat die niet 2 keer wordt gezien als op verkeerde plek.

    """

    for gv_ch in gv_invoer:
        if gv_ch in gv_geheim and gv_ch is not " ":
            gv_invoer = gv_invoer.replace(gv_ch, "", 1)
            gv_geheim = gv_geheim.replace(gv_ch, "", 1)
            gv_W += 1

    return [gv_X, gv_W]


def game_afsluit(ga_vraag):
    """
    Sluit het programma af of return
    uit de functie als de gebruiker niet wil afsluiten.

    ga_vraag -- Boolean die bepaalt of er een vraag gesteld moet worden.

    """

    if ga_vraag:
        while True:
            print("Wil je het opnieuw proberen? J/N: ", end="")
            ga_keuzen = input()
            if ga_keuzen.upper() == "N":
                afsluit("\nTot de volgende keer!")
            elif ga_keuzen.upper() == "J":
                return

    else:
        afsluit("\nHet programma wordt afgesloten")


def main():
    print("Welkom bij DNA mind. Het doel is het correct raden van de",
          "complementaire DNA-strand.",
          "Een DNA-strand bestaat uit basen met de volgende codes:",
          "\tA; T; C; G; R en Y", sep="\n", end="\n")

    """
    Vraagt de lengte aan gebruiker maak een DNA string en geeft dat door
    aan game_main.
    Zodra het DNA bekent is aan de gebruiker vraagt die aan de gebruiker of
    het programma wordt afgesloten.

    """

    while True:
        game_main(game_maak_geheim(game_start()))
        game_afsluit(True)


main()