Problem Description

You are tasked with implementing the core logic for a simple word-guessing game. The game involves:

• A dictionary: A list of distinct lowercase strings, all of the same length L, representing valid words.
• A secret word: One of the words from the provided dictionary.
• A player's guess word.

For each guess, your function must return feedback consisting of two components:

1. exact_matches: The number of positions i where the character in the secret word at index i is identical to the character in the guess word at index i.
2. misplaced_matches: The number of letters that appear in both the secret and guess words but in different positions, without double-counting any letter.

More formally for misplaced_matches: After identifying and accounting for exact_matches, consider the remaining characters in both secret and guess (those not contributing to an exact match). For each distinct character c, count its occurrences in the remaining secret characters and its occurrences in the remaining guess characters. The contribution to misplaced_matches for character c is the minimum of these two counts. The total misplaced_matches is the sum of these minimums across all distinct characters.

If the guessed word is not present in the dictionary, the function should clearly indicate this invalid state.

Requirements

Implement a function with the following signature and behavior:

get_feedback(dictionary: List[str], secret: str, guess: str) -> (int exact_matches, int misplaced_matches)

• If guess is not found within the dictionary, the function should signal an invalid guess. This can be achieved, for example, by raising an exception or returning a special sentinel value like (-1, -1).
• Otherwise, return the pair (exact_matches, misplaced_matches) as defined above.

Assumptions

You can assume the following constraints:

• The dictionary will contain between 1 and 10^5 words (1 <= len(dictionary) <= 10^5).
• All words in the dictionary, as well as the secret and guess words, will have the same length L, where 1 <= L <= 20.
• All words consist solely of lowercase English letters ('a' through 'z').

Example

Consider the following scenario:

• dictionary = ["apple", "angle", "ample"]
• secret = "apple"
• guess = "alley" (Assume "alley" is a valid word in the dictionary for this example.)

Let's trace the feedback calculation:

• secret: a p p l e
• guess: a l l e y

1. Exact Matches: Only the first character 'a' matches in the same position (secret[0] == guess[0]).

   • exact_matches = 1

2. Remaining Letters (after exact matches):

   • From secret: p, p, l, e (at indices 1, 2, 3, 4)
   • From guess: l, l, e, y (at indices 1, 2, 3, 4)

3. Misplaced Matches:

   • Character 'l': Appears 1 time in remaining secret, 2 times in remaining guess. min(1, 2) = 1.
   • Character 'e': Appears 1 time in remaining secret, 1 time in remaining guess. min(1, 1) = 1.
   • Other characters ('p', 'y') do not appear in both remaining sets.
   • misplaced_matches = 1 ('l') + 1 ('e') = 2

Therefore, for secret = "apple" and guess = "alley", the feedback is (1, 2).

Your task is to design and implement an efficient algorithm to compute this feedback for a single guess.