Filtering Words by Length from Nested Sentence Lists in Python

You need to extract words from a list of sentences and filter them based on their length. Specifically, you want to create a list of words that are shorter than or equal to a given length limit, which the user will provide as input.To solve this problem:

1. Data Preparation:

   - You start with a list of lists, where each sublist contains words from different sentences.

2. Input Handling:

   - You prompt the user to enter a length limit for filtering the words.

3. Flattening the List:

   - You flatten the nested list structure into a single list that contains all the words from all the sentences. This is done to make it easier to process each word individually.

4. Filtering Words:

   - You iterate through the flattened list of words and check the length of each word.

   - If the length of a word is less than or equal to the specified limit, you add that word to a new list.

5. Output:

   - Finally, you print the list of filtered words.

The approach ensures that only words meeting the length criterion are included in the final list, making it straightforward to analyze or process these filtered words further.

Efficiently Tracking and Querying Word Positions in a List Using a Dictionary

You need to create a program that processes a list of words input by the user, stores the positions (indices) of each word, and then allows querying of these positions. If a user queries a word that exists in the list, the program should return all indices where that word appears. If the word does not exist in the list, it should return "not found." 

1. **Reading Input**:

   - The program starts by taking a single line of input, which consists of words separated by spaces. This line is split into a list of words.

2. **Building Index Dictionary**:

   - The program then constructs a dictionary to map each word to a list of its indices (positions) in the original list. This is achieved by iterating through the list of words and recording each word's position.

3. **Handling Queries**:

   - After building the dictionary, the program waits for another user input, which is a query for a specific word. It looks up this word in the dictionary.

   - If the word exists in the dictionary, it prints out all indices where this word appears. If the word is not found, it outputs "not found."

### Summary:

This approach allows you to efficiently track the positions of words within a list and handle user queries to retrieve these positions. It uses a dictionary to store and quickly access the positions of each word, making it effective for both storing and querying word positions.