Patternal issues creative solution for Number Length by smilicic - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.

Patternal issues solution in Creative category for Number Length by smilicic

from random import shuffle

class NonDeterministicStringDigitIterator:
    def __init__(self, to_iterate):
        self.data = str(to_iterate.value)
    
    def __iter__(self):
        self.data_for_iteration = list(self.data)
        return self
        
    def __next__(self):
        data = self.data_for_iteration
        if not data:
            raise StopIteration
        shuffle(data)
        first_letter, data = data[0], data[1:]
        self.data_for_iteration = data
        return first_letter
        
    def __len__(self):
        true_list = list(x==x for x in self)
        return sum(true_list)

class NumberDigitsIteratorFacade:
    def __init__(self, value, Strategy):
        self.value = value
        self.strategy = Strategy(self)
    
    def __iter__(self):
        return iter(self.strategy)
        
    def __len__(self):
        return len(self.strategy)

def number_length(a):
    f = NumberDigitsIteratorFacade(a, NonDeterministicStringDigitIterator)
    return len(f)

Nov. 16, 2020

Comments:

jiaoxueyuan1108 on Dec. 6, 2020, 9:43 a.m.
How does this work? I don't quite understand

smilicic on Dec. 8, 2020, 4:11 p.m.
This is a joke on the strategy and facade pattern. The facade pattern as Wikipedia puts it, "is an object that serves as a front-facing interface masking more complex underlying or structural code" and strategy pattern "is a behavioral software design pattern that enables selecting an algorithm at runtime". Now, NDIF just delegates the computation of length to it's iterator, and since that iterator is a strategy, it goes to a different class, NDSDI. NDSDI has length implemented as a sum of booleans, and summing booleans in Python is the same as summing integers with `True == 1`, so `sum(True for _ in range(10)) == 10`. The most obfuscated part, of course, is the iterator shuffling data at every `next` step, but that shuffling has zero effect on the functionality.

X-Yupto10 on Feb. 13, 2021, 8 p.m.
Hahha, nice one

Calen on March 19, 2021, 11:40 a.m.
thats genuinely weird solution, nice!

a8696tk on March 26, 2024, 1:12 p.m.
I would solve it this way: <pre class='brush: python'>from random import shuffle def random_iterator(data): shuffled_data = list(data) shuffle(shuffled_data) for item in shuffled_data: yield item </pre> In this example, random_iterator is a generator function that takes data and returns a generator. The generator then shuffles the data and returns elements from the shuffled list one at a time each time next() is called. This makes the code more readable and compact.

a8696tk on March 26, 2024, 1:15 p.m.
You can simplify the code by getting rid of the NumberDigitsIteratorFacade class and using a function instead of a class. Here's a shorter version: <pre class='brush: python'>from random import shuffle class NonDeterministicStringDigitIterator: def __init__(self, value): self.data = list(str(value)) shuffle(self.data) def __iter__(self): return self def __next__(self): if not self.data: raise StopIteration return self.data.pop(0) def __len__(self): return sum(1 for _ in self) def number_length(a): return len(NonDeterministicStringDigitIterator(a)) </pre> This option removes the NumberDigitsIteratorFacade class and makes the NonDeterministicStringDigitIterator directly accept a value in the constructor. The number_length function now simply returns the length of the iterator created from the string a.

Strings and Integers

0 %

You ClassRoom Demo is Ready With the new tool CheckiO ClassRoom, you will be able to analyze your students' progress, have your own leaderboard, change missions order on the map, and so on.