<jupyter_start><jupyter_text>01. Number of BitsGiven an integer n, return the number of 1 bits in n.- Constraints: ```0 ≤ n < 2 ** 31``` **Binarise decimals**- ```format(number, "b")```<jupyter_code>class Solution:
    def solve(self, number):
        if (number >= 2**31):
            pass
        elif (number == 0):
            return 0
        else:     
            num = str(format(number, "b"))
            return len(num)<jupyter_output><empty_output><jupyter_text>01. Review  02. Narcissistic NumberGiven an integer n, return whether it is equal to the sum of its own digits raised to the power of the number of digits. Split a word into letters- ```[char for char in word]```<jupyter_code>class Solution:
    def solve(self, number):
        digits = str(number)
        digits = [digit for digit in digits]
        print('digits', digits)
        num_digits = len(digits)
        
        print('num_digits:', num_digits)
        
        nums = []

        for digit in digits:
            num = int(digit)
            nums.append(num**num_digits)
        
        if (sum(nums) == number):
            return True 
        else: 
            return False<jupyter_output><empty_output><jupyter_text>02. Review  03. Non-Decreasing DigitsGiven a positive integer n, return the largest integer smaller or equal to n where all digits are non-decreasing.   - Constraints ```0 < n < 2 ** 31 - 1```  - Hint: Try a few test cases and see what the result should be. Do you notice a pattern at the point where the number breaks the required condition?<jupyter_code><jupyter_output><empty_output><jupyter_text>03. Review  04. List Partitioning with Inequality RelationGiven a list of integers nums, we want to split the list into two non-empty sublists a and b such that every element in a is less than or equal to every element in b.Return the smallest length of a that is possible. You can assume that the solution exists.Constraints- ```n ≤ 100,000``` where ```n``` is the length of nums  - Hint 1: Note: a is always towards the left.  - Hint 2: Maintain LeftMax and RightMin while traversing from left to right. Find a index where ```LeftMax <= RightMin``` is happening.<jupyter_code><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09508787742226228, 'fraction_numerical': 0.016674177557458314, 'mean_word_length': 2.9572192513368982, 'pattern_counts': {'":': 0, '<': 21, '<?xml version=': 0, '>': 18, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '503593', 'license': 'Apache-2.0', 'n_tokens_mistral': 697, 'n_tokens_neox': 648, 'n_words': 267, 'path': '00 Monday Coding Challenge/01 Monday 13 Sept .ipynb', 'repo_name': 'Coding-Forest/2021-Algorithms', 'size': '2219'}