diff --git a/README.md b/README.md index 366c0ff..17d0fcf 100644 --- a/README.md +++ b/README.md @@ -51,3 +51,15 @@ Učí profesor Kubis a docent Veškrna. + [code_gen](code_gen) + [site_gen](site_gen) +## projekty/star_wars ++ [matej](projekty/star_wars/matej) ++ [petr](projekty/star_wars/petr) + +## projekty/tic_tac_toe ++ [katka](projekty/tic_tac_toe/katka) ++ [matej](projekty/tic_tac_toe/matej) ++ [ondra](projekty/tic_tac_toe/ondra) ++ [petr](projekty/tic_tac_toe/petr) ++ [tobias](projekty/tic_tac_toe/tobias) ++ [vlasta](projekty/tic_tac_toe/vlasta) + diff --git a/projekty/star_wars/matej.md b/projekty/star_wars/matej.md new file mode 100644 index 0000000..e33a56f --- /dev/null +++ b/projekty/star_wars/matej.md @@ -0,0 +1,81 @@ +# matej.py +```python +import requests + +# wtf jsou tyhle obrovsky mezery + +def ship_detail(ShipName): + url = 'https://swapi.co/api/starships' + r = requests.get(url).json() # tohle je mega gay, protoze si nacitas vsechny data + res = r['results'] # a sortujes v pythonu, misto toho abys si upravil + ship_absolute = '' # url - mel bys to jednodussi, rychlejsi, prehlednejsi + for ship in res: # a pametove efektivnejsi + if ship['name'] == ShipName: # lol + ship_absolute = ship + break + return[ship_absolute['name'], ship_absolute['model'], [requests.get(film).json()['title'] for film in ship_absolute['films']]] # sexy + +def species_detail(SpeciesName): + url = 'https://swapi.co/api/species' # stejnej problem jako nahore + r = requests.get(url).json() + res = r['results'] + species_absolute = '' + for specie in res: + if specie['name'] == SpeciesName: + species_absolute = specie + break + list_title = [requests.get(film).json()['title'] for film in species_absolute['films']] + list_id = [requests.get(film).json()['episode_id'] for film in species_absolute['films']] + sort = sorted(zip(list_id, list_title)) + return [species_absolute['name'], species_absolute['classification'], species_absolute['designation'], requests.get(species_absolute['homeworld']).json()['name'], sort] # sexy + + +def person_detail(Name): # a zase + url = 'https://swapi.co/api/people' + r = requests.get(url).json() + res = r['results'] + person_absolute = '' + for person in res: + if person['name'] == Name: + person_absolute = person + break + + list_title = [requests.get(film).json()['title'] for film in person_absolute['films']] + list_id = [requests.get(film).json()['episode_id'] for film in person_absolute['films']] + sort = sorted(zip(list_id, list_title)) + return [person_absolute['name'], person_absolute['gender'], requests.get(person_absolute['homeworld']).json()['name'], sort] # sexy + +def Crawl(Film_Title): # a poctvrte + url = 'https://swapi.co/api/films' + r = requests.get(url).json() + res = r['results'] + film_absolute = '' + for film in res: + if film['title'] == Film_Title: + film_absolute = film + break + print(film_absolute['opening_crawl']) + + +def film_detail(FilmIdentifier): # a popate :D + url = 'https://swapi.co/api/films' + r = requests.get(url).json() + res = r['results'] + film_absolute = '' + for film in res: + if film['title'] == FilmIdentifier or film['episode_id'] == FilmIdentifier: + film_absolute = film + break + list_char = [requests.get(char).json() for char in film_absolute['characters']] + list_ship = [requests.get(char).json() for char in film_absolute['starships']] + return [film_absolute['title'], film_absolute['director'], film_absolute['episode_id'], sorted([ch['name'] for ch in list_char]), sorted([ch['name'] for ch in list_ship])] # sexy + + +if __name__ == '__main__': + print(ship_detail('Executor')) + print(species_detail('Hutt')) + print(person_detail('Luke Skywalker')) + print(film_detail(3)) + print(film_detail('A New Hope')) + Crawl('The Phantom Menace') +``` \ No newline at end of file diff --git a/projekty/star_wars/petr.md b/projekty/star_wars/petr.md new file mode 100644 index 0000000..f1180b0 --- /dev/null +++ b/projekty/star_wars/petr.md @@ -0,0 +1,112 @@ +# petr.py +```python +import requests +import json +import time + + +# helper functions +def get_json(url): + return requests.get(url).json() + + +def get_film_titles(films): + list_films = [] + for film in films: + list_films.append(get_json(film)["title"]) + return list_films + + +def get_character_names(characters): + list_characters = [] + for character in characters: + list_characters.append(get_json(character)["name"]) + + return sorted(list_characters) + + +def get_spaceship_names(spaceships): + list_spaceships = [] + for spaceship in spaceships: + list_spaceships.append(get_json(spaceship)["name"]) + + return sorted(list_spaceships) + + +def get_film_info(film): + list_characters = get_character_names(film["characters"]) + list_spaceships = get_spaceship_names(film["starships"]) + return [film["title"], film["director"], film["episode_id"], + list_characters, list_spaceships] + + +def ship_detail(shipname): + web = get_json("https://swapi.co/api/starships/?search={}".format(shipname))["results"] + list_results = [] + for result in web: + list_films = get_film_titles(result["films"]) + list_results.append( + [result["name"], result["model"], result["starship_class"], result["hyperdrive_rating"], list_films]) + + return list_results + + +def species_detail(speciesname): + web = get_json("https://swapi.co/api/species/?search={}".format(speciesname))["results"] + list_results = [] + for result in web: + list_films = get_film_titles(result["films"]) + homeworld = get_json(result["homeworld"])["name"] + list_results.append( + [result["name"], result["classification"], result["designation"], homeworld, list_films]) + + return list_results + + +def person_detail(name): + web = get_json("https://swapi.co/api/people/?search={}".format(name))["results"] + list_results = [] + for result in web: + list_films = get_film_titles(result["films"]) + homeworld = get_json(result["homeworld"])["name"] + list_results.append( + [result["name"], result["gender"], homeworld, list_films]) + + return list_results + + +def film_detail(filmidentifier, id_type="ep_id"): + list_results = [] + if id_type == "ep_id": + web = get_json("https://swapi.co/api/films/{}".format(filmidentifier)) + list_results.append(get_film_info(web)) + elif id_type == "title": + web = get_json("https://swapi.co/api/films/?search={}".format(filmidentifier))["results"] + for result in web: + list_results.append(get_film_info(result)) + + else: + raise Exception('Bad film id type') + + return list_results + + +def crawl(title): + web = get_json("https://swapi.co/api/films/?search={}".format(title))["results"] + for result in web: + film_crawl = result["opening_crawl"].split("\r\n") + for line in film_crawl: + print(line) + time.sleep(1) + + +if __name__ == "__main__": + # testing program. runs only if run as main + print(ship_detail("Imperial shuttle")) + print(species_detail("Hutt")) + print(person_detail("Owen Lars")) + + print(film_detail("The Phantom Menace", "title")) + print(film_detail(2)) + + crawl("A New Hope")``` \ No newline at end of file diff --git a/projekty/tic_tac_toe/katka.md b/projekty/tic_tac_toe/katka.md new file mode 100644 index 0000000..54c6e3d --- /dev/null +++ b/projekty/tic_tac_toe/katka.md @@ -0,0 +1,76 @@ +# katka.py +```python +plocha = [[" ", " ", " "], [" ", " ", " "], [" ", " ", " "]] # globaly - spatnej zvyk +hrac = "X" + +def kontrola(): # kontrola vsech moznosti; celkem v pohode tady ale slo to vyresit chytreji + # kdybychom najednou zmenili plochu z 3x3 na 4x4 tak uz by to nefungovalo + # jinak je to celkem hezky + if plocha[0][0] == plocha[0][1] and plocha[0][1] == plocha[0][2] and plocha[0][2] != " ": + print("Vyhrál " + hrac) # print ve funkci, ne moc idealni z funkcionalniho hlediska + # protoze `hrac` je tady globalni promenna; nevadi, to jeste budeme resit; v takhle + # malym programu to ani tolik nevadi + return True + if plocha[1][0] == plocha[1][1] and plocha[1][1] == plocha[1][2] and plocha[1][2] != " ": + print("Vyhrál " + hrac) + return True # skvele ze je tady return, diky tomuhle se utece z funkce aniz by se kontroloval zbytek + if plocha[2][0] == plocha[2][1] and plocha[2][1] == plocha[2][2] and plocha[2][2] != " ": + #if plocha[2][0] == plocha[2][1] == plocha[2][2] != " ": + # ^ ekvivalence, asi trochu hezci + # je to ale specifikum pythonu ze to funguje + # takze tohle je ve skutecnosti v poradku + print("Vyhrál " + hrac) + return True + if plocha[0][0] == plocha[1][0] and plocha[1][0] == plocha[2][0] and plocha[2][0] != " ": + print("Vyhrál " + hrac) + return True + if plocha[0][1] == plocha[1][1] and plocha[1][1] == plocha[2][1] and plocha[2][1] != " ": + print("Vyhrál " + hrac) + return True + if plocha[0][2] == plocha[1][2] and plocha[1][2] == plocha[2][2] and plocha[2][2] != " ": + print("Vyhrál " + hrac) + return True + if plocha[0][0] == plocha[1][1] and plocha[1][1] == plocha[2][2] and plocha[2][2] != " ": + print("Vyhrál " + hrac) + return True + if plocha[0][2] == plocha[1][1] and plocha[1][1] == plocha[2][0] and plocha[2][0] != " ": + print("Vyhrál " + hrac) + return True + return False + +def vytiskni(): # tady vsechno super + print(plocha[0][0] + "|" + plocha[0][1] + "|" + plocha[0][2]) + print("-+-+-") + print(plocha[1][0] + "|" + plocha[1][1] + "|" + plocha[1][2]) + print("-+-+-") + print(plocha[2][0] + "|" + plocha[2][1] + "|" + plocha[2][2]) + +vytiskni() +while True: + x = input() + y = x.split() # asi bych tohle zkratil, ta promenna x tam tak trochu visi bez cile + # taky by mozna bylo chytry si rovnou vzit prvni 2 prvky z `x.split()` + # napsal bych: + #x = input() + #x = x.split() + # nebo: + #x = input().split() + # k tomu ze bych rovnou vzal 2 prvky tak bych napsal: + #x = input().split() + #y = int(x[0]) + #x = int(x[1]) + if plocha[int(y[0])][int(y[1])] == " ": # tady by bylo: `plocha[y][x] == " "` + plocha[int(y[0])][int(y[1])] = hrac + if kontrola(): # tohle se mi libi - hromada lidi by napsala: + # `if kontrola() == True:` + vytiskni() + break + if hrac == "X": # lze napsat hezcejc, ale to jeste neumite + hrac = "O" + else: + hrac = "X" + vytiskni() +# sice to vypada ze to hodne hatim ale libi se mi to +# je to presne jak jsem si to predstavoval +# cili exactly co jsem od vas ocekaval +``` \ No newline at end of file diff --git a/projekty/tic_tac_toe/matej.md b/projekty/tic_tac_toe/matej.md new file mode 100644 index 0000000..7a4753a --- /dev/null +++ b/projekty/tic_tac_toe/matej.md @@ -0,0 +1,216 @@ +# matej.py +```python +grid = [ + ["", "", ""], + ["", "", ""], + ["", "", ""] +] + +x = False +# nazev promenny nic nerika +# taky ta definice je kilometry od mista kde se +# ta promenna pouzije :( + +def play1(): # dve oddeleny funkce pro ruzne hrace + # debilni protoze a) nemuzeme snadno pridat hrace + # b) opakovani kodu + + global x_input_1 + global y_input_1 + # oof, globaly + + true_x = False # lol, to jsou nazvy. + true_y = False # procs tam nenapsal rovnou: + #false_y = True + # :D + # ale vazne by bylo lepsi: + #bool_y = False + true_taken_1 = False + + print("Now will play player 1") # english + + while not true_taken_1: # celkem elegantni, az na to ze moc ne + # chytrejsi by bylo volat funkci na taken ale to by + # vyzadovalo premyslet o strukture programu, vid ze jo? + + while not true_x: + + x_input_1 = int(input("Enter x axis position (1, 2, 3): ")) + + if x_input_1 == 1: + true_x = True + elif x_input_1 == 2: + true_x = True + elif x_input_1 == 3: + true_x = True + else: + print("Try again (1, 2, 3)") # eeeh, zdaleka ne moc elegantni + + while not true_y: + + y_input_1 = int(input("Enter y axis position (1, 2, 3): ")) + + if y_input_1 == 1: + true_y = True + elif y_input_1 == 2: + true_y = True + elif y_input_1 == 3: + true_y = True + else: + print("Try again (1, 2, 3)") + + if grid[x_input_1 - 1][y_input_1 - 1] not in ("X", "O"): + true_taken_1 = True + + else: + print("That position is taken") + true_x = False + true_y = False + + grid[x_input_1 - 1][y_input_1 - 1] = "X" + + print(grid[0][0] + " | " + grid[1][0] + " | " + grid[2][0] + "\n" + "__" + " " + "__" + " " + "__" + + "\n" + grid[0][1] + " | " + grid[1][1] + " | " + grid[2][1] + "\n" + "__" + " " + "__" + " " + "__" + + "\n" + grid[0][2] + " | " + grid[1][2] + " | " + grid[2][2]) # celkem v pohode lol + +def play2(): + print("Now will play player 2\n") + global x_input_2 + global y_input_2 + # globaly fuj fuj + true_taken_2 = False + true_x_1 = False + true_y_1 = False + + while not true_taken_2: + while not true_x_1: + + x_input_2 = int(input("Enter x axis position (1, 2, 3): ")) + + if x_input_2 == 1: + true_x_1 = True + elif x_input_2 == 2: + true_x_1 = True + elif x_input_2 == 3: + true_x_1 = True + else: + print("Try again (1, 2, 3)") + + while not true_y_1: + y_input_2 = int(input("Enter y axis position (1, 2, 3): ")) + + if y_input_2 == 1: + true_y_1 = True + elif y_input_2 == 2: + true_y_1 = True + elif y_input_2 == 3: + true_y_1 = True + else: + print("Try again (1, 2, 3)") + + if grid[x_input_2 - 1][y_input_2 - 1] not in ("X", "O"): + true_taken_2 = True + + else: + print("That position is taken") + true_x_1 = False + true_y_1 = False + + grid[x_input_2 - 1][y_input_2 - 1] = "O" + + print(grid[0][0] + " | " + grid[1][0] + " | " + grid[2][0] + "\n" + "__" + " " + "__" + " " + "__" + + "\n" + grid[0][1] + " | " + grid[1][1] + " | " + grid[2][1] + "\n" + "__" + " " + "__" + " " + "__" + + "\n" + grid[0][2] + " | " + grid[1][2] + " | " + grid[2][2]) + +def win(): + global x + # globaly fuj fuj + x0_y0 = grid[0][0] # <-- gay + x0_y1 = grid[0][1] # <-- gay + x0_y2 = grid[0][2] # <-- gay + x1_y0 = grid[1][0] # <-- gay + x1_y1 = grid[1][1] # <-- gay + x1_y2 = grid[1][2] # <-- gay + x2_y0 = grid[2][0] # <-- gay + x2_y1 = grid[2][1] # <-- gay + x2_y2 = grid[2][2] # <-- gay + + if x0_y0 == x0_y1 == x0_y2 and x0_y0 == "X": + print("Player 1 wins") + x = True + + elif x1_y0 == x1_y1 == x1_y2 and x1_y0 == "X": + print("Player 1 wins") + x = True + elif x2_y0 == x2_y1 == x2_y2 and x2_y0 == "X": + print("Player 1 wins") + x = True + elif x0_y0 == x1_y0 == x2_y0 and x0_y0 == "X": + print("Player 1 wins") + x = True + elif x0_y1 == x1_y1 == x0_y2 and x0_y1 == "X": + print("Player 1 wins") + x = True + elif x0_y2 == x1_y2 == x2_y2 and x0_y2 == "X": + print("Player 1 wins") + x = True + elif x0_y0 == x1_y1 == x2_y2 and x0_y0 == "X": + print("Player 1 wins") + x = True + elif x2_y0 == x1_y1 == x0_y2 and x2_y0 == "X": + print("Player 1 wins") + x = True + + elif x0_y0 == x0_y1 == x0_y2 and x0_y0 == "O": + print("Player 2 wins") + x = True + elif x1_y0 == x1_y1 == x1_y2 and x1_y0 == "O": + print("Player 2 wins") + x = True + elif x2_y0 == x2_y1 == x2_y2 and x2_y0 == "O": + print("Player 2 wins") + x = True + elif x0_y0 == x1_y0 == x2_y0 and x0_y0 == "O": + print("Player 2 wins") + x = True + elif x0_y1 == x1_y1 == x0_y2 and x0_y1 == "O": + print("Player 2 wins") + x = True + elif x0_y2 == x1_y2 == x2_y2 and x0_y2 == "O": + print("Player 2 wins") + x = True + elif x0_y0 == x1_y1 == x2_y2 and x0_y0 == "O": + print("Player 2 wins") + x = True + elif x2_y0 == x1_y1 == x0_y2 and x2_y0 == "O": + print("Player 2 wins") + x = True + # top kek, jeste jsi ani neresil to ze vlastne nemusis rozlisovat + # mezi X a O, staci ze jsou stejny. dalo se to vymyslet mnohem + # jednoduseji, o tom byl ten ukol + +while not x: # mega gay, tyhle casti programu se rika + # mainloop, a princip je takovej ze kdyz + # hra skonci tak breakujes. To tady pochopitelne + # nemas, protoze tvoje kazda funkce je void (a nic nevraci) + # takze vystup je printovej. To je mega gay, protoze nevyuzivas + # potencial funkci a taky print je vedlejsi efekt o kterym jsem + # se bavil ze je to presne to co nechces + + # takze ten program sice pozna ze nekdo vyhral, ale neskonci + win() + play1() + + win() + if not x: + play2() + +print("End of the game") + +# krasnej priklad toho, proc jsem vam rikal abyste si nejdriv program +# promysleli nez ho naprogramujete + +# na druhou stranu respekt zes to dotahl i presto ze je to tak necitelny +# a taky diky tobe mam o cem mluvit :D + +``` \ No newline at end of file diff --git a/projekty/tic_tac_toe/ondra.md b/projekty/tic_tac_toe/ondra.md new file mode 100644 index 0000000..cc9b7a8 --- /dev/null +++ b/projekty/tic_tac_toe/ondra.md @@ -0,0 +1,145 @@ +# ondra.py +```python +# Zdar, tady Lukáš +# Taky je v tvém kódu přímo vidět nějaký ten vliv toho C# nebo tak něčeho, +# protože pojmenováváš věci s velkým písmenem na začátku. Dále jsi také s pojmenováváním trošku nekonzistentní. +# V Pythonu jsou zvyky trochu jiné, ale chyba to samozřejmě není. + +# Dobrý, akorát k tomu mám jednu připomínku – +# tady ukládáš data rovnou v jejich výsledném formátu, ale smysluplnější je ukládat +# data v nějakém jednodušším formátu, který je pak před vypsáním do výsledného formátu převeden, +# protože takto musíš porovnávat políčka s jejich výslednými formáty +board = ["[ ]", "[ ]", "[ ]", + "[ ]", "[ ]", "[ ]", + "[ ]", "[ ]", "[ ]"] +player_2 = False +Hra = True +kolo = 1 +winner_2 = None + +# Lukáš - Docela fajn, vypadá to čitelně +#spuští funkce ve správném pořadí +def tah(): + Tah = Input_pos() + while Input_chack(Tah) == False: # gay protoze input chack vraci bool - Dawid + Tah = Input_pos() + Move(Tah) + Show() + +#zobarí hrací desku +def Show(): # Lukáš - bylo by lepší, kdyby Show bralo board jako argument + print(board[0], board[1], board[2], sep="") + print(board[3], board[4], board[5], sep="") + print(board[6], board[7], board[8], sep="") + print("_________") + +#vrátí array s xy informací o tahu +def Input_pos(): + player = int(player_2) + 1 + print("hráč", player, "hraje") + vert = int(input("zadej sloupec (max 3)")) + while vert > 3: + print("vstup nesmí být větší než 3") + vert = int(input("zadej sloupec (max 3)")) + hor = int(input("zadej řádek (max 3)")) + while hor > 3: + hor = int(input("zadej řádek (max 3)")) + print("vstup nesmí být větší než 3") + tah = [vert, hor] + return To_Index(tah) + +#změní políčko +# Lukáš - tady bereš tah jako argument, ale proč ne board? je to pak takový podivně globální +def Move(tah): + if Input_chack(tah): + if player_2: + x = "O" + else: + x = "X" + board[tah] = "[" + x + "]" + else: + pass + +# Lukáš - a v tvém komentáři je děsivá pravopisná chyba :^) +# Lukáš - i programátor musí umět pravopis, i když všichni už víme, že programovací jazyky dávají mnohem větší smysl +# Lukáš - (jedna kamarádka mi pořád opravuje chyby, takže už mi to teď taky dost vadí) +#skontroluje platnost vstupu +def Input_chack(index): + if not board[index] == "[ ]": + print("pole je již obsazené") + return Falsetsko + else: + return True + +#převede array s xy pozicí do indexu +def To_Index(tah): + index = tah[0] + ((tah[1] - 1) * 3) - 1 + return index + +# Lukáš - tohle by se dalo udělat za pomocí cyklů mnohem snadněji, příště to zkus nějak chytřeji +# Lukáš - jakmile začneš psát kód, který se nějak podivně opakuje, tak zkus popřemýšlet, jak by to šlo lépe +# Lukáš - taky by bylo lepší, kdyby Chack bralo board jako argument, je to flexibilnější a znovu použitelné +#skontroluje zde hráč nevyhrál +# Lukáš - další děsivá pravopisná chyba +def Chack(): + if board[0] == board[1] and board[0] == board[2] and not board[0] == "[ ]": #123 + if board[0] == "[X]": + return True + else: + return False + elif board[3] == board[4] and board[3] == board[5] and not board[3] == "[ ]": #456 + if board[3] == "[X]": + return True + else: + return False + elif board[6] == board[7] and board[6] == board[8] and not board[6] == "[ ]": #789 + if board[6] == "[X]": + return True + else: + return False + elif board[0] == board[3] and board[0] == board[6] and not board[0] == "[ ]": #147 + if board[0] == "[X]": + return True + else: + return False + elif board[1] == board[4] and board[1] == board[7] and not board[1] == "[ ]": #258 + if board[1] == "[X]": + return True + else: + return False + elif board[2] == board[5] and board[2] == board[8] and not board[2] == "[ ]": #369 + if board[2] == "[X]": + return True + else: + return False + elif board[0] == board[4] and board[0] == board[8] and not board[0] == "[ ]": #159 + if board[0] == "[X]": + return True + else: + return False + elif board[2] == board[4] and board[2] == board[6] and not board[2] == "[ ]": #357 + if board[2] == "[X]": + return True + else: + return False + else: + return None + +Show() +while Hra: + tah() + if not Chack() == None: + # Lukáš - tohle je neskutečně matoucí, nechápu proč ti Chack vrací None nebo bool a ne True/False, to by bylo mnohem srozumitelnější + # Lukáš - ty dokonce ten možný True/False výsledek z Chack ani nevyužiješ + # Lukáš - mimochodem, když porovnáváš == None, tak je vhodnější použít is None (porovnání identity objektu), protože None existuje pouze jenom jedno pro celý vesmír + Hra = False + if player_2: + print("Hráč 2 wyhrál v kole", kolo) + else: + print("Hráč 1 wyhrál v kole", kolo) + player_2 = not player_2 # Lukáš - inteligentní + kolo += 1 + if kolo > 8: # Lukáš - taky inteligentní + Hra = False + print("Hra skončila bez výsledku") +``` \ No newline at end of file diff --git a/projekty/tic_tac_toe/petr.md b/projekty/tic_tac_toe/petr.md new file mode 100644 index 0000000..5503c37 --- /dev/null +++ b/projekty/tic_tac_toe/petr.md @@ -0,0 +1,87 @@ +# petr.py +```python +# OPRAVOVAL LUKÁŠ +# Celkový komentář: Hezký, dobře čitelný kód, za mě jsi úplně splnil zadání +# Máš to krátké a výstižné + + +# Hezký, takhle se to normálně dělává, máš nějaký dict, který ti mapuje internální strukturu na její zobrazení +values = { + 0: " ", + 1: "x", + 2: "o" +} + +# Kdybys pak chtěl přidat možnost opakovaného hraní, tak bys tohle musel přesunout do nějakého cyklu dole +board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] + +def print_board(): # Celkem pěkný, sice to dělá vedlejší efekty, ale tady to moc nevadí + for i in range(3): + print("{}|{}|{}".format(values.get(board[i][0]), values.get(board[i][1]), values.get(board[i][2]))) + print("-+-+-") + +def get_user_input(): + # Taky profi, jenom snad možná by bylo lepší přesunout kód na kontrolu vstupu sem + # aby to nemátlo lidi, co čtou kód hlavního cyklu a celkově by to bylo, řekl bych, ucelenější + return [int(i) for i in input().split()] + +def check_win(): + # Je vidět, že narozdíl od Matěje umíš cykly + # Bohužel by to nefungovalo, kdybychom zvětšili herní pole + # Tahle funkce by mohla brát board jako argument, což by bylo hezčí, + # protože by se dala používat flexibilněji a nezávisela na svém umístění + # Každopádně zadání celkem hezky splněno + for i in range(3): + if board[i][0] == board[i][1] == board[i][2] and board[i][0] != 0: + return True + if board[0][i] == board[1][i] == board[2][i] and board[0][i] != 0: + return True + + if board[0][0] == board[1][1] == board[2][2] and board[1][1] != 0: + return True + if board[2][0] == board[1][1] == board[0][2] and board[1][1] != 0: + return True + return False + +def main(): + finished = False + plays = 1 + + # Fajn, tady jsou dva odlišné přístupy (jeden je s break), ale nikdo neví, který z nich použít, takže dobrý:D + while not finished: + print_board() + # Dá se zjednodušit f-stringem, ale tvá verze je kompatibilní i se staršími verzemi Pythonu 3 (<3.5), + # což taky má své výhody + print("Hraje {}".format(values.get(plays))) + inp = False + while not inp: + try: + user_input = get_user_input() + if board[user_input[0]][user_input[1]] == 0: + board[user_input[0]][user_input[1]] = plays + # Jenom taková zajímavost - dalo by se to zkrátit na plays = (plays+1)%2 + # Každopádně je otázka, jestli by to bylo čitelnější, takže jsi udělal dobře + if plays == 2: + plays = 0 + plays += 1 + inp = True + else: + print("Buňka je již obsazena") + except: + # Jenom prosím, nikdy nepoužívat except bez specifikovaného typu chyby + # Tady by stačilo něco jako `except (IndexError, ValueError):` + # Vždycky specifikuj typy těch chyb, které zachytáváš, mohlo by se ti totiž stát, že tam bude ještě nějaká další + # Pak další věc - snaž se, aby byla část v try-except bloku, co nejkratší, + # protože opět, co kdybys udělal nějakou nečekanou chybu + # Ty tady totiž máš i tu logiku na udělání tahu a změnu hráče + # Každopádně jsem rád, že jsi na try-except vůbec přišel + print("Váš vstup není platný") + finished = check_win() + + print_board() + print("Konec hry") + +if __name__ == "__main__": + # Dobrá konstrukce, hodí se to, když chceš, aby tvůj kód byl také snadno importovatelný jako knihovna + main() +``` \ No newline at end of file diff --git a/projekty/tic_tac_toe/tobias.md b/projekty/tic_tac_toe/tobias.md new file mode 100644 index 0000000..b88438e --- /dev/null +++ b/projekty/tic_tac_toe/tobias.md @@ -0,0 +1,62 @@ +# tobias.py +```python + +pisk = [[" ", " ", " "], + [" ", " ", " "], + [" ", " ", " "]] + +player = 'x' + +def print_board(pisk): # beres board jako argument - super + + for x in pisk: # sice se ti tam dela jedna cara navic ale je to elegantni + # takze super + print(f'{x[0]} | {x[1]} | {x[2]}') + print('--+---+--') + +def check(): + for i in range(3): # pouzivas cykly, taky fajn protoze si zjednodussujes praci + if pisk[i][0] == pisk[i][1] and pisk[i][1] == pisk[i][2] and pisk[i][1] != ' ': + print('Player ' + player + ' is the winner!!!') + return True + for i in range(3): + if pisk[0][i] == pisk[1][i] and pisk[1][i] == pisk[2][i] and pisk[1][i] != ' ': + print('Player ' + player + ' is the winner!!!') + return True + for i in range(1): # range(1).. hmm, tady to nesedi, vysral bych se na loop + # kdybys delal cykly cyklu a mel misto `1` nejakou promennou pak pohoda + if pisk[i][i] == pisk[i + 1][i + 1] and pisk[i + 1][i + 1] == pisk[i + 2][i + 2] and pisk[i + 1][i + 1] != ' ': + print('Player ' + player + ' is the winner!!!') + return True + for i in range(1): + if pisk[i][i + 2] == pisk[i + 1][i + 1] and pisk[i + 1][i + 1] == pisk[i + 2][i] and pisk[i + 1][i + 1] != ' ': + print('Player ' + player + ' is the winner!!!') + return True + if pisk[0][0] != ' ' and pisk[0][1] != ' ' and pisk[0][2] != ' ' and pisk[1][0] != ' ' and pisk[1][1] != ' ' and pisk[1][2] != ' ' and pisk[2][0] != ' ' and pisk[2][1] != ' ' and pisk[2][2] != ' ': # husty, ale slo by to vymyslet lip + print('Draw') # printy - chytrejsi je vracet to co se ma vytisknout jako string + # lepsi zvyk protoze printy jsou vedlejsi efekty + return True + return False + +while True: + print_board(pisk) + print('Now plays player ' + player) # "now plays player" lol + print('Enter coordinates: ') + r = input('Row (0,1,2):') + c = input('Column(0,1,2): ') + if r == '0' or r == '1' or r == '2' and c == '0' or c == '1' or c == '2': + if pisk[int(r)][int(c)] == ' ': + pisk[int(r)][int(c)] = player + if check(): # chezky ze sis uvedomil ze `check` vraci bool + break + if player == 'x': # jde udelat chytreji, ale to jeste neumite + player = 'o' + elif player == 'o': # zbytecnej elif, staci else + player = 'x' + else: + print('Kill yourself! That position is already taken!') # lol nice + else: + print('Wrong input you idiot!') +print('End of the game') +# jinak vsechno funguje - super +``` \ No newline at end of file diff --git a/projekty/tic_tac_toe/vlasta.md b/projekty/tic_tac_toe/vlasta.md new file mode 100644 index 0000000..7d52be2 --- /dev/null +++ b/projekty/tic_tac_toe/vlasta.md @@ -0,0 +1,100 @@ +# vlasta.py +```python +#Jupyter je lepsi +# ^-- ok +import numpy as np # podle me zbytecny jelikoz jsi stejne nepouzil vsechny moznosti numpy + # jako treba ten matrix rotation + # takhle je tvuj kod jenom dependent na jeste jedny veci, coz je + # zbytecny; musis si uvedomit ze kdybys tohle nekomu posilal, + # tak ten clovek musi mit nejenom python ale i numpy +ikonky = [" "," X "," O "] +def render(board): # board jako argument - super + text = "+---+---+---+\n" + for row in board: + text += "|" + for column in row: + text += ikonky[column] + "|" + text += "\n+---+---+---+\n" + print(text) + print("""+---+---+---+ +| 0 | 1 | 2 | ++---+---+---+ +| 3 | 4 | 5 | ++---+---+---+ +| 6 | 7 | 8 | ++---+---+---+""") + +def compare3(a,b,c): # obecne vyjadreni, nice + return a == b and b == c and a != 0 + +def check(board, move): # elegantni reseni, ale jde to i snadneji :D + #print(board, move) + end = False + #kontrola řádku + end = end or compare3(board[0, move[1]],board[1, move[1]],board[2, move[1]]) + #kontrola sloupce + end = end or compare3(board[move[0], 0],board[move[0], 1],board[move[0], 2]) + #kontrola diagnálně + end = end or compare3(board[0, 0],board[1, 1],board[2, 2]) + end = end or compare3(board[0, 2],board[1, 1],board[2, 0]) + + return (end, 0 in board) + +def inputMove(): + x = "" + OK = False + while not OK: + x = input("Zadejte tah od 0 do 8 \n > ") # eeh, input ve funkci - vedlejsi efekt + OK = x.isnumeric() # nice, hezky reseni problemu vstupu + if OK: + OK = int(x) >= 0 and int(x) <= 8 + if OK: + X = int(x)//3 + Y = int(x)%3 + OK = move((X, Y),1) + +def move(move,player): + global board # fuj fuj + global lastMove # bleh + OK = board[move] == 0 # chytry ze sis to zapsal do promenny + # diky tomu neprovadis stejny vypocet dvakrat + if OK: + board[move] = player + lastMove = move + return OK # vyuzivas return hodnot - nice + +from random import randint +def AImove(): + #vim ze to neni minmax + #^-- to ne no, ale je to zajimavy ozvlastneni programu + while not move((randint(0,2),randint(0,2)), 2): + continue + return move + + +# LUKÁŠ - Tyhle module-level globaly by neměly fungovat, jsi si jistý, že jsi nahrál správný kód? +# hra +global board # wtf vlasto +board = np.zeros((3, 3), dtype=np.int) +global lastMove # wut; sice to nechazi chybu ale melo by +lastMove = (0,0) +player = 1 +render(board) +while (not check(board, lastMove)[0]) and check(board, lastMove)[1]: + if player == 1: + inputMove() + else: + AImove() + render(board) + player = (player%2)+1 # Hraje další hráč; 1 => 2; 2 => 1 + # ^-- fajn ze komentujes +if check(board, lastMove)[0]: + print("Vyhrál: "+ikonky[board[lastMove]]) +else: + print("Remíza") + +# ma to divnou strukturu, na jednu stranu jsou nektery mista dobre napsany +# jiny jsou gay a pouzivaj globaly + +# jinak + za to AI +``` \ No newline at end of file diff --git a/site_gen.md b/site_gen.md index 4a8c5d8..4c95132 100644 --- a/site_gen.md +++ b/site_gen.md @@ -10,7 +10,7 @@ def get_ext(path, ext): for i in os.listdir(path): if i[0] == '.': continue - if os.path.isdir(i): + if os.path.isdir(os.path.join(path, i)): results = results + get_ext(os.path.join(path, i), ext) else: name, extension = os.path.splitext(i) diff --git a/site_gen.py b/site_gen.py index a535a29..0cbc0f2 100755 --- a/site_gen.py +++ b/site_gen.py @@ -8,7 +8,7 @@ def get_ext(path, ext): for i in os.listdir(path): if i[0] == '.': continue - if os.path.isdir(i): + if os.path.isdir(os.path.join(path, i)): results = results + get_ext(os.path.join(path, i), ext) else: name, extension = os.path.splitext(i)