Extra: periodieke tshirt

Deze pagina bevat uitvoerbare code.

Periodieke tshirt

Er bestaan T-shirts met woorden die zijn samengesteld uit de symbolen van elementen uit het periodiek systeem. In deze opgave zoek je uit welke woorden je zo kunt maken, en op hoeveel manieren.

Een T-shirt met een woord dat is opgebouwd uit symbolen van het periodiek systeem

Het gegeven

Een element heeft een symbool van één of twee letters: "K" is kalium, "Kr" is krypton. Een woord maak je door symbolen achter elkaar te zetten. Hoofdletters tellen daarbij niet mee: het woord kranten is K + Ra + N + Te + N.

Soms moet je kiezen. kranten begint met de K van kalium of met de Kr van krypton. Kies je Kr, dan loop je vast: er is geen element A en geen element An. Met K lukt het wel. Of je één letter of twee moet nemen, weet je vooraf niet. Je probeert dus beide.

Het periodiek systeem van de elementen, met in elk vak het symbool

De cel hieronder zet de symbolen van de eerste 118 elementen klaar in de lijst ELEMENTS. De methode .split() knipt de lange string op bij de spaties. Voer de cel eerst uit.

ELEMENTS = (
    "H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni "
    "Cu Zn Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I "
    "Xe Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt "
    "Au Hg Tl Pb Bi Po At Rn Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr "
    "Rf Db Sg Bh Hs Mt Ds Rg Cn Nh Fl Mc Lv Ts Og"
).split()

Wat je gaat maken

Stap

Functie

Doet

Hoe je combineert

1

is_element

is een stukje tekst het symbool van een element?

geen recursie

2

can_spell

kun je een woord maken met symbolen?

één letter or twee letters

3

count_spellings

op hoeveel manieren kun je een woord maken?

één letter + twee letters

Stap 1: is_element(s)

s is een string van kleine letters. Geeft True als s het symbool van een element is, als je hoofdletters niet meetelt, en anders False.

Aanroep

Resultaat

is_element("k")

True

is_element("kr")

True

is_element("an")

False

Hint

De methode .lower() geeft een string in kleine letters: "Kr".lower() is "kr". Maak met een list comprehension de lijst van alle symbolen in kleine letters, en vraag met in of s daarin staat.

# jouw oplossing

assert is_element("k") == True
assert is_element("kr") == True
assert is_element("a") == False
assert is_element("an") == False

Stap 2: can_spell(word)

word is een string van kleine letters. Geeft True als je word kunt maken door symbolen van elementen achter elkaar te zetten, en anders False. Een lege string kun je altijd maken: met nul symbolen.

Aanroep

Resultaat

can_spell("kranten")

True

can_spell("uitdaging")

False

can_spell("")

True

Hint

Er zijn twee keuzes, en elke keuze is een recursieve aanroep:

  • de eerste letter is een symbool: is_element(word[:1]), en de rest, word[1:], kun je maken;

  • de eerste twee letters zijn een symbool: is_element(word[:2]), en de rest, word[2:], kun je maken.

Lukt een van de twee, dan kun je het woord maken. Een woord van één letter heeft geen twee eerste letters; let op dat word[:2] dan het hele woord is.

# jouw oplossing

assert can_spell("kranten") == True
assert can_spell("spuwers") == True
assert can_spell("caesar") == True
assert can_spell("uitdaging") == False
assert can_spell("kaas") == False
assert can_spell("") == True

Stap 3: count_spellings(word)

Geeft terug op hoeveel manieren je word kunt maken met symbolen van elementen. spuwers kan op twee manieren: S + P + U + W + Er + S, en S + Pu

  • W + Er + S.

Aanroep

Resultaat

count_spellings("spuwers")

2

count_spellings("kranten")

1

count_spellings("uitdaging")

0

count_spellings("")

1

Hint

De keuzes zijn dezelfde als in stap 2. Tel nu het aantal manieren van beide keuzes op. Een keuze waarvan het begin geen symbool is, levert 0 manieren op. Let weer op een woord van één letter: daar is maar één keuze, anders tel je "k" twee keer.

# jouw oplossing

assert count_spellings("kranten") == 1
assert count_spellings("spuwers") == 2
assert count_spellings("basis") == 3
assert count_spellings("sinas") == 5
assert count_spellings("uitdaging") == 0
assert count_spellings("") == 1

Tot slot

caesar kan op één manier: Ca + Es + Ar. sinas kan zelfs op vijf manieren. Bij elke letter probeerde je twee dingen: een symbool van één letter, of een van twee. Net als bij use it or lose it in het college zijn dat twee recursieve aanroepen, en de manier van combineren hangt af van de vraag: or als je wilt weten of het kan, + als je telt.

(Informatica Olympiade 2020-2021)