Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

Common Lisp handles big numbers for you, so this problem is very easy.

(defparameter numbers '(
37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690 ))

(defun euler-13 ()
  (subseq (write-to-string (apply #'+ numbers))
              0 10))

What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 2020 grid?

This solution scans four rows at a time, saves the max adjacent product and scans the next four rows.

(defparameter *grid*
  '((08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08)
    (49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00)
    (81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65)
    (52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91)
    (22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80)
    (24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50)
    (32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70)
    (67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21)
    (24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72)
    (21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95)
    (78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92)
    (16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57)
    (86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58)
    (19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40)
    (04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66)
    (88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69)
    (04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36)
    (20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16)
    (20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54)
    (01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48)))

(defun max-r (grid)
  "Returns the maximum product of each rows elements"
  (apply #'max (mapcar #'(lambda (lst) (apply #'* lst))
                       grid)))

(defun max-c (grid)
  "Returns the maximum product of each columns elements"
  ;; Transpose the grid then call max-r
  (max-r (apply #'mapcar #'list grid)))

(defun diag-prod (grid &optional (accum 1))
  "Returns the product of the grids diagonal elements,
starting from the top left to the bottom right.
The function works recursively.  If there is a top-left
element in the grid, it multiplies accum by the element.
Then it calls itself with the top row and first column
of the grid removed"
  (if grid
      (diag-prod (mapcar #'cdr (cdr grid)) (* accum (caar grid)))
      accum))

(defun max-d (grid)
  "Returns the maximum product of each diagonals elements"
  (max (diag-prod grid)
           (diag-prod (mapcar #'reverse grid))))

(defun max-adj (grid)
  "Returns the maximum product of the grids adjacent elements.
Elements are multiplied in rows, columns, and diagonals"
  (max (max-r grid) (max-c grid) (max-d grid)))

(defun max-in-4byX (grid &optional (result 0))
  "Returns the maximum product of 4 adjacent elements in
a grid with 4 rows and a variable number of columns"
  (if (< (length (car grid)) 4)
      result
      (let* ((subgrid (mapcar #'(lambda (lst)
                                                  (subseq lst 0 4))
                                            grid))
                (max-in-subgrid (max-adj subgrid))
                (cur-result (cond ((< result max-in-subgrid) max-in-subgrid)
                                           (t result))))
          (max-in-4byX (mapcar #'cdr grid) cur-result))))

(defun euler-11 (grid &optional (result 0))
  "Calculates the max prod of 4 adjacent elements in the top 4 rows
of a grid, removes the top row and repeats.  Returns the maximum
product of 4 adjacent numbers in the entire grid"
  (if (< (length grid) 4)
      result
      (let* ((top-4-rows (subseq grid 0 4))
               (max-in-top-4 (max-in-4byX top-4-rows))
               (cur-result (cond ((< result max-in-top-4) max-in-top-4)
                                           (t result))))
        (euler-11 (cdr grid) cur-result))))

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. Find the sum of all the primes below two million.

This solution tests if a number is prime by testing if the number's smallest divisor is equal to itself. It then loops through all the odd numbers by two and sums the primes.

;;; Functions for testing if a number is prime
(defun square (x) (* x x))

(defun dividesp (a b)
  (zerop (mod b a)))

(defun find-divisor (n test-divisor)
  (cond ((> (square test-divisor) n) n)
        ((dividesp test-divisor n) test-divisor)
        (t (find-divisor n (+ test-divisor 1)))))

(defun smallest-divisor (n)
  (find-divisor n 2))

(defun primep (n)
  (= n (smallest-divisor n)))

;;; End of prime functions
  
(defun sum-of-primes-below (num)
  "Returns the sum of all the prime numbers below num"
  (+ 2 (loop for i from 3 to num by 2 when (primep i) sum i)))

(defun euler-10 ()
  (sum-of-primes-below 2000000))               

A Pythagorean triplet is a set of three natural numbers, a b c, for which a2 + b2 = c2.

For example, 32 + 42 = 9 + 16 = 25 = 52.

There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.

A brute-force solution in Common Lisp:

(defun sqrd (x)
  (* x x))

(defun pythag-trip-p (a b c)
  "Tests if a b and c satisfies the pythagorean equation"
  (eq (sqrd c)
        (+ (sqrd a) (sqrd b))))

(defun sum-eq-1000-p (a b c)
  "Tests if the sum equals 100"
  (= 1000 (+ a b c)))

(defun euler-9 ()
  (let ((result nil))
    (loop for a from 1 to 1000 until (not (null result)) do
     (loop for b from 1 to 1000 until (not (null result)) do
          (let ((c (sqrt (+ (sqrd a) (sqrd b)))))
             (when (sum-eq-1000-p a b c)
                   (print (list a b c))
                   (setf result (list a b c))))))
    (apply #'* result)))

Find the greatest product of five consecutive digits in the 1000-digit number.

;;; Use emacs to paste and format the 1000 digit number
(defvar long-number '(
7 3 1 6 7 1 7 6 5 3 1 3 3 0 6 2 4 9 1 9 2 2 5 1 1 9 6 7 4 4 2 6 5 7 4 
7 4 2 3 5 5 3 4 9 1 9 4 9 3 4 9 6 9 8 3 5 2 0 3 1 2 7 7 4 5 0 6 3 2 6 
2 3 9 5 7 8 3 1 8 0 1 6 9 8 4 8 0 1 8 6 9 4 7 8 8 5 1 8 4 3 8 5 8 6 1 
5 6 0 7 8 9 1 1 2 9 4 9 4 9 5 4 5 9 5 0 1 7 3 7 9 5 8 3 3 1 9 5 2 8 5 
3 2 0 8 8 0 5 5 1 1 1 2 5 4 0 6 9 8 7 4 7 1 5 8 5 2 3 8 6 3 0 5 0 7 1
5 6 9 3 2 9 0 9 6 3 2 9 5 2 2 7 4 4 3 0 4 3 5 5 7 6 6 8 9 6 6 4 8 9 5
0 4 4 5 2 4 4 5 2 3 1 6 1 7 3 1 8 5 6 4 0 3 0 9 8 7 1 1 1 2 1 7 2 2 3
8 3 1 1 3 6 2 2 2 9 8 9 3 4 2 3 3 8 0 3 0 8 1 3 5 3 3 6 2 7 6 6 1 4 2
8 2 8 0 6 4 4 4 4 8 6 6 4 5 2 3 8 7 4 9 3 0 3 5 8 9 0 7 2 9 6 2 9 0 4
9 1 5 6 0 4 4 0 7 7 2 3 9 0 7 1 3 8 1 0 5 1 5 8 5 9 3 0 7 9 6 0 8 6 6
7 0 1 7 2 4 2 7 1 2 1 8 8 3 9 9 8 7 9 7 9 0 8 7 9 2 2 7 4 9 2 1 9 0 1
6 9 9 7 2 0 8 8 8 0 9 3 7 7 6 6 5 7 2 7 3 3 3 0 0 1 0 5 3 3 6 7 8 8 1
2 2 0 2 3 5 4 2 1 8 0 9 7 5 1 2 5 4 5 4 0 5 9 4 7 5 2 2 4 3 5 2 5 8 4
9 0 7 7 1 1 6 7 0 5 5 6 0 1 3 6 0 4 8 3 9 5 8 6 4 4 6 7 0 6 3 2 4 4 1
5 7 2 2 1 5 5 3 9 7 5 3 6 9 7 8 1 7 9 7 7 8 4 6 1 7 4 0 6 4 9 5 5 1 4
9 2 9 0 8 6 2 5 6 9 3 2 1 9 7 8 4 6 8 6 2 2 4 8 2 8 3 9 7 2 2 4 1 3 7
5 6 5 7 0 5 6 0 5 7 4 9 0 2 6 1 4 0 7 9 7 2 9 6 8 6 5 2 4 1 4 5 3 5 1
0 0 4 7 4 8 2 1 6 6 3 7 0 4 8 4 4 0 3 1 9 9 8 9 0 0 0 8 8 9 5 2 4 3 4
5 0 6 5 8 5 4 1 2 2 7 5 8 8 6 6 6 8 8 1 1 6 4 2 7 1 7 1 4 7 9 9 2 4 4
4 2 9 2 8 2 3 0 8 6 3 4 6 5 6 7 4 8 1 3 9 1 9 1 2 3 1 6 2 8 2 4 5 8 6
1 7 8 6 6 4 5 8 3 5 9 1 2 4 5 6 6 5 2 9 4 7 6 5 4 5 6 8 2 8 4 8 9 1 2
8 8 3 1 4 2 6 0 7 6 9 0 0 4 2 2 4 2 1 9 0 2 2 6 7 1 0 5 5 6 2 6 3 2 1
1 1 1 1 0 9 3 7 0 5 4 4 2 1 7 5 0 6 9 4 1 6 5 8 9 6 0 4 0 8 0 7 1 9 8
4 0 3 8 5 0 9 6 2 4 5 5 4 4 4 3 6 2 9 8 1 2 3 0 9 8 7 8 7 9 9 2 7 2 4
4 2 8 4 9 0 9 1 8 8 8 4 5 8 0 1 5 6 1 6 6 0 9 7 9 1 9 1 3 3 8 7 5 4 9
9 2 0 0 5 2 4 0 6 3 6 8 9 9 1 2 5 6 0 7 1 7 6 0 6 0 5 8 8 6 1 1 6 4 6
7 1 0 9 4 0 5 0 7 7 5 4 1 0 0 2 2 5 6 9 8 3 1 5 5 2 0 0 0 5 5 9 3 5 7
2 9 7 2 5 7 1 6 3 6 2 6 9 5 6 1 8 8 2 6 7 0 4 2 8 2 5 2 4 8 3 6 0 0 8
2 3 2 5 7 5 3 0 4 2 0 7 5 2 9 6 3 4 5 0))

(defun euler-8 (num &optional (current-max 0))
  "Returns the greatest product of five consecutive digits in the
given number.  The digits must be supplied as a list"
  (if (< (length num) 5)
      current-max
      (let ((product (apply #'* (subseq num 0 5))))
        (if (> product current-max)
            (euler-8 (cdr num) product)
            (euler-8 (cdr num) current-max)))))

SICP Exerice 1.29
Simpson's Rule is a more accurate method of numerical integration than the method illustrated above. Using Simpson's Rule, the integral of a function f between a and b is approximated as

(h/3)(y0 + 4y1 + 2y2 + 4y3 + 2y4 + ...+ 2yn-2 + 4yn-4 + yn)

where h = (b - a)/n, for some even integer n, and yk = f(a + kh). (Increasing n increases the accuracy of the approximation.) Define a procedure that takes as arguments f, a, b, and n and returns the value of the integral, computed using Simpson's Rule. Use your procedure to integrate cube between 0 and 1 (with n = 100 and n = 1000), and compare the results to those of the integral procedure shown above.

(defun cube (x) (* x x x))

(defun sum (term a next b)
  (if (> a b)
      0
      (+ (funcall term a)
         (sum term (funcall next a) next b))))

(defun integral (f a b n)
  (let ((h (/ (- b a) n)))
    (labels ((yk (k)
                (funcall f (+ a (* k h))))
              (inc2 (n) (+ n 2)))
      (* (/ h 3)
         (+ (yk 0)
            (* 4 (sum #'yk 1 #'inc2 (- n 1)))
            (* 2 (sum #'yk 2 #'inc2 (- n 2)))
            (yk n))))))

SICP Exercise 1.30
The sum procedure above generates a linear recursion. The procedure can be rewritten so that the sum is performed iteratively. Show how to do this by filling in the missing expressions in the following definition:

(define (sum term a next b)
(define (iter a result)
(if <??>
<??>
(iter <??> <??>)))
(iter <??> <??>))

(defun new-sum (term a next b)
  (labels ((iter (a result)
             (if (> a b)
                 result
                 (iter (funcall next a)
                       (+ result (funcall term a))))))
    (iter a 0)))
 
(defun inc (x) (+ x 1))

SICP Exercise 1.31
a. The sum procedure is only the simplest of a vast number of similar abstractions that can be captured as higher-order procedures.51 Write an analogous procedure called product that returns the product of the values of a function at points over a given range. Show how to define factorial in terms of product. Also use product to compute approximations to using the formula

(pie/4)=((2/3)(4/3)(4/5)(6/5)(6/7)(8/7)...)

b. If your product procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

(defun product (term a next b)
  (if (> a b)
      1
      (* (funcall term a)
         (product term (funcall next a) next b))))

(defun new-product (term a next b)
  (labels ((iter (a result)
             (if (> a b)
                 result
                 (iter (funcall next a) (* result (funcall term a))))))
    (iter a 1)))

(defun factorial (n)
  (labels ((ident (x) x))
    (product #'ident 1 #'inc n)))

(defun my-pie (n)
  (labels ((num-term (n)
             (if (oddp n)
                 (- n 1)
                 n))
           (den-term (n)
              (if (evenp n)
                  (- n 1)
                  n)))
    (float(* 4
            (/ (product #'num-term 3 #'inc n)
            (product #'den-term 3 #'inc n))))))

SICP Exercise 1.32
a. Show that sum and product (exercise 1.31) are both special cases of a still more general notion called accumulate that combines a collection of terms, using some general accumulation function:

(accumulate combiner null-value term a next b)

Accumulate takes as arguments the same term and range specifications as sum and product, together with a combiner procedure (of two arguments) that specifies how the current term is to be combined with the accumulation of the preceding terms and a null-value that specifies what base value to use when the terms run out. Write accumulate and show how sum and product can both be defined as simple calls to accumulate.

b. If your accumulate procedure generates a recursive process,write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

(defun accumulate (combiner null-value term a next b)
  (if (> a b)
      null-value
      (funcall combiner (funcall term a)
               (accumulate combiner null-value term
                          (funcall next a)
                          next b))))

(defun new-accumulate (combiner null-value term a next b)
  (labels ((iter (a result)
             (if (> a b)
                 result
                 (iter (funcall next a)
                       (funcall combiner result (funcall term a))))))
    (iter a null-value)))

SICP Exercise 1.33
You can obtain an even more general version of accumulate (exercise 1.32) by introducing the notion of a filter on the terms to be combined. That is, combine only those terms derived from values in the range that satisfy a specified condition. The resulting filtered-accumulate abstraction takes the same arguments as accumulate, together with an additional predicate of one argument that specifies the filter. Write filtered-accumulate as a procedure. Show how to express the following using filtered-accumulate:

a. the sum of the squares of the prime numbers in the interval a to b (assuming that you have a prime? predicate already written)

b. the product of all the positive integers less than n that arerelatively prime to n (i.e., all positive integers i < n suchthat GCD(i,n) = 1).

(defun accumulate-if (filter combiner null-value term a next b)
  (cond ((> a b) null-value)
        ((funcall filter a)
         (funcall combiner
                 (funcall term a)
                 (accumulate-if filter
                                combiner
                                null-value
                                term
                                (funcall next a)
                                next
                                b)))
        (t (accumulate-if filter
                          combiner
                          null-value
                          term
                          (funcall next a)
                          next
                          b))))

(defun prime-squared-sum (a b)
  (accumulate-if 'primep
         '+
         0
         #'(lambda(x) (* x x))
         a
         'inc
         b))

(defun rel-prime-product (n)
  (labels ((rel-prime-p (x)
               (if (= 1 (gcd x n))
                   t)))
    (accumulate-if #'rel-prime-p
           '*
           1
           #'(lambda(x) x)
           1
           'inc
           (- n 1))))

SICP Exercise 1.35
Show that the golden ratio (section 1.2.2) is a fixed point of the transformation x - 1 + 1/x, and use this fact to compute GO by means of the fixed-point procedure.

(defconstant +tolerance+ .00001)

(defun fixed-point (f first-guess)
  (labels ((close-enough-p (v1 v2)
              (< (abs (- v1 v2)) +tolerance+))
       (try (guess)
         (let ((next (funcall f guess)))
           (if (close-enough-p guess next)
               next
              (try next)))))
    (try first-guess)))

SICP Exercise 1.36
Modify fixed-point so that it prints the sequence of approximations it generates, using the newline and display primitives shown in exercise 1.22. Then find a solution to xx = 1000 by finding a fixed point of x log(1000)/log(x). (Use Scheme's primitive log procedure, which computes natural logarithms.) Compare the number of steps this takes with and without average damping. (Note that you cannot start fixed-point with a guess of 1, as this would cause division by log(1) =
0.)

(defun fixed-point-print (f first-guess)
  (labels ((close-enough-p (v1 v2)
             (< (abs (- v1 v2)) +tolerance+))
       (try (guess)
         (print guess)
         (let ((next (funcall f guess)))
           (if (close-enough-p guess next)
               next
              (try next)))))
    (try first-guess)))

SICP Exercise 1.37
a. An infinite continued fraction is an expression of the form

f = N1/(D1+(N2/(D2+(N3/(D3+...

As an example, one can show that the infinite continued fraction expansion with the Ni and the Di all equal to 1 produces 1/phi , where phi is the golden ratio (described in section 1.2.2). One way to approximate an infinite continued fraction is to truncate the expansion after a given number of terms. Such a truncation -- a so-called k-term finite continued fraction -- has the form

N1/(D1+(N2/(...+Nk/Dk)

Suppose that n and d are procedures of one argument (the term index i) that return the Ni and Di of the terms of the continued fraction. Define a procedure cont-frac such that evaluating (cont-frac n d k) computes the value of the k-term finite continued fraction. Check your procedure by approximating1/phi using

(cont-frac (lambda (i) 1.0)
(lambda (i) 1.0)
k)

for successive values of k. How large must you make k in order to get an approximation that is accurate to 4 decimal places?b. If your cont-frac procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

(defun cont-frac (n d k &optional (i 1))
  (if (> i k)
      0
      (/ (funcall n i)
         (+ (funcall d i) (cont-frac n d k (+ i 1))))))

(defun cont-frac-iter (n d k &optional (i k) (result 0))
  (if (< i 1)
      result
      (cont-frac-iter n d k
              (- i 1)
              (/ (funcall n i)
                 (+ (funcall d i) result)))))

SICP Exercise 1.38
In 1737, the Swiss mathematician Leonhard Euler published a memoir De Fractionibus Continuis, which included a continued fraction expansion for e - 2, where e is the base of the natural logarithms. In this fraction, the Ni are all 1, and the Di are successively 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, .... Write a program that uses your cont-frac procedure from exercise 1.37 to approximate e, based on Euler's expansion.

(defun d (i)
  "The D function to pass to cont-frac"
  (cond ((= i 2) 2)
        ((zerop (mod (+ 1 i) 3)) (- i (/ i 3)))
        (t 1)))

SICP Exercise 1.39
A continued fraction representation of the tangent function was published in 1770 by the German mathematician J.H. Lambert:

tan r = r/(1-(r^2/(3-(r^2/5-....

where x is in radians. Define a procedure (tan-cf x k) that computes an approximation to the tangent function based on Lambert's formula. K specifies the number of terms to compute, as in exercise 1.37.

(defun tan-cf (x k)
  (labels ((tan-n (i)
            (if (= i 1)
                x
                (- (* x x))))
          (tan-d (i)
             (if (= i 1)
                 1
                (- (* 2 i)
                   1))))
    (cont-frac #'tan-n #'tan-d k)))

SICP Exercise 1.40
Define a procedure cubic that can be used together with the
newtons-method procedure in expressions of the form (newtons-method
(cubic a b c) 1) to approximate zeros of the cubic x3 + ax2 + bx + c.

;;; Scheme functions redefined in CL

(defconstant +tolerance+ 0.00001)

(defconstant +dx+ 0.00001)

(defun deriv (g)
  (lambda (x)
    (/ (- (funcall g (+ x +dx+)) (funcall g x))
       +dx+)))

(defun newton-transform (g)
  (lambda (x)
    (- x (/ (funcall g x) (funcall (deriv g) x)))))

(defun newton-method (g guess)
  (fixed-point (newton-transform g) guess))

;;; Cubic function
(defun cubic (a b c)
  (lambda (x)
    (+ (* x x x)
       (* a x x)
       (* b x)
       c)))

SICP Exercise 1.41
Define a procedure double that takes a procedure of one argumentasargument and returns a procedure that applies the original proceduretwice. For example, if inc is a procedure that adds1 to its argument,then (double inc) should be a procedure that adds 2. What value is returned by (((double (double double)) inc) 5)

(defun double (procedure)
  (lambda (x)
    (funcall procedure (funcall procedure x))))

SICP Exercise 1.42
Let f and g be two one-argument functions. The composition f afterg is defined to be the function x f(g(x)). Define a procedure compose that implements composition. For example, if inc is a procedure that adds 1 to its argument,((compose square inc) 6) 49

(defun compose (f g)
  (lambda (x)
    (funcall f (funcall g x))))

SICP Exercise 1.43
If f is a numerical function and n is a positive integer, then we can form the nth repeated application of f, which is defined to be the function whose value at x is f(f(...(f(x))...)). For example, if f is the function x x + 1, then the nth repeated application of f is the function x x + n. If f is the operation of squaring a number, then the nth repeated application of f is the function that raises its argument to the 2nth power. Write a procedure that takes as inputs a procedure that computes f and a positive integer n and returns the procedure that computes the nth repeated application of f. Your procedure should be able to be used as follows:
((repeated square 2) 5)
625

(defun repeated (f n &optional (count 1))
  (if (>= count n)
      (lambda (x) (funcall f x))
      (compose (repeated f n (+ count 1)) f)))

SICP Exercise 1.44
The idea of smoothing a function is an important concept in signal processing. If f is a function and dx is some small number, then the smoothed version of f is the function whose value at a point x is the average of f(x - dx), f(x), and f(x + dx). Write a procedure smooth that takes as input a procedure that computes f and returns a procedure that computes the smoothed f. It is sometimes valuable to repeatedly smooth a function (that is, smooth the smoothed function, and so on) to obtained the n-fold smoothed function. Show how to generate the n-fold smoothed function of any given function using smooth and repeated from exercise 1.43.

(defun smoothed (f)
  (lambda (x)
    (/ (+ (funcall f (- x +dx+))
          (funcall f x)
          (funcall f (+ x +dx+)))
        3)))

(defun n-fold-smoothed (f n)
  (repeated (smoothed f) n))

SICP Exercise 1.45
We saw in section 1.3.3 that attempting to compute square roots by naively finding a fixed point of y x/y does not converge, and that this can be fixed by average damping. The same method works for finding cube roots as fixed points of the average-damped y x/y2. Unfortunately, the process does not work for fourth roots -- a single average damp is not enough to make a fixed-point search for y x/y3 converge. On the other hand, if we average damp twice (i.e., use the average damp of the average damp of y x/y3) the fixed-point search does converge. Do some experiments to determine how many average damps are required to compute nth roots as a fixed-point search based upon repeated average damping of y x/yn-1. Use this to implement a simple procedure for computing nth roots using fixedpoint, average-damp, and the repeated procedure of exercise 1.43. Assume that any arithmetic operations you need are available as primitives.

;;; Scheme functions redefined in CL
(defun average-damp (f)
  (lambda (x) (/ (+ x (funcall f x))
                 2)))
;;; End scheme functions

(defun nth-root (x n times)
  (fixed-point (repeated (average-damp (lambda (y) 
                                         (/ (+ y
                                              (/ x (expt y (- n 1))))
                                             2)))
                         times)
                 1.0))

SICP Exercise 1.46
Several of the numerical methods described in this chapter are instances of an extremely general computational strategy known as iterative improvement. Iterative improvement says that, to compute something, we start with an initial guess for the answer, test if the guess is good enough, and otherwise improve the guess and continue the process using the improved guess as the new guess. Write a procedure iterative-improve that takes two procedures as arguments: a method for telling whether a guess is good enough and a method for improving a guess. Iterative-improve should return as its value a procedure that takes a guess as argument and keeps improving the guess until it is good enough. Rewrite the sqrt procedure of section 1.1.7 and the fixed-point procedure of section 1.3.3 in terms of iterative-improve.

(defun iterative-improve (good-enough-p improve)
  (lambda (x)
    (labels ((next-guess (guess)
              (let ((improved-guess (funcall improve guess)))
                (if (funcall good-enough-p guess improved-guess)
                    improved-guess
                    (next-guess improved-guess)))))
      (next-guess x))))

(defun sqrt-improve (x)
  (funcall (iterative-improve (lambda (guess z)
                                (let ((ratio (/ guess z)))
                                   (and (< ratio 1.001) (> ratio 0.999))))
                              (lambda (guess)
                                 (/ (+ guess (/ x guess))
                                     2)))
           1.0))

SICP Exercise 1.11
A function f is defined by the rule that f(n) = n if n<3 and f(n) = f(n - 1) + 2f(n - 2) + 3f(n - 3) if n> 3. Write a procedure that computes f by means of a recursive process. Write a procedure that computes f by means of an iterative process.

(defun f (n)
  "Recursive"
  (cond ((< n 3) n)
             (t (+ (f (- n 1))
                     (* 2 (f (- n 2)))
                     (* 3 (f (- n 3)))))))

(defun f2 (n)
  "Iterative"
  (if (< n 3)
      n
      (f2-iter n 2 1 0)))

(defun f2-iter (count &optional fn-1 fn-2 fn-3)
  (if (< count 3)
      fn-1
      (progn (psetf fn-1 (+ fn-1 (* 2 fn-2) (* 3 fn-3))
                            fn-2 fn-1
                            fn-3 fn-2)
         (f2-iter (- count 1) fn-1 fn-2 fn-3))))

SICP Exercise 1.12
Write a procedure that computes elements of Pascal's triangle by means of a recursive process.

(defun gen-row (lst)
  "Given a list of values of the above row in Pascal's triangle, 
generates the values in the current row except for the leading and
trailing 1"
  (when (> (length lst) 1)
    (cons (+ (first lst) (second lst)) (gen-row (cdr lst)))))

(defun pascal (row)
  "Returns the values in the given row number of Pascal;s triangle"
  (if (eq row 1)
      '(1)
      (append '(1) (gen-row (pascal (- row 1))) '(1))))

SICP Exercise 1.16
Design a procedure that evolves an iterative exponentiation process that uses successive squaring and uses a logarithmic number of steps, as does fast-expt. (Hint: Using the observation that (bn/2)2 = (b2)n/2, keep, along with the exponent n and the base b, an additional state variable a, and define the state transformation in such a way that the product a bn is unchanged from state to state. At the beginning of the process a is taken to be 1, and the answer is given by the value of a at the end of the process. In general, the technique of defining an invariant quantity that remains unchanged from state to state is a powerful way to think about the design of iterative algorithms.)

(defun my-expt (b n &optional (result 1))
  (cond ((zerop n) result)
        ((evenp n)  (my-expt (* b b) (/ n 2) result))
        (t (my-expt b (- n 1) (* b result)))))

SICP Exercise 1.17
The exponentiation algorithms in this section are based on performing exponentiation by means of repeated multiplication. In a similar way, one can perform integer multiplication by means of repeated addition. The following multiplication procedure (in which it is assumed that our language can only add, not multiply) is analogous to the expt procedure:
(define (* a b)
(if (= b 0)
0
(+ a (* a (- b 1)))))
This algorithm takes a number of steps that is linear in b. Now suppose we include, together with addition, operations double, which doubles an integer, and halve, which divides an (even) integer by 2. Using these, design a multiplication procedure analogous to fast-expt that uses a logarithmic number of steps.

(defun double (x) (+ x x))
(defun half (x) (/ x 2))

(defun fast-mult (a b)
  (cond ((zerop b) 0)
        ((evenp b) (double (fast-mult a (half b))))
        (t (+ a (fast-mult a (- b 1))))))

SICP Exercise 1.18
Using the results of exercises 1.16 and 1.17, devise a procedure that generates an iterative process for multiplying two integers in terms of adding, doubling, and halving and uses a logarithmic number of steps.

(defun my-mult (a b &optional (result 0))
  (cond ((zerop b) result)
        ((evenp b) (my-mult (double a) (half b)  result))
        (t (my-mult a (- b 1) (+ a result)))))

SICP Exercise 1.22
Most Lisp implementations include a primitive called runtime that returns an integer that specifies the amount of time the system has been running (measured, for example, in microseconds). The following timed-prime-test procedure, when called with an integer n, prints n and checks to see if n is prime. If n is prime, the procedure prints three asterisks followed by the amount of time used in performing the test.
(define (timed-prime-test n)
(newline)
(display n)
(start-prime-test n (runtime)))
(define (start-prime-test n start-time)
(if (prime? n)
(report-prime (- (runtime) start-time))))
(define (report-prime elapsed-time)
(display " *** ")
(display elapsed-time))
Using this procedure, write a procedure search-for-primes that checks the primality of consecutive odd integers in a specified range. Use your procedure to find the three smallest primes larger than 1000; larger than 10,000; larger than 100,000; larger than 1,000,000. Note the time needed to test each prime. Since the testing algorithm has order of growth of (n), you should expect that testing for primes around 10,000 should take about 10 times as long as testing for primes around 1000. Do your timing data bear this out? How well do the data for 100,000 and 1,000,000 support the n prediction? Is your result compatible with the notion that programs on your machine run in time proportional to the number of steps required for the computation?

;;; Redefine given functions for common lisp
(defun smallest-divisor (n)
  (find-divisor n 2))

(defun find-divisor (n test-divisor)
  (cond ((> (square test-divisor) n) n)
            ((dividesp test-divisor n) test-divisor)
            (t (find-divisor n (+ test-divisor 1)))))

(defun dividesp (a b) (zerop (mod b a)))

(defun square (x) (* x x))

(defun primep (n) (= n (smallest-divisor n)))

(defun timed-prime-test (n)
  (print n)
  (start-prime-test n (get-internal-run-time)))

(defun start-prime-test (n start-time)
  (if (primep n)
      (report-prime (- (get-internal-run-time) start-time))))

(defun report-prime (elapsed-time)
  (print '***)
  (print elapsed-time))

(defun search-for-primes (start end)
  (loop for i from start to end do (timed-prime-test i)))

Exercise 1.3
Define a procedure that takes three numbers as arguments and returns the sum of the squares of the two larger numbers.

(defun square (x) (* x x))

(defun sum-of-squares (lst)
  (apply #'+ (mapcar #'square lst)))

(defun get-largest-2 (lst)
  (when (>= (length lst) 2)
    (let ((sorted-lst (sort lst #'>)))
      (list (first sorted-lst)
            (second sorted-lst)))))

;;; This does better and takes any number of arguments
(defun sum-sqr-lrgst (lst)
  (sum-of-squares (get-largest-2 lst)))

Exercise 1.8
Newton's method for cube roots is based on the fact that if y is an approximation to the cube root of x, then a better approximation is given by the value
(x/y^2 + 2y)/3
Use this formula to implement a cube-root procedure analogous to the square-root procedure.

(defconstant +tolerance+ 0.001)

(defun cube (x) (* x x x))

(defun good-enough-p (guess x)
  "Returns true if the cube of the guess differs from x by less 
than the tolerance"
  (< (abs (- (cube guess) x)) +tolerance+))

(defun improve (guess x)
  "Returns a better approximation of the cube root of x"
  (/ (+ (/ x
           (square guess))
       (* 2 guess))
     3))

(defun cube-rt-iter (guess x)
  (if (good-enough-p guess x)
      guess
      (cube-rt-iter (improve guess x) x)))

(defun cube-rt (x)
  "Calculates the cube root of x"
  (cube-rt-iter 1.0 x))

I am creating a Java web application using Spring and Hibernate. Although I clearly see the benefit of using the Spring framework and Hibernate object/relational mapping tool, configuring it properly can cause some headaches.

Recently I was using Spring's HibernateTemplate to retrieve a list of users from my database. After successfully running a simple query, I then wanted to return the users starting at result number 10 instead of 0. I scanned HibernateTemplate's api to no avail, then searched Google and, to my surprise, found there was no way to return specific rows using HibernateTemplate. The forum posts suggested using Hibernate session instead.

I added a SessionFactory to my class and changed my query code to something like this:

return sessionFactory.getCurrentSession().createQuery("FROM User")
                .setMaxResults(10).setFirstResult(10).list();

I confidently ran the code and received the following error:

- Method execution failed:
org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

This error happened because I did not have my transaction managment configured properly. HibernateTemplate handles this on its own, but when using Hibernate sessions directly, put something like this in your Spring bean files:

 <!-- enable the configuration of transactional behavior based on annotations -->  
      <tx:annotation-driven />
  
   <!-- a PlatformTransactionManager is still required -->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>

More information can be found in the Spring documentation.

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10001st prime number?

This Common Lisp solution uses the Sieve of Eratosthenes algorithm to find all the prime numbers under a million then returns the 10001st prime.

(defconstant +max+ 1000000)

(defun range (start end)
  "Creates a list of integers from start to end"
 (loop for i from start to end collect i))

(defun e.6 ()
  (let ((limit (sqrt +max+))
         (lst (range 2 +max+)))
    (loop for i in lst until (> i limit) do
     ;; Delete all multiples of i from the list
     (delete-if #'(lambda (x)
                           (and (not (eq x i))
                                   (zerop (mod x i))))
               lst))
    ;; The resulting list is a list of all prime numbers
    ;; up to +max+.  Get the 10001st prime number
    (nth 10000 lst)))