Added word-building question

Author: TianLangHin

competition/word-building/.gitignore

@@ -0,0 +1 @@
+/target

competition/word-building/Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "word-building"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.1"
+rand_chacha = "0.9.0"

competition/word-building/Cargo.toml

@@ -0,0 +1,112 @@
+---toml
+[fuzz]
+exec = ["cargo", "run", "--release", "--", "generate"]
+env = {}
+
+[judge]
+exec = ["cargo", "run", "--release", "--quiet", "--", "validate"]
+
+[problem]
+points = 15
+difficulty = 2
+---
+
+# 🔠 Word-Building Competition
+
+Alice and Bob are playing a game where they take turns to place down letters to form a word.
+Completing a word ends the game and awards both players a certain number of points.
+This is determined by a *dictionary* they are given at the start of every game,
+containing the list of valid words and the points awarded by forming each word.
+
+The only restriction on the letter they can play is that the word they form by playing it
+must either reach a valid word in the dictionary, or be the prefix of one such word.
+For example, if only the words `car` and `cat` are in the dictionary,
+and the letters placed down currently are `ca`, then Alice can only play either `r` or `t`.
+
+Since Alice and Bob are very competitive, however, they have opposing goals in this game.
+Alice wishes to maximise the number of points at the end of the game,
+while Bob wishes to minimise the number of points.
+Out of courtesy, Bob says that *Alice will play first*.
+
+While they are both human, Alice and Bob are both experts in this game.
+They are both *guaranteed to play optimally*.
+
+Your task is to answer the following question:
+when both Alice and Bob **always play optimally**,
+what is the **number of points they will receive at the end of the game**?
+
+## Example
+
+Consider a game with the following dictionary.
+```
+aaa 28
+aab -45
+ab 17
+baa -10
+bab 19
+bba 18
+bbb -7
+```
+If Alice plays `a`:
+* If Bob plays `a`, then Alice will choose to play `a`,
+  forming the word `aaa` and scoring **28** (since `aab` scores less than this).
+* If Bob plays `b`, the word `ab` is formed, scoring **17**.
+Therefore, if Alice plays `a`, then Bob will play `b` (to minimise the score),
+meaning the game will end with score of **17**.
+
+If Alice plays `b`:
+* If Bob plays `a`, then Alice will choose to play `b`,
+  forming the word `bab` and scoring **19**.
+* If Bob plays `b`, then Alice will choose to play `a`,
+  forming the word `bba` and scoring **18**.
+Knowing this, Bob will choose to play `b` in this situation,
+so that Alice will score 18 instead of 19 (thus minimising her score in optimal play).
+
+After having considered all of the above,
+Alice now realises that if she plays `a`, the game will end with 17 points,
+and if she plays `b`, the game will end with 18 points.
+
+Therefore, she will play `b`, and the game will end with the word `bba` and **18** points.
+The answer is here thus:
+```
+18
+```
+
+## Input
+
+Your puzzle input will be the dictionary that Alice and Bob receive at the start of the game,
+each line containing a valid word that can be formed to signal the end of a game
+and its associated points.
+
+Another example of the input is as follows.
+```
+aa -1
+ab -2
+ba 8
+bba 7
+bbb 6
+bc 10
+c 4
+```
+
+### Constraints
+
+* The words in the dictionary are given in alphabetical (lexicographical) order.
+* Every line consists of a word followed by an integer, separated by whitespace.
+* Every score is an integer from `-100,000` to `100,000` inclusive.
+  Numbers are given without commas.
+* At every turn, the set of playable letters always spans alphabetically from `a`.
+  For example, if the word `aaf` exists in the dictionary,
+  it is guaranteed that `aaa`, `aab`, `aac`, `aad`, and `aae` are either valid words,
+  or are prefixes of one or more valid words.
+
+Please note that the your input file will be very large (approximately 10,000+ lines).
+
+## Output
+
+A single integer, which is the final score of the game when both Alice and Bob play optimally.
+
+For this example, the output should be
+```
+7
+```