Homework 2: Number Properties Solution | Introduction to Python Programming

 Introduction to Python Programming
University of Pennsylvania

Homework 2: Instructions

Homework 2: Number Properties

This assignment is designed to give you practice writing code and applying lessons and topics for the current module.

This homework deals with the following topics:

• Loops

• Functions

About the Assignment

This HW deals primarily with loops and functions.  It will introduce you to some interesting number theory as well.  You have probably heard of prime numbers and composite numbers before, but have you ever heard of abundant numbers, or narcissistic numbers?  This assignment will ask you to write code to identify different kinds of number properties.

We also want you to learn how to reuse code in this assignment, by writing and using functions.  This is a basic strategy for reducing complexity in a program.  Why?  Because things change, and if you have the same thing in several places, when you change one, you have to change all the others.  And you can’t always find them all!  In order to reuse code, you must take common pieces of code and put them into functions.  Failure to do so will result in loss of points.

We also want you to add comments to your code and docstrings to your functions.

*You can assume that all inputs in this assignment will be positive integers.

Background on Number Theory

You’ll use the following number theory properties in this assignment.

Factor - A factor is a number that divides evenly into another number.  For example, 2 is a factor of 4 because 2 divides evenly into 4.  3 and 4 are both factors of 12 because they both divide evenly into 12.

Prime number - A number with exactly 2 factors -- 1 and itself.  For example, 2 is a prime number because its only 2 factors are 1 and 2.  41 is also a prime number because it can only be divided by 1 and 41.

Composite number - A number with more than 2 factors.  For example, 9 is a composite number because its factors are 1, 3, and 9.  Please note that number 1 is neither prime nor composite.  

Perfect number - A number is said to be perfect if it is equal to the sum of all its factors (for obvious reasons the list of factors being considered does not include the number itself).  6 = 3 + 2 + 1, hence 6 is perfect.  28 is another example since 1 + 2 + 4 + 7 + 14 is 28.  Please note that the number 1 is not a perfect number.

Abundant number - A number is considered to be abundant if the sum of its factors (aside from the number) is greater than the number itself.  For example, 12 is abundant since 1 + 2 + 3 + 4 + 6 = 16 > 12.  However, a number like 15, where the sum of the factors is 1 + 3 + 5 = 9, is not abundant.

Triangular number - The triangular number Tn is a number that can be represented in the form of a triangular grid of points where the first row contains a single element and each subsequent row contains one more element than the previous one (see figure below).  

For the purposes of this assignment, we use the fact that the nth triangular number can be found by using the following formula:

For example, 3 is the 2nd triangular number, since 2 (3) / 2 = 3.  As another example, 15 is the 5th triangular number, since 5 (6) / 2 = 15.  However, 14 is not triangular, since there is no x such that x (x + 1) / 2 = n.

Narcissistic number - A positive integer is called narcissistic if it is equal to the sum of its own digits each raised to the power of the number of digits.  For example, 153 is narcissistic because 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153.  Note that by this definition all single digit numbers are narcissistic.

The Assignment

Write a Python program with at least the following functions.  We want you to demonstrate your understanding of code reusability so you should write a few others -- we call these helper functions.   For example, you might want to write a function that calculates and returns all the factors of a given number.

getFactors(x) - function that returns a list of factors of a given number x.  Basically, finds the numbers between 1 and the given integer that divide the number evenly.

isPrime(x) - function that returns whether or not the given number x is prime.  This function returns a boolean.

isComposite(x) - function that returns whether or not the given number x is composite.  This function returns a boolean.  We intend for you to reuse code from the prime number function here.

isPerfect(x) - function that returns whether or not the given number x is perfect.  This function returns a boolean.

isAbundant(x) - function that returns whether or not the given number x is abundant.  This function returns a boolean.

isTriangular(x) - function that returns whether or not a given number x is triangular.  This function returns a boolean.

isNarcissistic(x) - function that returns whether or not a given number is Narcissistic.  This function returns a boolean.

Each function has been defined for you, but without the code. See the docstring in each function (in the starter code) for more details on what the function is supposed to do and how to write the code. It should be clear enough. In some cases, we have provided hints and examples to get you started.  

For example, we have defined an “isPrime” function for you (see below) which returns whether or not a given number is prime.  Read the docstring, which explains what the function is supposed to do.  Then write your code where it says “# TODO” to implement the function.  (“# TODO” is a special kind of highlighted comment in Python which indicates there is a task to complete or issue that requires attention.)  You’ll do this for each function in the program.

To get the solution contact (Not for Free) -

ramverma2369@gmail.com

Solution-

Module 2

This HW deals primarily with loops and functions. It will introduce you to some interesting number theory as well. You have probably heard of prime numbers and composite numbers before, but have you ever heard of abundant numbers, or narcissistic numbers? This assignment will ask you to write code to identify different kinds of number properties.

We also want you to learn how to reuse code in this assignment, by writing and using functions. This is a basic strategy for reducing complexity in a program. Why? Because things change, and if you have the same thing in several places, when you change one, you have to change all the others. And you can’t always find them all! In order to reuse code, you must take common pieces of code and put them into functions. Failure to do so will result in loss of points.

We also want you to add comments to your code and docstrings to your functions.

You can assume that all inputs in this assignment will be positive integers.

Each function has been defined for you, but without the code. See the docstring in each function (in the starter code) for more details on what the function is supposed to do and how to write the code. It should be clear enough. In some cases, we have provided hints and examples to get you started.

In [1]:

###########################################################

### EXECUTE THIS CELL BEFORE YOU TO TEST YOUR SOLUTIONS ###

###########################################################

​

import unittest

from nose.tools import assert_equal, assert_true

    In [2]:

def getFactors(x):

    """Returns a list of factors of the given number x.

    Basically, finds the numbers between 1 and the given integer that divide the number evenly.

​

    For example:

    - If we call getFactors(2), we'll get [1, 2] in return

    - If we call getFactors(12), we'll get [1, 2, 3, 4, 6, 12] in return

    """

    List=[]

    for i in range (1,x+1):

        if(x % i == 0):

            List.append(i)

    return List

In [3]:

##########################

### TEST YOUR SOLUTION ###

##########################

​

num = 2

factors_test = [1, 2]

factors = getFactors(num)

assert_equal(factors_test, factors, str(factors) + ' are not the factors of ' + str(num))

​

num = 12

factors_test = [1, 2, 3, 4, 6, 12]

factors = getFactors(num)

assert_equal(factors_test, factors, str(factors) + ' are not the factors of ' + str(num))

​

num = 13

factors_test = [1, 13]

factors = getFactors(num)

assert_equal(factors_test, factors, str(factors) + ' are not the factors of ' + str(num))

​

# test existence of docstring

assert_true(len(getFactors.__doc__) > 1, "there is no docstring for getFactors")

print("Success!")

Success!

In [19]:

def isPrime(x):

    """Returns whether or not the given number x is prime.

​

    A prime number is a natural number greater than 1 that cannot be formed

    by multiplying two smaller natural numbers.

​

    For example:

    - Calling isPrime(11) will return True

    - Calling isPrime(71) will return True

    - Calling isPrime(12) will return False

    - Calling isPrime(76) will return False

    """

    if x==1:

        return False

    if x==2:

        return True

    f= True

    for i in range(2,x):

        if(x%i==0):

            f=False

            break

    return f

In [20]:

##########################

### TEST YOUR SOLUTION ###

##########################

​

prime_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23,

     29, 31, 37, 41, 43, 47, 53, 59,

     61, 67, 71, 73, 79, 83, 89, 97,

     101, 103, 107, 109, 113, 127,

     131, 137, 139, 149, 151, 157,

     163, 167, 173, 179, 181]

​

for i in prime_numbers:

    assert_true(isPrime(i), str(i) + ' is prime')

​

not_prime_numbers = [1, 8, 12, 18, 20, 27, 28, 30,

     42, 44, 45, 50, 52, 63, 66,

     68, 70, 75, 76, 78, 92, 98,

     99, 102, 138, 148, 150, 156, 158]

​

for i in not_prime_numbers:

    assert_true(not(isPrime(i)), str(i) + ' is not prime')

​

#test existence of docstring

assert_true(len(isPrime.__doc__) > 1, "there is no docstring for isPrime")

print("Success!")

Success!

In [21]:

def isComposite(x):

    """Returns whether or not the given number x is composite.

​

    A composite number has more than 2 factors.

    A natural number greater than 1 that is not prime is called a composite number.

    Note, the number 1 is neither prime nor composite.

​

    For example:

    - Calling isComposite(9) will return True

    - Calling isComposite(22) will return True

    - Calling isComposite(3) will return False

    - Calling isComposite(41) will return False

    """

    f=False

    for i in range(2,x):

        if(x%i==0):

            f=True

            break

    return f

In [22]:

##########################

### TEST YOUR SOLUTION ###

##########################

​

composite_numbers = [4, 6, 8, 9, 10, 12, 14, 15, 16,

     18, 20, 21, 22, 24, 25, 26, 27,

     28, 30, 32, 33, 34, 35, 36,

     38, 39, 40, 42, 44, 45, 46, 48,

     49, 50, 51, 52, 54, 55, 56, 57,

     58, 60, 62, 63, 64, 65, 66, 91, 93]

​

for i in composite_numbers:

    assert_true(isComposite(i), str(i) + ' is composite')

​

not_composite_numbers = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23,

     29, 31, 37, 41, 43, 47, 53, 59,

     61, 67, 71, 73, 79, 83, 89]

​

for i in not_composite_numbers:

    assert_true(not(isComposite(i)), str(i) + ' is not composite')

​

#test existence of docstring

assert_true(len(isComposite.__doc__) > 1, "there is no docstring for isComposite")

print("Success!")

Success!

In [25]:

def isPerfect(x):

    """Returns whether or not the given number x is perfect.

​

    A number is said to be perfect if it is equal to the sum of all its

    factors (for obvious reasons the list of factors being considered does

    not include the number itself).

​

    Example: 6 = 3 + 2 + 1, hence 6 is perfect.

    Example: 28 is another example since 1 + 2 + 4 + 7 + 14 is 28.

    Note, the number 1 is not a perfect number.

    """

    s=0

    for i in range (1,x):

        if(x % i == 0):

            s=s+i

    f=False

    if(s==x):

        f= True

    return f

In [26]:

perfect_numbers = [6, 28, 496, 8128, 33550336]

for i in perfect_numbers:

    assert_true(isPerfect(i), str(i) + ' is perfect')

​

not_perfect_numbers = [2, 3, 4, 5, 7, 8, 9, 10,

                       495, 8127, 8129,

                       33550335]

​

for i in not_perfect_numbers:

    assert_true(not(isPerfect(i)), str(i) + ' is not perfect')

​

#test existence of docstring

assert_true(len(isPerfect.__doc__) > 1, "there is no docstring for isPerfect")

print("Success!")

Success!

In [27]:

def isAbundant(x):

    """Returns whether or not the given number x is abundant.

​

    A number is considered to be abundant if the sum of its factors

    (aside from the number) is greater than the number itself.

​

    Example: 12 is abundant since 1+2+3+4+6 = 16 > 12.

    However, a number like 15, where the sum of the factors.

    is 1 + 3 + 5 = 9 is not abundant.

    """

    s=0

    for i in range (1,x):

        if(x % i == 0):

            s=s+i

    f=False

    if(s>x):

        f = True

    return f

In [28]:

abundant_numbers = [12, 18, 20, 24, 30, 36, 40, 42, 48,

    54, 56, 60, 66, 70, 72, 78, 80, 84,

    88, 90, 96, 100, 102, 104, 108, 112,

    114, 120]

​

for i in abundant_numbers:

    assert_true(isAbundant(i), str(i) + ' is abundant')

​

not_abundant_numbers = [1, 2, 3, 4, 5, 6,

    7, 8, 9, 10, 11, 13,

    14, 15, 16, 17, 19,

    21, 22, 23, 25, 26, 27, 28, 29,

    91, 92, 93, 94, 95, 119]

​

for i in not_abundant_numbers:

    assert_true(not(isAbundant(i)), str(i) + ' is not abundant')

​

#test existence of docstring

assert_true(len(isAbundant.__doc__) > 1, "there is no docstring for isAbundant")

print("Success!")

Success!

In [29]:

def isTriangular(x):

    """Returns whether or not a given number x is triangular.

    The triangular number Tn is a number that can be represented in the form of a triangular 

    grid of points where the first row contains a single element and each subsequent row contains 

    one more element than the previous one.

    We can just use the fact that the nth triangular number can be found by using a formula: Tn = n(n + 1) / 2.

    Example: 3 is triangular since 3 = 2(3) / 2

    3 --> 2nd position: (2 * 3 / 2)

    Example: 15 is triangular since 15 = 5(6) / 2

    15 --> 5th position: (5 * 6 / 2)

    """

    if(x==1):

        return True

    f=False

    for i in range(1,x):

        s=(i*(i+1))/2

        if(s==x):

            f = True

            break

    return f

In [30]:

triangular_numbers = [1, 3, 6, 10, 15, 21, 28, 36, 45, 55,

      66, 78, 91, 105, 120, 136, 153, 171,

      190, 210, 231]

​

for i in triangular_numbers:

    assert_true(isTriangular(i), str(i) + ' is triangular')

​

not_triangular_numbers = [2, 4, 5, 7, 8, 9, 11, 12, 13, 14,

      16, 17, 18, 19, 20,

      22, 23, 24, 25, 26, 27,

      29, 30, 31, 32, 33, 34, 35,

      37, 40, 41, 42, 43, 44,

      54, 56, 189, 191, 209, 211, 230, 232]

​

for i in not_triangular_numbers:

    assert_true(not(isTriangular(i)), str(i) + ' is not triangular')

​

#test existence of docstring

assert_true(len(isTriangular.__doc__) > 1, "there is no docstring for isTriangular")

print("Success!")

Success!

In [37]:

def isNarcissistic(x):

    """Returns whether or not a given number is Narcissistic.

​

    A positive integer is called a narcissistic number if it

    is equal to the sum of its own digits each raised to the

    power of the number of digits.

​

    Example: 153 is narcissistic because 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153.

    Note that by this definition all single digit numbers are narcissistic.

    """

    num = str(x)

    power = len(num)

    sum = 0

    for number in num:

        sum += pow(int(number), power)

    if sum == x:

        return True

    return False

In [38]:

narcissistic_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407]

​

for i in narcissistic_numbers:

    assert_true(isNarcissistic(i), str(i) + ' is narcissistic')

​

non_narcissistic_numbers = [10, 11, 12, 13, 152, 154, 369, 372, 406]

​

for i in non_narcissistic_numbers:

    assert_true(not(isNarcissistic(i)), str(i) + ' is not narcissistic')

​

#test existence of docstring

assert_true(len(isNarcissistic.__doc__) > 1, "there is no docstring for isNarcissistic")

print("Success!")

Success!

     In [ ]:

def main():

​

    playing = True

    while playing == True:

​

        num_input = input('Give me a number from 1 to 10000.  Type -1 to exit. ')

​

        try:

            num = int(num_input)

​

            if (num == -1):

                playing = False

                continue

​

            if (num <= 0 or num > 10000):

                continue

​

            factors = getFactors(num)

            print("The factors of", num, "are", factors)

​

            if isPrime(num):

                print(str(num) + ' is prime')

            if isComposite(num):

                print(str(num) + ' is composite')

            if isPerfect(num):

                print(str(num) + ' is perfect')

            if isAbundant(num):

                print(str(num) + ' is abundant')

            if isTriangular(num):

                print(str(num) + ' is triangular')

            if isNarcissistic(num):

                print(str(num) + ' is narcissistic')

​

        except ValueError:

            print('Sorry, the input is not an int.  Please try again.')

#This will automatically run the main function in your program

#Don't change this

if __name__ == '__main__':

    main()