DEV Community

Shahrouz Nikseresht
Shahrouz Nikseresht

Posted on

Day 12: Rediscovering the Longest Word Without `len()`

#challenge #python #beginners #programming

Welcome to Day 12 of the #80DaysOfChallenges journey! After chasing the longest word in a sentence on Day 8, today's challenge, finding the longest word without using len(), took things to a new level. This beginner-friendly task pushed me to rethink a familiar problem, diving deeper into manual counting, loops, and logic. It's like solving the same puzzle but with a twist that forces you to understand the gears behind Python's built-in tools.

💡 Key Takeaways from Day 12: Longest Word, Manual Counting

The goal was to find the longest word in a user-provided sentence, but with a catch: we can't use Python's len() function to count characters. Instead, we manually count each word's characters using loops, returning both the longest word and its length as a tuple. This challenge was a fantastic exercise in manual iteration, string manipulation, and logical comparison, while also shedding light on how len() works under the hood.

1. Manual Counting: Reinventing len()

The core twist of this challenge is avoiding len(). Normally, len(word) gives the number of characters instantly, but here we had to count each character manually. The find_longest_word function splits the sentence into words and iterates through each word, counting its characters one by one:

def find_longest_word(sentence: str) -> tuple[str, int]:
    if not sentence.strip():
        return "", 0   # Handle empty or whitespace-only input

    word_list = sentence.split()
    longest_word = ""
    longest_length = 0

    for current_word in word_list:
        current_length = 0
        for _ in current_word:
            current_length += 1

        if current_length > longest_length:
            longest_word = current_word
            longest_length = current_length

    return longest_word, longest_length
Enter fullscreen mode Exit fullscreen mode

The inner loop (for _ in current_word) iterates over each character in a word, incrementing a counter (current_length). The underscore (_) is a neat Python convention for a loop variable we don't use, since we're just counting iterations. This manual counting mimics how len() likely works internally, traversing a string's characters and tallying them up. It was eye-opening to realize how much we take built-in functions for granted!

2. Building on Day 8: A Familiar Yet Fresh Challenge

This challenge is a direct evolution of Day 8's longest word task, but the manual counting adds a layer of depth. The logic remains similar: split the sentence into words, compare their lengths, and track the longest one. However, instead of len(current_word) > len(longest_word), we compare current_length > longest_length. The function also returns a tuple (longest_word, longest_length), which is a nice touch for providing both pieces of information. For more details on the original version, check out the Day 8 article or longest_word.py code.

I appreciated how this forced me to revisit Day 8's solution and think about what len() abstracts away. It’s like peeling back the hood of a car to see how the engine works; you gain a deeper respect for the machinery.

3. Handling Edge Cases: Robustness Matters

The function handles edge cases cleanly:

  • Empty or whitespace-only input: Returns ("", 0) to avoid errors with blank sentences.
  • Ties in length: Returns the first word encountered, consistent with the challenge's requirements.

For example, running the code with the input "Python is an amazing programming language" yields:

The longest word is 'programming' with length 11.
Enter fullscreen mode Exit fullscreen mode

The empty input case was a small but important detail. Without if not sentence.strip():, an empty string could lead to an empty word_list, but the function still handles it gracefully. This reinforced the importance of anticipating user behavior, even in simple programs.

4. Why Return a Tuple?

Returning a tuple (longest_word, longest_length) instead of just the word was a clever design choice. It provides more information without extra effort, making the function versatile. For instance, you could use the length for further calculations or display it directly, as shown in the example usage:

user_sentence = input("Enter a sentence: ")
word, length = find_longest_word(user_sentence)
print(f"\nThe longest word is '{word}' with length {length}.\n")
Enter fullscreen mode Exit fullscreen mode

This output format is user-friendly and clear, showing both the result and its context.

🧠 Why This Challenge Shines

This challenge was a perfect blend of revisiting familiar territory (string splitting, iteration) and exploring new ground (manual counting). It's a reminder that programming isn't just about solving problems but understanding how tools work. Manually counting characters felt like stepping into Python's shoes, seeing the world as it does.

The challenge also highlighted the power of iteration. Each loop, whether splitting words or counting characters, is a small decision-making process: "Is this word longer? How many characters does it have?" These micro-decisions are the building blocks of more complex algorithms, from text processing to data analysis.

🎯 Summary and Reflections

Day 12 was a lesson in appreciating the mechanics behind Python's conveniences. Key takeaways:

  • Manual Counting: Writing a loop to count characters demystifies len() and strengthens loop logic.
  • Modularity: The function's design makes it reusable for other string-based tasks.
  • Edge Cases: Handling empty inputs and ties ensures robustness, a hallmark of good code.

What surprised me was how satisfying it felt to "reinvent" len(). It's a small function, but coding it manually gave me a deeper connection to Python's inner workings. I also started thinking about extensions, like ignoring punctuation or handling multiple longest words. Maybe a future challenge will explore those!

What's your favorite way to tweak string processing in Python? Share below!

🚀 Next Steps and Resources

Day 12 was a rewarding detour into the nuts and bolts of string manipulation, setting the stage for more complex text challenges. If you're following #80DaysOfChallenges, how did you approach this one? Got any clever tricks for manual counting or string handling? Drop them in the comments!

Top comments (0)