0. #lang scheme
1. ;;-------------------------------------------------------------------------------
2. ;; Name:
3. ;; Pledge:
4. ;;-------------------------------------------------------------------------------
5. ;; This lab serves as an introduction to using recursion in Scheme.
6. ;; You should implement every function in this program recursively.
7. ;;
8. ;; NOTE: the empty list is a valid input for each function!
9. ;;
10. ;; Also, just because your code works for provided test cases
11. ;;   doesn't mean it always works.
12. ;; Always come up with your own test cases too!
13. ;; Implement your version of multiplication denoted by the symbol @. @ should take as arguments
14. ;; an integer a and a non-negative integer b. The return value of @ should be a*b. HOWEVER, the only
15. ;; arithmetic operation you're allowed to use is +.
16. ;; Examples:
17. ;; (@ 7 3) -> 21
18. ;; (@ 8 0) -> 0
19. ;; (@ -3 4) -> 12
20. ;; (@ 0 4) -> 0
21. ;; (@ -5 1) -> -5
22. ;; Type signature: (@integer integer) -> integer
23. (define (@ a b)
24.    "Your code comes here"
25.   )
26. ;; Implement the "power" function which takes as its arguments a positive integer x and a non-negative
27. ;; integer n. "power" shoud return x raised to the power of n. HOWEVER, the only
28. ;; arithmetic operation you're allowed to use is *.
29. ;; Examples:
30. ;; (power 3 2) -> 9
31. ;; (power 2 10) -> 1024
32. ;; (power 3 1) -> 3
33. ;; (power 7 0) -> 1
34. ;; Type signature: (power integer integer) -> integer
35. (define (power x n)
36.  "Your code comes here"
37.   )
38. ;; Implement "nth", which returns the element at index n of the provided list.
39. ;; The first element of the list is at index 0, the second at index 1, etc.
40. ;; You may assume that the "n" provided is non-negative and less than the list's length.
41. ;; Examples:
42. ;; (nth 1 '(Sandeep Owen Jared Sarvani)) -> Owen
43. ;; (nth 5 '("zero" "one" "two" "three" "four" "five")) -> "five"
44. ;; (nth 0 '(a b c)) -> 'a
45. ;; Type signature: (nth integer list) -> element from list
46. (define (nth n lst)
47.  "Your code comes here"
48.   )
49. ;; Implement "sum of squares", which returns the summation of squares of all the elements in
50. ;; the given list. You may assume that the list will only contain numbers.
51. ;; Note: mathematical convention is that the sum of squares of nothing is 0.
52. ;; Examples:
53. ;; (sum2 '(1 3 5 1)) -> 36
54. ;; (sum2 '(75050 344 0 -70 125)) -> 5632641361
55. ;; Type signature: (sum2 number-list) -> number
56. (define (sum2 lst)
57.  "Your code comes here"
58. )
59. ;; Implement "product", which returns the result of multiplying all elements in the list.
60. ;; You may assume that the list will only contain numbers.
61. ;; Note: mathematical convention is that the product of nothing is 1.
62. ;; Examples:
63. ;; (product (list 1 3 5 4)) -> 60
64. ;; (product '(100 -50 6789 4183457)) -> -142007447865000
65. ;; Type signature: (product number-list) -> number
66. (define (product lst)
67.  "Your code comes here"
68. )
69. ;; Implement the following continued fraction function denoted as "cf" and defined as follows.
70. ;; "cf" takes as its only argument a list of positive integers. If the list has length 1, then the
71. ;; only element of the list is returned as the function's value. Otherwise, the function returns the
72. ;; fraction built according to the pattern below
73. ;; (cf '(a))     ->  a
74. ;;
75. ;; (cf '(a b))   ->        1
76. ;;                    a + ---
77. ;;                         b
78. ;;
79. ;; (cf '(a b c)) ->               1
80. ;;                    a    +  ------------
81. ;;                                    1
82. ;;                              b   + ---
83. ;;                                     c
84. ;;
85. ;; (cf '(a b c d)) ->               1
86. ;;                     a    +  ----------------
87. ;;                                        1
88. ;;                              b   + ---------
89. ;;                                     c  +  1
90. ;;                                          ---
91. ;;                                           d
92. ;;
93. ;; and so on.
94. ;;
95. ;; Examples:
96. ;; Approximation for Pi
97. ;; (exact->inexact (cf '(3 7 15 1 292 1))) -> 3.141592653921421
98. ;; Approximation for square root of 2
99. ;; (exact->inexact (cf '(1 2 2 2 2 2 2 2 2 2 2 2 2 2 2))) -> 1.4142135623637995
100. ;; Approximation for golden ratio
101. ;; (exact->inexact (cf '(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))) -> 1.618034447821682
102. ;;
103. ;; Type signature (cf number-list) -> fraction
104. (define (cf number-list)
105.  "Your code comes here"
106.   )
107. ;; Implement "2filter", which accepts a predicate (a function that returns a boolean) and a list,
108. ;; and returns the same list except that for every element satisfing the predicate a new copy of
109. ;; that element is added. The new copy should be added beside the element which makes the predicate
110. ;; return #t.
111. ;; Examples
112. ;; (2filter zero? '(1 0 2 34 56 1 0)) -> '(1 0 0 2 34 56 1 0 0)
113. ;; (2filter even? '(0 1 2 3 4 5 6 7 8 9)) -> '(0 0 1 2 2 3 4 4 5 6 6 7 8 8 9)
114. ;; (2filter number? '(shave and 1 haircut 2 bits)) -> '(shave and 1 1 haircut 2 2 bits)
115. ;; (2filter (lambda (x) (> x 10)) '(1 0 2 34 56 1 0) ) -> (1 0 2 34 34 56 56 1 0)
116. ;; Type signature: (2filter predicate list) -> list
117. (define (2filter pred lst)
118.  "Your code comes here"
119.  )
120. ;; Created January 2018 by Samuel Kraus and Edward Minnix
121. ;; Updated January 2020 by Jared Pincus
122. ;; Modified Januare 2022 by Jacek Ossowski

=>