An intersting coding challenge

Vishnuprasad Ranganatha — Fri, 10 Apr 2026 09:49:25 +0000

Given an array of sequential integers, with multiples of 3 and 5 replaced, determine if it's a valid FizzBuzz sequence.

In a valid FizzBuzz sequence:

Multiples of 3 are replaced with "Fizz".
Multiples of 5 are replaced with "Buzz".
Multiples of both 3 and 5 are replaced with "FizzBuzz".
All other numbers remain as integers.

is_fizz_buzz(["FizzBuzz", 16, 17, "Fizz", 19, "Buzz"]) should return True
is_fizz_buzz(["Fizz", "Buzz", 101, "Fizz", 103, 104, "FizzBuzz"]) should return True
is_fizz_buzz([1, 2, "Fizz", "Buzz", 5]) should return False

Solution:

find the original array or range of numbers;
check the fizzbuzz condition of the number in original array, and check the fizzbuzz value in input array is same. if both different, return False.
if all are same, return True.

This problem is a bit different because it is not just asking for solving fizz buzz, instead, it is asking to validate the sequence. this will add some additional complexity.

Below is the solution code:

def is_fizz_buzz(arr):
    anum = None;
    anum_index = None;
    for i, item in enumerate(arr):
        if isinstance(item, int):
            anum = item;
            anum_index = i;
            break;
    original_range = [*range(item-i, item-i+len(arr))];
    for item1, item2 in zip(original_range, arr):
        if not item1%3 and not item1%5:
            if item2 != "FizzBuzz":
                return False
        elif not item1%5:
            if item2 != "Buzz":
                return False
        elif not item1%3:
            if item2 != "Fizz":
                return False
    return True;

OOP’s Missing Link: Why "Abstraction" is About Enforcement, Not Just Hiding

Vishnuprasad Ranganatha — Fri, 20 Mar 2026 09:21:56 +0000

Most textbooks tell you that Abstraction is about "hiding complexity." But let’s be honest: a simple function hides complexity. So why do we need Abstract Base Classes (ABCs)?

If we look at Object-Oriented Programming from a developer’s perspective, the definition changes. Abstraction isn't just a "black box"—it's a Contractual Blueprint.

The Four Pillars, Redefined

To understand Abstraction, we have to see where it fits among its peers:

Encapsulation: (The Gatekeeper). It prevents accidental access to internal data.

Inheritance: (The Recycler). It lets us reuse parent code in child classes.

Abstraction: (The Standardizer). It is a mandatory guide that forces subclasses to implement specific methods.

Polymorphism: (The Result). Because Abstraction enforces a standard, we can use different objects interchangeably without our code breaking.

Why the "Hiding" Definition Fails

"Hiding" can be achieved by a simple function definition; you don't want to know how it works, you just want the result.

Abstraction is different. It is a guide for the developer to implement methods of any classes that inherit this guide. Even if hiding some logic is a result of the process, the primary goal is Standardized Enforcement.

The "Real-World" Python Example

Imagine you are building a "Save" button for an app. You might have a CloudSaver and a HardDriveSaver.

Without a guide, one developer might name their method upload() and another might use write_to_disk(). Your "Save" button will crash because it doesn't know which name to call.

from abc import ABC, abstractmethod

# 1. THE ABSTRACTION (The Blueprint/Guide)
class FileSaver(ABC):
    @abstractmethod
    def save(self, data):
        """Every child MUST implement this name exactly."""
        pass

# 2. THE IMPLEMENTATION (The Complex Logic)
class CloudSaver(FileSaver):
    def save(self, data):
        # 100 lines of complex API logic hidden here
        print(f"Cloud: Uploading '{data}' to server...")

class HardDriveSaver(FileSaver):
    def save(self, data):
        # 50 lines of disk-writing logic hidden here
        print(f"Local: Saving '{data}' to C:/ drive...")

# 3. THE POLYMORPHISM (The Result)
def click_save_button(saver_object, user_data):
    # This function is 'shielded' from complexity.
    # It only knows 'save' exists because of the ABC.
    saver_object.save(user_data) 

# Usage
click_save_button(CloudSaver(), "My Document")

The Takeaway

Abstraction is the Standardization of logic. It’s the "Government Standard" for the wall outlet that ensures every plug—no matter how complex the appliance—will fit and work. It moves us from "I hope this class has the right method" to "The computer guarantees this class has the right method."

DEV Community: Vishnuprasad Ranganatha