CODEWITHSUNDEEP
pythonpython-2.7
Daniel Otieno
Daniel Otieno

Reputation: 85

How to divide an unknown integer into a given number of even parts using Python

I need help with the ability to divide an unknown integer into a given number of even parts — or at least as even as they can be. The sum of the parts should be the original value, but each part should be an integer, and they should be as close as possible.

Parameters
num: Integer - The number that should be split into equal parts

parts: Integer - The number of parts that the number should be split 
into

Return Value
List (of Integers) - A list of parts, with each index representing the part and the number contained within it representing the size of the part. The parts will be ordered from smallest to largest.

This is what I have 

def split_integer(num,parts):
    if (num < parts):
      print(-1)

    elif (num % parts == 0):
      for i in range(parts):
        print(num // parts),
    else: 
      parts_remaining = parts - (num % parts)
      quotient = num // parts 

      for i in range(parts):
        if (i >= parts_remaining):
          print(quotient + 1),
        else:
          print(quotient),

split_integer(10, 1)

This is the sample tests

import unittest

class Test(unittest.TestCase):
    def test_should_handle_evenly_distributed_cases(self):
        self.assertEqual(split_integer(10, 1), [10])
        self.assertEqual(split_integer(2, 2), [1,1])
        self.assertEqual(split_integer(20, 5), [4,4,4,4,4])

Examples of the expected output

num parts   Return Value
Completely even parts example   10  5   [2,2,2,2,2]
Even as can be parts example    20  6   [3,3,3,3,4,4]

I am getting the error 

Failure
AssertionError: None != [10]

Upvotes: 4

Views: 2707

Answers (3)

Saurav
Saurav

Reputation: 13

Or simply,

In [1]: n,p=20,6                                                                
In [2]: c,r=divmod(n,p)                                                         
In [3]: [c]*(p-r) + [c+1]*r                                                     
Out[3]: [3, 3, 3, 3, 4, 4]

Upvotes: 1

elayira
elayira

Reputation: 11

This problem is very similar to the "giving change" problem.

Let us start by looking at the simplest scenario of split(10, 1) where you're dealing with a partition size of 1 i.e parts = 1, an intuitive solution would be: partition = [10]. Of course, this assumes that the remainder = 0 and parts = 1 or 0.

If that is a generic idea of a base case, then the total partitions can be calculated by way of recursion where both the num and parts are continuesly reduced as shown below:

def split_integer(num, parts):
    """
    split_integer(integer, parts) -> [ value[, values] ]
    divides an integer into an ""even as can be"" number of parts.
    >>> split_integer(10, 1)
    [10]
    >>> split_integer(2, 2)
    [1, 1]
    >>> split_integer(20, 5)
    [4, 4, 4, 4, 4]
    >>> split_integer(10, 5)
    [2, 2, 2, 2, 2]
    >>> split_integer(20, 6)
    [3, 3, 3, 3, 4, 4]
    >>> split_integer(5, 4)
    [1, 1, 1, 2]
    """
    lower_bound, remainder = divmod(num, parts)
    sub_partition = [lower_bound ] * (parts - remainder)
    num -= len(sub_partition) * lower_bound
    if remainder:
        sub_partition += split_integer(num, remainder)
    return sub_partition

if __name__ == "__main__":
    import doctest
    doctest.testmod()

Upvotes: 1

gmds
gmds

Reputation: 19885

The first problem is that you are printing your results instead of returning them. By default, in Python, any function that does not explicitly return anything will return None.

In any case, there is a more concise way, using comprehensions:

def split_integer(num, parts):
    quotient, remainder = divmod(num, parts)
    lower_elements = [quotient for i in range(parts - remainder)]
    higher_elements = [quotient + 1 for j in range(remainder)]
    return lower_elements + higher_elements

Upvotes: 6

Related Questions