← Zpět na projekt

Wordle

Postavíš českou verzi hry Wordle. Hráč má šest pokusů na uhodnutí slova o pěti písmenech a po každém pokusu vidí, která písmena sedí. Nakonec napíšeš řešič: program, který hru umí hrát sám. Vystačíš si s tím, co umíš z lekcí 1 až 9.

             K   A   B   Á   T
             P   A   U   Z   A
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·

         Ě   Š   Č   Ř   Ž   Ý   Á   Í   É
 Q   W   E   R   T   Z   U   I   O   P   Ú
   A   S   D   F   G   H   J   K   L   Ů
 Y   X   C   V   B   N   M   Ď   Ť   Ň   Ó

  Zkus: PAUZA

  Tvůj pokus:

Pracovat můžeš sama nebo ve dvojici.

Jak to bude probíhat

Projekt je rozdělený na kroky. Začneš programem, který vyhodnotí jedno slovo, a v každém kroku mu něco přidáš. Nemusíš stihnout všechno. Do kroku 3 by měla dojít každá, to už je hra, která se dá hrát. Zbytek je navíc.

Krok Co přibude Co si zopakuješ
1 – Jeden pokus vyhodnocení jednoho slova řetězce, seznamy, for, funkce
2 – Celá hra šest pokusů, kontrola vstupu, výhra a prohra while, metody řetězců
3 – Seznam slov náhodné slovo, jen skutečná slova in, randrange, import
4 – Barvy barevná pole místo značek seznam n-tic, rozbalování
5 – Klávesnice přehled písmen slovníky, slovník ve funkci
6 – Opakovaná písmena oprava chyby u slov se stejným písmenem dvakrát měnění seznamu, testy jako první
7 – Nápověda která slova ještě připadají v úvahu stavění seznamu, skládání funkcí
8 – Řešič program poradí nejlepší slovo počítadlo, hledání největšího
9 – Statistiky výsledky uložené v souboru slovník ve slovníku
10 – Herní obrazovka obrazovka, která zůstává na místě rozdělení programu na funkce

Kdo stihne všech deset kroků, najde další úkoly ve složce bonusy a volné náměty v souboru napady.md.

Každý krok má stejnou stavbu:

  1. Funkce. Zadání řekne, co má funkce dostat a co vrátit. Píšeš ji do logika.py.
  2. Testy. V prvních krocích je dostaneš hotové a zkopíruješ si je do test_logika.py. Od kroku 6 je píšeš sama.
  3. Program. Hotové funkce použiješ ve hře ve wordle.py.

Zadání říká, co má funkce dělat. Jak to udělá, je na tobě.

Po každém kroku ulož práci na GitHub: Commit a pak Sync Changes.

Soubory

Soubor K čemu je
logika.py logika: funkce s pravidly hry. Dostanou data a vrátí výsledek. Tyhle funkce se testují.
wordle.py hra: input() a print(). Volá funkce z logika.py. Tenhle soubor spouštíš.
test_logika.py testy funkcí z logika.py
pomocnik.py hotové funkce na barvy a soubory. Nemusíš ho číst ani měnit.
hadana_slova.txt 425 slov, která může program vybrat jako tajná
povolena_slova.txt skoro 28 000 slov, která může hráč zadat

Proč dva soubory s kódem? Funkce, která se ptá přes input() a odpovídá přes print(), se testovat nedá: test za tebe nic nenapíše na klávesnici a nepřečte si obrazovku. Funkci, která dostane data a výsledek vrátí, otestuješ na jednom řádku. Proto pravidla hry bydlí v logika.py a povídání s hráčem ve wordle.py.

Jak vypadá test

def test_uhodnute_slovo():
    assert logika.vyhodnot("panna", "panna") == [S, S, S, S, S]

Test je funkce, jejíž jméno začíná test_. Slovo assert znamená „tvrdím, že“: nalevo je to, co funkce vrátila, napravo to, co vrátit měla. Když tvrzení platí, test je zelený. Když ne, je červený a v hlášce uvidíš, co funkce vrátila doopravdy.

Víc o testech je v lekci o testování, tahák najdeš v lekce-testovani/TAHAK.md.

Než začneš

  1. Měj připravený počítač podle návodu Před workshopem: fork, clone a nainstalovaný pytest. Když pytest chybí, napiš v terminálu ve VS Code pip install pytest, na Windows případně py -m pip install pytest.
  2. Ve VS Code měj otevřenou složku celého workshopu (File → Open Folder), ne jen složku projektu.
  3. Otevři panel Testing (ikona baňky vlevo). Rozbal projekt-wordle a spusť jeho testy šipkou vedle názvu. V test_logika.py je jeden test a má být zelený. Když je, všechno funguje.
  4. Spusť wordle.py. Má vypsat, kolik písmen slovo má a kolik máš pokusů.
  5. Otevři krok 1.

Když se zasekneš

  1. Přečti si chybovou hlášku odspodu.
  2. Otevři nápovědu ke kroku ve složce napovedy. Jmenuje se stejně jako zadání.
  3. Zeptej se kolegyně ve dvojici nebo u stolu.
  4. Zavolej kouče.

Na konci dne

Ukážeš ostatním, co jsi postavila. Stačí si zahrát jednu hru a říct, co ti dalo nejvíc práce.

Zpět na workshop

Krok 1 – Jeden pokus

Na konci tohohle kroku program vyhodnotí jedno hádané slovo:

Tvůj pokus: kabát
k a b á t
+ ? - - -

Tajné slovo je tady kočka. Značka + znamená, že písmeno sedí, ? že ve slově je, ale jinde, a - že ve slově není.

Funkce

Funkce píšeš do logika.py.

Funkce Co vrátí
vyhodnot(hadane, tajne) seznam pěti řetězců, jeden pro každé písmeno hádaného slova

V seznamu můžou být tři hodnoty:

Hodnota Význam
"spravne" Písmeno je ve slově a stojí na správném místě.
"jinde" Písmeno ve slově je, ale na jiném místě.
"neni" Písmeno ve slově není.
vyhodnot("kabát", "kočka")
# ["spravne", "jinde", "neni", "neni", "neni"]

Nahoře v logika.py jsou dvě konstanty, DELKA_SLOVA a POCET_POKUSU. Konstanta je obyčejná proměnná, kterou program nikde nemění. Velká písmena v názvu to dávají najevo. Používej je místo čísel 5 a 6.

Testy

Otevři test_logika.py a tyhle testy zkopíruj na jeho konec:

def test_uhodnute_slovo():
    assert logika.vyhodnot("panna", "panna") == [S, S, S, S, S]

def test_zadna_shoda():
    assert logika.vyhodnot("mléko", "sušit") == [N, N, N, N, N]

def test_pismeno_na_jinem_miste():
    assert logika.vyhodnot("kabát", "kočka") == [S, J, N, N, N]

def test_diakritika_je_jine_pismeno():
    assert logika.vyhodnot("město", "mesto") == [S, N, S, S, S]

S, J a N jsou zkratky pro "spravne", "jinde" a "neni". Najdeš je nahoře v souboru s testy.

Spusť testy v panelu Testing. Budou červené a v hlášce uvidíš AttributeError: module 'logika' has no attribute 'vyhodnot'. To je v pořádku: testy popisují funkci, která ještě neexistuje. Napiš ji tak, aby zezelenaly.

Slova se stejným písmenem dvakrát teď neřeš, přijdou na řadu v kroku 6.

Program

Program píšeš do wordle.py.

  1. Napiš funkci vypis_pokus(hadane, vysledek), která vypíše slovo a pod něj značky +, ? a - jako v ukázce nahoře.
  2. Tajné slovo si zatím napiš přímo do kódu. Zeptej se hráče na slovo, vyhodnoť ho a vypiš.

Na začátku wordle.py už je import logika. Funkce a konstanty z logika.py proto voláš s tečkou, stejně jako v testech:

vysledek = logika.vyhodnot(hadane, "kočka")

Import už nikdy měnit nemusíš. Každá funkce, kterou do logika.py přidáš, je ve wordle.py hned k dispozici jako logika.jmeno_funkce, konstanty jako logika.DELKA_SLOVA.

Zobrazit nápověduSkrýt nápovědu

Funkce

Projdi pozice jednu po druhé. U každé se nejdřív zeptej, jestli je v tajném slově na stejném místě stejné písmeno. Když ne, zeptej se operátorem in, jestli je písmeno v tajném slově aspoň někde.

  • Výsledky sbírej do seznamu. Tahák L8, Stavění seznamu v cyklu.
  • Na pozice se dostaneš přes range a index: hadane[i], tajne[i].
vysledek = []
for i in range(DELKA_SLOVA):
    if hadane[i] == tajne[i]:
        vysledek.append("spravne")
    ...
return vysledek

Program

Poskládej si dva řetězce, jeden s písmeny a druhý se značkami, a pak je vypiš.

Který výsledek má jakou značku, si ulož do slovníku. Značku pak najdeš přes klíč, bez podmínek:

ZNACKY = {"spravne": "+", "jinde": "?", "neni": "-"}

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 2 – Celá hra

Zadání na GitHubu

Krok 2 – Celá hra

Na konci tohohle kroku má hráč šest pokusů a hra pozná výhru i prohru:

Tvůj pokus: pes
Slovo musí mít 5 písmen.
Tvůj pokus: Kabát
k a b á t
+ ? - - -
Tvůj pokus: kočka
k o č k a
+ + + + +
Uhodla jsi to na 2. pokus!

Funkce

Funkce píšeš do logika.py.

Funkce Co vrátí
uprav_vstup(text) text bez mezer na začátku a na konci, převedený na malá písmena
chyba_slova(slovo) "Slovo musí mít 5 písmen.", když slovo nemá pět písmen; když je v pořádku, prázdný řetězec ""

Testy

Zkopíruj na konec test_logika.py a místo ___ doplň, co má funkce vrátit:

def test_uprav_vstup():
    assert logika.uprav_vstup("  KOČKA ") == ___

def test_kratke_slovo():
    assert logika.chyba_slova("kočk") == ___

def test_spravna_delka():
    assert logika.chyba_slova("kočka") == ___

Program

Program píšeš do wordle.py.

Napiš dvě funkce.

nacti_slovo() se hráče ptá tak dlouho, dokud nezadá slovo, které projde kontrolou. Když slovo neprojde, vypíše chybu a zeptá se znovu. Vrátí upravené slovo.

zahraj(tajne) odehraje celou hru:

Špatně zadané slovo se díky nacti_slovo nepočítá jako pokus.

Zobrazit nápověduSkrýt nápovědu
  • Mezery kolem textu a malá písmena: metody strip a lower. Tahák L6, Metody řetězců.
  • Ptaní, dokud není odpověď v pořádku: while True. Tahák L4, Nekonečný cyklus.

Funkce nacti_slovo je nekonečný cyklus, ze kterého vyskočíš příkazem return:

def nacti_slovo():
    while True:
        slovo = logika.uprav_vstup(input("Tvůj pokus: "))
        ...

Ve funkci zahraj počítej pokusy od jedničky: for pokus in range(1, logika.POCET_POKUSU + 1).

Když hráč uhodne, ukonči funkci příkazem return. Co je napsané za cyklem, se pak provede jen při prohře.

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 3 – Seznam slov

Zadání na GitHubu

Krok 3 – Seznam slov

Na konci tohohle kroku vybírá tajné slovo program a hráč smí hádat jen skutečná slova:

Tvůj pokus: xyzab
Takové slovo neznám.
Tvůj pokus: kabát
k a b á t
- + - - -
...
Došly pokusy. Tajné slovo bylo pauza.
Hrát znovu? (ano/ne)

Ve složce projektu jsou dva soubory se slovy. V hadana_slova.txt je 425 slov, ze kterých program vybírá tajné slovo. V povolena_slova.txt je skoro 28 000 slov, která smí hráč zadat.

Na začátek wordle.py přidej:

from random import randrange
from pomocnik import nacti_radky

nacti_radky("hadana_slova.txt") vrátí seznam slov ze souboru. randrange(n) vrátí náhodné celé číslo od 0 do n - 1. Soubor pomocnik.py je hotový, nemusíš ho číst ani měnit.

Funkce

Funkce píšeš do logika.py.

Funkce Co vrátí
chyba_slova(slovo, povolena) to, co dřív, a navíc "Takové slovo neznám.", když slovo o pěti písmenech není v seznamu povolena

Testy

Funkce má teď dva parametry, takže testy z minulého kroku spadnou. Oprav v nich volání a přidej dva nové testy. Místo ___ doplň, co chybí:

def test_nezname_slovo():
    assert logika.chyba_slova(___, ["kočka"]) == "Takové slovo neznám."

def test_povolene_slovo():
    assert logika.chyba_slova("kočka", ["kočka"]) == ___

Program

Program píšeš do wordle.py.

  1. Náhodně vyber tajné slovo ze souboru hadana_slova.txt.
  2. Zadaná slova kontroluj podle souboru povolena_slova.txt. Seznam povolených slov pošli funkcím zahraj a nacti_slovo jako další parametr.
  3. Po skončení hry se zeptej, jestli chce hráč hrát znovu.
Zobrazit nápověduSkrýt nápovědu
  • Jestli je slovo v seznamu, zjistíš operátorem in, případně not in.
  • Oba soubory načti jen jednou, na začátku programu.
  • Náhodné slovo je slovo na náhodném indexu, tedy na indexu od 0 do len(slova) - 1. Tahák L4, Náhodné číslo.

Hraní znovu je další cyklus while True, tentokrát kolem volání zahraj. Ukončíš ho příkazem break. Tahák L4, break.

Odpověď hráče na otázku „Hrát znovu?“ uprav stejnou funkcí jako hádané slovo. Projde pak i ANO nebo ano.

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 4 – Barvy

Zadání na GitHubu

Krok 4 – Barvy

Na konci tohohle kroku hra místo značek + ? - ukazuje barevná pole a po každém pokusu vypíše všechny dosavadní pokusy pod sebe:

 K   A   B   Á   T
 P   A   U   Z   A

Na obrazovce bude každé písmeno ve svém poli: zelené sedí, žluté je ve slově jinde, šedé ve slově není.

Do importu přidej obarvi:

from pomocnik import nacti_radky, obarvi

obarvi(" K ", "zelena") vrátí text, který se vypíše s barevným pozadím. Barvy jsou "zelena", "zluta" a "seda".

Tahle změna se týká jen výpisu, takže se logika.py ani testy nemění. Až budeš hotová, testy musí být pořád zelené.

Program

Program píšeš do wordle.py.

  1. Ve funkci zahraj si pokusy ukládej do seznamu n-tic (hadane, vysledek).
  2. Místo vypis_pokus napiš funkci vypis_pokusy(pokusy). Po každém pokusu vypíše všechny dosavadní pokusy pod sebe, každé písmeno ve svém barevném poli. Písmena piš velká, řetězec na to má metodu upper().
Zobrazit nápověduSkrýt nápovědu

Slovník se značkami z kroku 1 vyměň za slovník s barvami:

BARVY_POLI = {"spravne": "zelena", "jinde": "zluta", "neni": "seda"}

Seznam n-tic projdeš cyklem, který si každou n-tici rovnou rozbalí. Tahák L8, Rozbalování.

for hadane, vysledek in pokusy:

Řádek si poskládej do jednoho řetězce, pole po poli, a vypiš ho až celý.

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 5 – Klávesnice

Zadání na GitHubu

Krok 5 – Klávesnice

Na konci tohohle kroku hra před každým pokusem ukáže klávesnici, na které je vidět, co už hráč o kterém písmenu ví:

 Ě   Š   Č   Ř   Ž   Ý   Á   Í   É
 Q   W   E   R   T   Z   U   I   O   P   Ú
 A   S   D   F   G   H   J   K   L   Ů
 Y   X   C   V   B   N   M   Ď   Ť   Ň   Ó

Tvůj pokus:

Funkce

Funkce píšeš do logika.py.

Funkce Co dělá
aktualizuj_pismena(pismena, hadane, vysledek) do slovníku pismena zapíše, co hráč o písmenech hádaného slova zjistil; nic nevrací

Slovník pismena vypadá třeba takhle:

{"k": "spravne", "a": "jinde", "t": "neni"}

Funkce mění slovník, který dostala:

Poslední pravidlo je potřeba, protože v hádaném slově může být stejné písmeno dvakrát a pokaždé dopadnout jinak.

Testy

První test je hotový. U dalších doplň, co má ve slovníku být.

def test_zapise_vsechna_pismena():
    pismena = {}
    logika.aktualizuj_pismena(pismena, "kabát", [S, J, N, N, N])
    assert pismena == {"k": S, "a": J, "b": N, "á": N, "t": N}

def test_spravne_se_nikdy_nezhorsi():
    pismena = {"k": S}
    logika.aktualizuj_pismena(pismena, "okapy", [N, J, N, N, N])
    assert pismena["k"] == ___

def test_jinde_se_nezhorsi_na_neni():
    pismena = {"a": J}
    logika.aktualizuj_pismena(pismena, "banka", [N, N, N, N, N])
    assert pismena["a"] == ___

Vlastní test: stejné písmeno dvakrát v jednom slově. Ve slově banka vyjde první a jako "jinde" a druhé jako "neni". Ve slovníku má zůstat "jinde".

Program

Program píšeš do wordle.py.

Hra si musí pamatovat, co hráč o písmenech zjistil:

  1. Na začátku funkce zahraj si založ prázdný slovník pismena = {}.
  2. Po každém vyhodnoceném pokusu zavolej logika.aktualizuj_pismena(pismena, hadane, vysledek).
  3. Před každým pokusem vypiš klávesnici podle slovníku pismena.

Klávesnice má tyhle řádky:

KLAVESNICE = ["ěščřžýáíé", "qwertzuiopú", "asdfghjklů", "yxcvbnmďťňó"]
Zobrazit nápověduSkrýt nápovědu

Funkce

Slovník, který funkce dostane jako parametr, je pořád ten samý slovník. Co do něj funkce zapíše, uvidí i ten, kdo ji zavolal. Tahák L9, Slovník ve funkci.

Projdi hádané slovo po pozicích. U každého písmene stačí dvě otázky: je výsledek "spravne"? A když ne, je už písmeno ve slovníku?

for i in range(DELKA_SLOVA):
    pismeno = hadane[i]
    if vysledek[i] == "spravne":
        ...
    elif pismeno not in pismena:
        ...

Program

Slovník pismena založ jednou na začátku hry, ne v cyklu. Jinak by si klávesnice po každém pokusu všechno zapomněla.

Na výpis potřebuješ dva cykly v sobě: vnější přes řádky klávesnice, vnitřní přes písmena v řádku.

Jestli o písmenu něco víš, zjistíš podmínkou if pismeno in pismena:. Tahák L9, Když klíč chybí.

Barvy kláves si ulož do druhého slovníku, který se od barev polí liší jen u "neni".

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 6 – Opakovaná písmena

Zadání na GitHubu

Krok 6 – Opakovaná písmena

Na konci tohohle kroku hra správně vyhodnotí i slova, ve kterých je stejné písmeno dvakrát.

Funkce vyhodnot má totiž chybu, kterou zatím nebylo vidět. Pro hádané slovo banka a tajné slovo sonda vrátí - ? + - +.

Tajné slovo sonda má jedno a, a to je na konci, kde ho hráč trefil. Funkce přesto hlásí, že a na druhém místě je "jinde". Hráč si pak myslí, že jsou ve slově dvě.

Tenhle krok je nejtěžší z celého dne. Když ti nepůjde, přeskoč ho a vrať se k němu později. Další kroky fungují i bez něj.

Testy

Od tohohle kroku píšeš testy sama. A tentokrát jimi začni: nejdřív testy, potom oprava. Některé budou červené, a to je správně.

Co má vyjít, je v tabulce. Výsledky jsou tu psané značkami + ? -:

Volání Výsledek
vyhodnot("banka", "sonda") - - + - +
vyhodnot("mamka", "mléko") + - - + -
vyhodnot("banka", "okapy") - ? - ? -
vyhodnot("kočka", "kabát") + - - - ?
vyhodnot("nanuk", "panna") ? + + - -

Funkce

Funkci opravuješ v logika.py.

Funkce Co se mění
vyhodnot(hadane, tajne) každé písmeno tajného slova jde použít jen jednou a přesné shody mají přednost

Jeden průchod slovem stačit nebude, takže si to nejdřív rozmysli na papíře. Zkus si ručně vyhodnotit banka proti sonda: co musíš vědět, než rozhodneš o prvním a?

Program ve wordle.py se nemění.

Zobrazit nápověduSkrýt nápovědu

Projdi slovo dvakrát.

V prvním průchodu hledej jen přesné shody. Písmena tajného slova, která hráč netrefil, si ukládej do seznamu.

Ve druhém průchodu dostane písmeno "jinde", jen když v tom seznamu ještě je. Pak ho ze seznamu odeber, aby nešlo použít podruhé.

Zobrazit další nápověduSkrýt nápovědu

V prvním průchodu zapiš na místa bez přesné shody zatím "neni". Ve druhém průchodu pak některá "neni" přepíšeš na "jinde".

Prvek seznamu přepíšeš přes index: vysledek[i] = "jinde".

Jedno písmeno ze seznamu odebereš metodou remove. Odebere první výskyt hodnoty. Tahák L8, Metody, které seznam mění.

zbyla = ["s", "o", "d"]
zbyla.remove("o")
# ["s", "d"]

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 7 – Nápověda

Zadání na GitHubu

Krok 7 – Nápověda

Na konci tohohle kroku hra umí napovědět. Když hráč místo slova napíše ?, program vypíše, kolik tajných slov ještě přichází v úvahu, a prvních deset z nich:

Tvůj pokus: ?
Zbývá slov: 14
bavit, chata, hlava, vlast, ...
Tvůj pokus:

Nápověda se nepočítá jako pokus.

Funkce

Funkce píšeš do logika.py.

Funkce Co vrátí
filtruj(mozna, hadane, vysledek) nový seznam jen s těmi slovy z mozna, která odpovídají tomu, co hráč zjistil
mozna = ["kočka", "mléko", "sonda", "panna"]
print(filtruj(mozna, "banka", vyhodnot("banka", "panna")))
# ['panna']

Než začneš psát podmínky pro každou barvu, zastav se: co by platilo, kdyby tajné bylo právě tohle slovo? Máš na to už hotovou funkci.

Testy

Napiš testy sama. Co vyzkoušet:

Program

Program píšeš do wordle.py.

  1. Ve funkci zahraj začni seznamem všech slov z hadana_slova.txt a po každém pokusu ho zmenši funkcí filtruj.
  2. Otazník zpracuj ve funkci nacti_slovo: vypiš nápovědu a zeptej se znovu. Funkce k tomu potřebuje seznam mozna jako další parametr.

Prvních deset slov získáš výřezem mozna[:10]. Seznam řetězců spojíš do jednoho textu takhle:

", ".join(["kočka", "mléko"])    # kočka, mléko
Zobrazit nápověduSkrýt nápovědu

Nepiš podmínky pro zelenou, žlutou a šedou zvlášť.

Představ si, že tajné slovo je jedno ze slov v seznamu. Jaký výsledek by hráč za své hádané slovo dostal? To ti řekne funkce vyhodnot. Slovo v seznamu zůstane, jen když by ten výsledek byl stejný jako ten, který hráč opravdu dostal.

Dva seznamy porovnáš obyčejným ==.

Funkce vrací nový seznam. Ten původní nemění. Tahák L8, Stavění seznamu v cyklu.

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 8 – Řešič

Zadání na GitHubu

Krok 8 – Řešič

Na konci tohohle kroku program umí hrát sám. Když hráč napíše !, program mu poradí slovo:

Tvůj pokus: !
Zkus: ?????
Tvůj pokus:

Ze všech slov, která přicházejí v úvahu, vybere to, které prozradí nejvíc: slovo složené z písmen, která se v možných slovech vyskytují nejčastěji.

Funkce

Funkce píšeš do logika.py.

Funkce Co vrátí
spocitej_pismena(slova) slovník: v kolika slovech je které písmeno; slovo se dvěma a se počítá jen jednou
ohodnot(slovo, cetnosti) součet bodů za různá písmena ve slově; slovo panna dostane body za p, a, n
nejlepsi_slovo(mozna) slovo s nejvíc body; když je jich víc se stejnými body, je jedno které
cetnosti = spocitej_pismena(["panna", "pivo"])
# {"p": 2, "a": 1, "n": 1, "i": 1, "v": 1, "o": 1}
ohodnot("panna", cetnosti)
# 4

Testy

Napiš testy sama, ke každé funkci aspoň jeden. Vymysli si malý seznam slov, u kterého výsledek spočítáš z hlavy. Co vyzkoušet:

Program

Program píšeš do wordle.py.

Vykřičník přidej do funkce nacti_slovo, stejně jako otazník v minulém kroku.

Než to spustíš, odhadni, jaké první slovo program doporučí. Pak ho nech poradit a hraj podle něj. Na kolik pokusů to zvládne?

Zobrazit nápověduSkrýt nápovědu

spocitej_pismena je počítadlo. Tahák L9, Počítadlo.

Aby se písmeno ve slově nezapočítalo dvakrát, pamatuj si u každého slova, která písmena jsi v něm už viděla. Stačí na to řetězec nebo seznam, do kterého písmena přidáváš.

ohodnot potřebuje stejný trik: body za písmeno přičti jen poprvé.

nejlepsi_slovo je vzor „kdo vyhrál“. Pamatuj si zatím nejlepší slovo a vyměň ho, když najdeš slovo s víc body. Tahák L9, Kdo vyhrál.

Četnosti spočítej jen jednou, před cyklem.

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 9 – Statistiky

Zadání na GitHubu

Krok 9 – Statistiky

Na konci tohohle kroku si program pamatuje odehrané hry i po vypnutí a po každé hře vypíše přehled:

Her: 4   Úspěšnost: 75 %
Pokusy:  1: 0  2: 0  3: 2  4: 0  5: 0  6: 1

Funkce

Funkce píšeš do logika.py.

Funkce Co vrátí
spocitej_statistiky(radky) slovník s přehledem; radky je seznam řetězců, každý je počet pokusů, nebo "0" za prohru
spocitej_statistiky(["3", "0", "3", "6"])
# {"her": 4, "vyher": 3, "uspesnost": 75.0,
#  "pokusy": {1: 0, 2: 0, 3: 2, 4: 0, 5: 0, 6: 1}}

Úspěšnost je podíl výher v procentech. Když ještě nikdo nehrál, je úspěšnost 0.

Testy

Napiš testy sama. Co vyzkoušet:

Program

Program píšeš do wordle.py. Do importu z pomocnik přidej pridej_radek:

from pomocnik import nacti_radky, obarvi, pridej_radek

Funkce přidá na konec souboru jeden řádek. Když soubor neexistuje, založí ho. Třeba pridej_radek("statistiky.txt", 4) přidá řádek 4. Ty tam místo 4 pošleš počet pokusů z právě odehrané hry. Řádky pak přečteš funkcí nacti_radky, kterou už znáš. Vrátí seznam řetězců, takže čísla bude potřeba převést.

  1. Ať zahraj vrací počet pokusů, nebo 0, když hráč prohrál.
  2. Po každé hře výsledek ulož a vypiš statistiky jako v ukázce nahoře.

Úspěšnost zaokrouhlíš funkcí round: round(75.0) je 75.

Zobrazit nápověduSkrýt nápovědu

Slovník pokusy si nejdřív připrav se samými nulami, cyklem od 1 do POCET_POKUSU. Tahák L9, Stavění slovníku v cyklu.

Potom projdi řádky. Každý převeď funkcí int a u výhry přičti jedničku ke správnému klíči.

Dělit počtem her můžeš, jen když nějaká hra byla.

Výsledek je slovník, ve kterém je další slovník. Tahák L9, Záznamy a tabulky.

Hotovo, když


Zpět na projekt: Wordle · Další: Krok 10 – Herní obrazovka

Zadání na GitHubu

Krok 10 – Herní obrazovka

Výpis v terminálu pořád ujíždí nahoru. Na konci tohohle kroku z něj bude obrazovka, která zůstává na místě:

             O   P   E   R   A
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·
             ·   ·   ·   ·   ·

         Ě   Š   Č   Ř   Ž   Ý   Á   Í   É
 Q   W   E   R   T   Z   U   I   O   P   Ú
   A   S   D   F   G   H   J   K   L   Ů
 Y   X   C   V   B   N   M   Ď   Ť   Ň   Ó

  Takové slovo neznám.

  Tvůj pokus:

Do importu přidej vycisti_obrazovku. Tahle funkce smaže všechno, co je v terminálu vypsané.

Tahle změna se týká jen výpisu, takže se logika.py ani testy nemění. Když po úpravách testy pořád procházejí, víš, že pravidla hry zůstala stejná.

Program

Program píšeš do wordle.py.

  1. Napiš funkci vykresli(pokusy, pismena, zprava), která smaže obrazovku a vypíše hrací plochu, klávesnici a zprávu.
  2. Plocha má vždycky šest řádků. Prázdné pokusy vyplň tečkami.
  3. Před každým pokusem zavolej vykresli.

Zarovnání na střed jako v ukázce je navíc. Výpis od levého kraje úplně stačí.

Teď narazíš na problém: když print vypíše chybu a hned potom se obrazovka smaže, hráč ji nestihne přečíst. Proto se chyba nevypisuje hned. Ulož ji do proměnné zprava a vykresli ji vypíše při dalším překreslení. Stejně naložíš s nápovědou, s radou řešiče i s výsledkem hry.

Zobrazit nápověduSkrýt nápovědu

Překreslovat se musí i po špatně zadaném slově, takže vykresli patří dovnitř cyklu ve funkci nacti_slovo. Ta k tomu potřebuje pokusy a pismena jako další parametry:

def nacti_slovo(pokusy, pismena, povolena, mozna):
    zprava = ""
    while True:
        vykresli(pokusy, pismena, zprava)
        slovo = logika.uprav_vstup(input("  Tvůj pokus: "))
        ...

V cyklu už nic nevypisuj přes print. Nápovědu, radu i chybu jen ulož do zprava.

Počet prázdných řádků na ploše je logika.POCET_POKUSU - len(pokusy).

Hotovo, když


Zpět na projekt: Wordle · Další: Bonusy

Zadání na GitHubu

Bonusy

Bonusy jsou na později, když máš hotové kroky. Na sebe nenavazují.

Bonus 1 – Jak dobrý je řešič

Řešič umí poradit jedno slovo. Jak dobře by ale hrál celou hru? Na konci tohohle bonusu to budeš vědět:

První slovo: ?????
Průměr: ?.?? pokusu
Nejhorší slovo: ????? (? pokusů)
Víc než šest pokusů: ?

Ve složce projektu založ soubor bonus1.py a na jeho začátek napiš import logika, stejně jako ve hře. Nech řešič odehrát hru s každým slovem ze souboru hadana_slova.txt.

Pro každé tajné slovo začni se všemi slovy a opakovaně hádej nejlepsi_slovo a filtruj, dokud se netrefíš. Vypiš průměrný počet pokusů, nejhorší slovo a kolikrát by řešič překročil šest pokusů.

Tady žádný input() není, program hraje sám proti sobě. Hru jednoho slova si napiš jako funkci, která vrátí počet pokusů.

Bonus 2 – Lepší řešič

Počítání písmen je jen odhad. Přesnější je zeptat se: kdybych hádala tohle slovo, kolik slov mi průměrně zbude?

Navazuje na bonus 1, výsledky obou řešičů pak porovnáš.

Pro každé kandidátské slovo projdi všechna možná tajná slova a spočítej do slovníku, kolikrát padl který výsledek. Klíčem bude n-tice, seznam klíčem být nemůže:

klic = tuple(logika.vyhodnot(kandidat, tajne))

Když výsledek padl n-krát, zbude po něm n slov. Průměrný zbytek je součet n * n přes všechny výsledky, vydělený počtem možných slov. Vyber slovo s nejmenším průměrným zbytkem.

První slovo počítej jen jednou a ulož si ho. Porovnej výsledek s prvním bonusem. Je lepší? Které slovo je první?

Výpočet chvíli trvá, program projde každou dvojici slov. To je v pořádku.


Zpět na projekt: Wordle · Další: Nápady na rozšíření

Bonusy na GitHubu

Nápady na rozšíření

Máš hotovo a chceš si hrát dál? Tady je pár směrů. Řešení k nim není, cesta je na tobě. U každého platí totéž co u kroků: logiku piš jako funkci do logika.py a napiš k ní test.


Zpět na projekt: Wordle