#
CMU 15-112: Fundamentals of Programming and Computer Science

Day2 Practice (Due never)

- These problems will help you prepare for hw2, and quiz1.
- To start:
- Go to your folder named 'week1'
- Download day2_practice.py to that folder
- Edit day2_practice.py using pyzo

- Do not use lists or recursion.
- Do not hardcode the test cases in your solutions.

**Code Tracing**

What will this code print? Figure it out by hand, then run the code to confirm. Then slightly edit the code and try again.

**Trace #1 of 3:**def ct1(m, n): total = 0 for x in range(m, n+1, 3): print('x =', x) total += x for y in range(m, m+2): print('y = ', y) total += y return total print(ct1(1,9))**Trace #2 of 3:**def ct2(n): k = 0 total = 0 while (n >= k): print('k =', k) for i in range(k): total += n%10 n //= 10 print(i, n%10, total) k += 1 print('total =', total) print(ct2(1234))**Trace #3 of 3:**def ct3(z): total = 0 for y in range(z,1,-1): if (y % 2 == 0): print('skip y =', y) continue total += y if (total > 20): print('break at y =', y) break return total print(ct3(10))

**Reasoning Over Code**

Find parameter(s) to the following functions so that they return True. Figure it out by hand, then run the code to confirm. There may be more than one correct answer for each function, and you can provide any one of them.

**RC #1 of 2:**def rc1(n): if ((not isinstance(n, int)) or (n > 100)): return False total = 0 while (n > 0): total = 10*total + n%10 n //= 10 return (total == 42)**RC #2 of 2:**def f(n): if (n == 0): return 1 n = abs(n) count = 0 while (n > 0): count += 1 n //= 10 return count def rc2(m): if (not(isinstance(m, int)) or (m < 0)): return False start = 0 while True: count = 0 for n in range(start, start+3): count += f(n) if (count > 9): break start += 1 return (m == start)

**Free Response (Problem-Solving)**

**digitCount(n)**

Write the function digitCount(n) that takes a possibly-negative int and returns the number of digits in it. So, digitCount(12323) returns 5, digitCount(0) returns 1, and digitCount(-111) returns 3. One way you could do this would be to return len(str(abs(n))), but you cannot do that, since you may not use strings here! This can be solved with logarithms, but seeing as this is "loops week", you should instead simply repeatedly remove the ones digit until you cannot.**hasConsecutiveDigits(n)**

Write the function hasConsecutiveDigits(n) that takes a possibly- negative int value n and returns True if that number contains two consecutive digits that are the same, and False otherwise.**gcd(m, n)**

[Note: to receive any credit, you must solve this problem using Euclid's algorithm, and by no other means. In particular, do not just loop through all integers less than min(m,n) and find the common factors that way -- it is much too slow!]

According to Euclid, the greatest common divisor, or gcd, can be found like so:

gcd(x,y) == gcd(y, x%y)

We can use that to quickly find gcd's. For example:

gcd(270,250) == gcd(250, 20) # 270 % 250 == 20

== gcd(20, 10) # 250 % 20 == 10

== gcd(10, 0) # 20 % 10 == 0

When we get to gcd(x,0), the answer is x. So gcd(270, 250) is 10. With this in mind, write the function gcd(x,y) that takes two positive integers x and y and returns their gcd using Euclid's gcd algorithm.**countingPrimes**

Do the "Counting Primes" problem here.**nthAdditivePrime(n)**

Write the function nthAdditivePrime(n) that takes a non-negative int n and returns the nth Additive Prime, which is a prime number such that the sum of its digits is also prime. For example, 113 is prime and 1+1+3==5 and 5 is also prime, so 113 is an Additive Prime.**nthPerfectNumber(n)**

Write the function nthPerfectNumber(n) that takes a non-negative integer n and returns the nth perfect number, starting at n=0, where a number is perfect if it is the sum of its positive divisors less than itself. For example, 6 is perfect because 6 = 1 + 2 + 3. Also, 28 is perfect because 28 = 1 + 2 + 4 + 7 + 14. The next one is 496, then 8128. For full credit, you need to use a faster version, which uses the same observation that sped up isPrime, so that you only have to search for factors up to the square root of n.

**longestDigitRun(n)**

Write the function longestDigitRun(n) that takes a possibly-negative int value n and returns the digit that has the longest consecutive run, or the smallest such digit if there is a tie. So, longestDigitRun(117773732) returns 7 (because there is a run of 3 consecutive 7's), as does longestDigitRun(-677886).**longestIncreasingRun(n)**

Write the function longestIncreasingRun that takes in a positive int value n and returns the longest increasing run of digits. For example longestIncreasingRun(1232) would return 123 and longestIncreasingRun(27648923679) returns 23679. If there is a tie in run length, the larger of the two runs should be returned. So longestIncreasingRun(123345) would return 345.**nthPalindromicPrime(n)**

Write the function nthPalindromicPrime(n). See here for details. So nthPalindromicPrime(0) returns 2, and nthPalindromicPrime(10) returns 313.**nthLeftTruncatablePrime(n)**

Write the function nthLeftTruncatablePrime(n). See here for details. So nthLeftTruncatablePrime(0) returns 2, and nthLeftTruncatablePrime(10) returns 53.**nthCarolPrime(n)**

Write the function nthCarolPrime(n), which takes a non-negative int and returns the nth Carol Prime, which is a prime number of the form ((2**k - 1)**2 - 2) for some value positive int k. For example, if k equals 3, ((2**3 - 1)**2 -2) equals 47, which is prime, and so 47 is a Carol Prime. The first several Carol primes are: 7, 47, 223, 3967, 16127, 1046527, 16769023,... As such, nthCarolPrime(0) returns 7.

Note: You must use a reasonably efficient approach that quickly works up to n==9, which will return a 12-digit answer! In particular, this means you cannot just edit isPrime. Hint: you may need to generate only Carol numbers, and then test those as you go for primality (and you may need to think about that hint for a while for it to make sense!).**rotateStringLeft(s, k)**

Write the function rotateStringLeft that takes a string s and a non-negative integer k, and returns the string s rotated k places to the left.**rotateStringRight(s, k)**

Write the function rotateStringRight that takes a string s and a non-negative integer k, and returns the string s rotated k places to the right.**Happy Primes**

Background: read the first paragraph from the Wikipedia page on happy numbers. After some thought, we see that no matter what number we start with, when we keep replacing the number by the sum of the squares of its digits, we'll always either arrive at 4 (unhappy) or at 1 (happy). With that in mind, we want to write the function nthHappyNumber(n). However, to write that function, we'll first need to write isHappyNumber(n) (right?). And to write that function, we'll first need to write sumOfSquaresOfDigits(n). And that's top-down design! Here we go....

Note: the autograder will grade each of the following functions, so they are required. However, they also are here specifically because they are just the right helper functions to make nthHappyNumber(n) easier to write!**sumOfSquaresOfDigits(n)**

Write the function sumOfSquaresOfDigits(n) which takes a non-negative integer and returns the sum of the squares of its digits. Here are some test assertions for you (note that in the hw2.py starter file, instead of assert, these use assertEqual):assert(sumOfSquaresOfDigits(5) == 25) # 5**2 = 25 assert(sumOfSquaresOfDigits(12) == 5) # 1**2 + 2**2 = 1+4 = 5 assert(sumOfSquaresOfDigits(234) == 29) # 2**2 + 3**2 + 4**2 = 4 + 9 + 16 = 29

**isHappyNumber(n)**

Write the function isHappyNumber(n) which takes a possibly-negative integer and returns True if it is happy and False otherwise. Note that all numbers less than 1 are not happy. Here are some test assertions for you:assert(isHappyNumber(-7) == False) assert(isHappyNumber(1) == True) assert(isHappyNumber(2) == False) assert(isHappyNumber(97) == True) assert(isHappyNumber(98) == False) assert(isHappyNumber(404) == True) assert(isHappyNumber(405) == False)

**nthHappyNumber(n)**

Write the function nthHappyNumber(n) which takes a non-negative integer and returns the nth happy number (where the 0th happy number is 1). Here are some test assertions for you:assert(nthHappyNumber(0) == 1) assert(nthHappyNumber(1) == 7) assert(nthHappyNumber(2) == 10) assert(nthHappyNumber(3) == 13) assert(nthHappyNumber(4) == 19) assert(nthHappyNumber(5) == 23) assert(nthHappyNumber(6) == 28) assert(nthHappyNumber(7) == 31)

**nthHappyPrime(n)**

A happy prime is a number that is both happy and prime. Write the function nthHappyPrime(n) which takes a non-negative integer and returns the nth happy prime number (where the 0th happy prime number is 7).

**mostFrequentDigit(n)**

Write the function mostFrequentDigit(n), that takes a non-negative integer n and returns the digit from 0 to 9 that occurs most frequently in it, with ties going to the smaller digit.**nthPowerfulNumber(n)**

Write the function nthPowerfulNumber(n). See here for details. So nthPowerfulNumber(0) returns 1, and nthPowerfulNumber(10) returns 64.**findZeroWithBisection(f, x0, x1, epsilon)**

Write the function findZeroWithBisection(f, x0, x1, epsilon) as described here.