Home/ Questions/Q 6990
Next
In Process

askthedev.com Latest Questions

Asked: 2024-09-25T14:39:02+05:30 In: ,

Brevity Challenge: Create a Compact Class to Mimic Perl’s Hash of Hashes in Python, Ruby, or JavaScript

I’ve been diving into some fun coding challenges lately, and I stumbled upon a really interesting one that got my gears turning. You know how in Perl, you can use hashes of hashes to store complex data structures? It’s such a versatile feature, and I was thinking about how we could implement something similar in another language—or even more interestingly, how we could create a really concise class to handle this in a super compact way.

So here’s the challenge: could you create the shortest class that can mimic a hash of hashes in Perl using, say, Python, Ruby, or JavaScript? The requirements are pretty straightforward. The class should support typical operations like adding a key-value pair, retrieving a value, and deleting a key. However, the catch is that the outer hash should map strings to other hashes, and those inner hashes can also store simple values.

Imagine you’re creating a chaotic but delightful family tree—where each family member can have their own set of relationships stored in the inner hashes. For example, you could have an outer hash where each key is a person’s name, and the values are hashes mapping relationships to other persons, like siblings or cousins. It should be a breeze to add new family members or remove someone who’s no longer in the picture.

I can’t help but wonder what the shortest solution would look like. And just to be clear, brevity is key here— I’m thinking of a challenge that gets people scratching their heads and coming up with clever tricks to condense their code.

If you dive into this, it would be awesome to see your implementations and any little hacks you used to make everything fit into the smallest space. I bet there are some creative approaches out there! What do you think would be the most challenging part of keeping the code short while still functional? Looking forward to seeing what you all come up with!

Coding Challenge
Share

    Leave an answer

    You must login to add an answer.

    Need An Account,

    2 Answers


    1. class FamilyTree:
    def __init__(self):
        self.tree = {}
        
    def add(self, person, relation, related_person):
        if person not in self.tree:
            self.tree[person] = {}
        self.tree[person][relation] = related_person
        
    def get(self, person):
        return self.tree.get(person, {})
    
    def delete(self, person, relation):
        if person in self.tree:
            del self.tree[person][relation]
            if not self.tree[person]:
                del self.tree[person]

# Example usage
family = FamilyTree()
family.add("Alice", "sister", "Bob")
family.add("Alice", "cousin", "Charlie")
print(family.get("Alice"))  # Output: {'sister': 'Bob', 'cousin': 'Charlie'}
family.delete("Alice", "sister")
print(family.get("Alice"))  # Output: {'cousin': 'Charlie'}



    2. Below is a concise implementation of a class in Python that mimics a hash of hashes, allowing for the storage of complex relationships in a family tree structure. The class supports adding, retrieving, and deleting key-value pairs in a compact manner. This version utilizes Python’s built-in dictionary to achieve the desired functionality:

      class FamilyTree:
    def __init__(self):
        self.tree = {}
    def add(self, person, relation, relation_person):
        self.tree.setdefault(person, {})[relation] = relation_person
    def get(self, person, relation):
        return self.tree.get(person, {}).get(relation)
    def remove(self, person, relation):
        if person in self.tree:
            self.tree[person].pop(relation, None)

      This implementation leverages methods like `setdefault` for efficient initialization of inner hashes and concise access to nested data. The biggest challenge while keeping the code short and functional is balancing readability with brevity, ensuring that the code remains understandable without adding unnecessary complexity or sacrificing function. Each method is designed to be straightforward while encapsulating the required operations on the family relationships.


    Related Questions