CIT 590 Assignment 1: Number Personalities
Fall 2015, David Matuszek

# Purposes of this assignment

• To familiarize you with IDLE
• To get you started programming in Python
• To teach you a little bit about functions

# General idea of the assignment

In this assignment you will write a number of functions for testing characteristics of positive integers, plus one special function named `main`. Each function other than `main` will take a single positive integer as an argument, test whether it has some property, and return a value of either `true` or `false`.

Put your program on a file named `number_personalities.py`. Get a copy of the file number_personalities_test.py.

# Details

## The `main()` function

In the `main` function, define a variable `limit = 100` and test each of the numbers` 1 `through` limit`, inclusive. Do not use the number 100 elsewhere; use the variable `limit` instead. This makes the program easier to change if you later want some limit other than 100.

The `main` function will call each of the other functions, for each of the numbers 1 through `limit`, to determine the properties of those numbers. It will then print out each number, one per line, along with a list of its properties (on the same line).

Your output should look approximately like this:

```    1   composite, happy, triangular, square, not smug, honest
2   prime, unhappy, not triangular, not square, smug, honest
3   prime, unhappy, triangular, not square, not smug, honest
4   composite, unhappy, not triangular, square, not smug, honest
5   prime, unhappy, not triangular, not square, smug, dishonest
. . .```

The `main` function doesn't return a value. Each of the other functions is a predicate, that is, a function that returns `True` or `False`.

## The `is_prime(n)` function

A positive number is prime if its only positive divisors are itself and one. For example,` 7 `is prime because it is evenly divisible by` 1 `and` 7`, but not by any number in between (in particular, it is not evenly divisible by` 2`,``` 3```,` 4`,` 5`, or` 6`).

A positive number is composite if it is not prime. For example,``` 10 ```is composite because it is evenly divisible by` 2 `and``` 5```;` 12 `is composite because it is evenly divisible by` 2`,` 3`,` 4`, and` 6`. As a special case,` 1 `is considered to be composite.

This function should return `True` if its argument is a prime number, and `False` otherwise. Similar statements hold for the other functions.

## The `is_happy(n)` function

Repeatedly apply the following procedure to a number:

1. Square each of the digits of the number.
2. Add the squares together.

If by doing this you eventually get to` 1`, then the number is happy.

For example, if you start with` 19`:

• `12 + 92 = 1 + 81 = 82`
• `82 + 22 = 64 + 4 = 68`
• `62 + 82 = 36 + 64 = 100`
• `12 + 02 + 02 = 1 + 0 + 0 = 1` and the number is happy.

If instead you get into an infinite loop, the number is unhappy. So if your program runs forever, the number is unhappy. This isn't a very useful test, however. Fortunately, every unhappy number will eventually get into this cycle:

`4, 16, 37, 58, 89, 145, 42, 20, 4, ...`

so if you get any one of these numbers, say` 4`, then you can stop and conclude that the number is unhappy.

## The `is_triangular(n)` function A triangular number is a number of the form `1 + 2 + 3 + ... + n`, for some positive` n`. These numbers are called triangular because, if you have that many objects, you can arrange them in an equilateral triangle (see figure).

The first few triangular numbers are `1, 3, 6, 10, 15`....

## The `is_square(n)` function

A square number is a number of the form `1 + 3 + 5 + 7 + ... + n`, for some odd positive` n`. (The figure should help you understand why this definition is the same as the usual definition of square numbers.)

## The `is_smug(n)` function

A number is smug if it is the sum of two square numbers. The first few smug numbers are `2` (1+1), `5` (1+4), `8` (4+4), `10` (1+9), `13` (4+9), etc.

## The `is_honest(n)` function

A number is dishonest if it "pretends" to be a square number, but isn't one. Specifically, n is dishonest if there is a number` k `such that` n // k = k `(using integer division), but `k * k` is not` n`. A number is honest if it is not dishonest.

# Coda

At the end of your Python program (after all your function definitions), insert the following lines:

``````if __name__ == "__main__":
main()``````
Here's what this does. If you are in the IDLE window containing your program, and you click `F5` (or choose ```Run -> Run module```) from the menu, IDLE will automatically run your main function. If you are in the IDLE window containing your test cases (supplied) and click `F5` or use the menu equivalent, it will run the tests and tell you the results.

# Due date

Turn in your one Python file to Canvas by 6am Thursday, September 3.