6.090 IAP '05 - Homework 3

Assigned Wednesday January 12th.
Due 10am Thursday January 13th.
Submit a print-out of your .scm file. Should you encounter difficulty printing, the file may be emailed to bpe-staff@mit.edu.

Problem 1: Non-collaborative!

Please attempt these problems by yourself. If you get stuck and need assistance, talk to the course staff.

Write a procedure, with-tax, that given a dollar amount returns the amount with a 5% sales tax added in. For example:
```
(with-tax 5.00)
;Value: 5.25
(with-tax 259.99)
;Value: 272.9895
```
Remember that you can't actually use the $ in your code or it won't work.
Write a procedure, num-digits, that takes in a number and returns the number of decimal digits in the number. For example:
```
(num-digits 5)
;Value: 1
(num-digits 21)
;Value: 2
(num-digits 3987423)
;Value: 7
```
You will find quotient useful, as it works like /, except it throws away anything after the decimal point (ie integer division). For example:
```
(quotient 4 2)
;Value: 2
(quotient 5 2)
;Value: 2
```
First write out a plan (base case and recursive case), then implement the procedure in scheme. Finally, test your procedure to verify that it works.
Write a procedure, add-digit, which takes a number and a digit and returns a new number with the digit as the least significant digit and the rest of the digits like the original number. You may assume that the second input is always less than 10 (ie a digit from 0-9). For example:
```
(add-digit 123 4)
;Value: 1234

(add-digit 7 1)
;Value: 71
```

Reasonable Problems

You may collaborate on these problems.

Implement divisible?, which returns true if the first argument is divisible by the second. Using remainder is a good idea.
```
(divisible? 6 3)
;Value: #t
(divisible? 37 4)
;Value: #f
```
Implement slow-add, which adds two non-negative numbers together. The catch is that you may not use any arithmetic procedures other than inc (increment by 1), dec (decrement by 1), and zero? (is the number 0):
```
(inc 5)
;Value: 6
(dec 3)
;Value: 2
(zero? 0)
;Value: #t

(slow-add 5 3)
;Value: 8
```

Sticky Problems

These problems are sticky. Make sure you have a good plan before you go for implementation.

Write a procedure to find the smallest factor of a number. As a suggestion, have the procedure take in both the number n, and a factor f. The procedure should test to see if f is a factor, along with all possible factors greater than f. Some numbers may not have any factors in this range, if so, the procedure should return false. You should use divisible? from the previous problem.
```
(smallest-factor 8 3)
;Value: 4   (4 divides 8 and is between 3 and 8)
(smallest-factor 12 7)
;Value: #f  (12 has no factors larger than 7)
```
Building on the previous exercise, write prime?, which returns true if the number is prime. Remember that a prime number has no factors other than 1 and itself.
```
(prime? 4)
;Value: #f
(prime? 17)
;Value: #t
(prime? 569)
;Value: #t
```