A node is a
(define-struct node (left right))
A leafy binary tree (LBT) is one of
; - 'leaf
; - (make-node LBT LBT)
I have to design a function that takes in a natural number n and creates a list of all leafy binary trees that have height n.
So for example, a height of 2 should return:
`(list
(make-node 'leaf (make-node 'leaf 'leaf))
(make-node (make-node 'leaf 'leaf) 'leaf)
(make-node (make-node 'leaf 'leaf) (make-node 'leaf 'leaf)))`
I've been stuck on this assignment for days now. The best I could come up with was:
`(define (lbt-list n)
(cond [(= 0 n) 'leaf]
[(= 1 n) (cons (make-node (lbt-list (- n 1)) (lbt-list (- n 1))) empty)]
[else (list (make-node (first (lbt-list (- n 1))) (lbt-list (- n n)))
(make-node (lbt-list (- n n)) (first (lbt-list (- n 1))))
(make-node (first (lbt-list (- n 1))) (first (lbt-list (- n 1)))))]))`
The problem involves recursion and I'm just not sure how to fully code out this function. Any help would be appreciated!
You are trying to make nodes out of lists; the only valid arguments to make-node are leafs and nodes. Instead, you should take the results of lbt-list and use each of its elements to make each of the nodes for the list to be returned.
Also, you never use the rest of any returned lbt-list.
To start, the reason why you're only getting three trees is that your else clause calls list with exactly three instances of make-node. This might be a little easier to see if you make (= n 1) your base case, and explicitly use 'leaf wherever you need it, instead of (lbt-list (- n n)).
I think you'll benefit from stepping back from the code for a second and asking yourself what mathematical products you're trying to generate. In particular, how do you get the n-depth binary trees from the (n-1)-depth binary trees?
It's simplest to break it into three parts. Here are two big hints:
is make-node commutative?
how is the level-on-level generation related to a Cartesian product?
Finally, helper functions are your friend here - they'll go a long way towards dividing the mental burden of generating the list into smaller pieces. I wrote three helper functions when I threw together a solution, but you might be able to make do with two.
Related
While developing a classical exercise piece of code for odd and even functions in MIT/GNU Scheme (rel 9.2), I encountered a problem that my code does not terminate for a big integer value.
First, I tested the following code, which processes both positive and negative values:
(define error-message-number "Error. x must be a number")
(define odd?
(lambda (x)
(cond
((not (integer? x)) error-message-number)
((= x 0) #f)
((< x 0) (even? (+ x 1))) ;for negatives
(else (even? (- x 1)))))) ;if number n is odd then n - 1 is even
(define even?
(lambda (x)
(cond
((not (integer? x)) error-message-number)
((= x 0) #t)
((< x 0) (odd? (+ x 1))) ;for negatives
(else (odd? (- x 1)))))) ;if number n is even then n - 1 is odd
The calls (assert (equal? #f (even? 100000000001))) and (assert (equal? #t (odd? -100000000001))) do not terminate on my machine, while, e.g. (assert (equal? #f (even? 1001))) and (assert (equal? #t (odd? -1001))) do.
My first thought was that the code is not optimized for proper tail recursion, while I have not one, but two tail calls in each function.
So, I decided to simplify the task and make a take for positive integers only, like this:
(define error-message-positive "Error. x must be a nonnegative number")
(define odd-positive?
(lambda (x)
(cond
((not (integer? x)) error-message-number)
((= x 0) #f)
((< x 0) error-message-positive) ;for negatives
(else (even? (- x 1)))))) ;if number n is odd then n - 1 is even
(define even-positive?
(lambda (x)
(cond
((not (integer? x)) error-message-number)
((= x 0) #t)
((< x 0) error-message-positive) ;for negatives
(else (odd? (- x 1)))))) ;if number n is even then n - 1 is odd
But this version does not return either for big integers.
So, I have these related questions:
Features. Are mutually recursive functions in MIT/GNU Scheme optimized at all?
Diagnostics. Is there any way one can tell the functions were indeed optimized for mutual tail recursion by Scheme compiler/interpreter. So, how can one tell the problem is in (absence of) tail recursion optimization, or in some other thing.
What is proper mutual tail recursion? Does my initial code qualify for optimization? Does my second take qualify for it?
What is proper mutual tail recursion?
Just like your code, both versions of them.
Diagnostics.
Empirical orders of growth FTW!
Your diagnosis just might be incorrect. In particular, on my machine, in Racket, the expected time of your code to finish is 40 minutes. And it does seem to run in constant memory overall.
Yes, even while running in constant space it still takes time linear in the magnitude of argument. How do I know? I simply measured it in clock wall time, and it indeed scales as linear i.e. n1 power law. Approximately. (i.e. whether it measured as 1.02 or 0.97, it still indicates linear growth rate. approximately. which is all that matters).
See also:
Painter puzzle - estimation
Features. Are mutually recursive functions in MIT/GNU Scheme optimized at all?
It must be so, since tail call optimization is in the language specification. And TCO is more than just tail recursion, as I understand it even if the decision what to call next is dynamic (let alone static, evident in code as it is in your case) it still must run in constant stack space when one tail call eventually leads back to entering the same function again. Tail call is tail call, whatever is called, and it must be optimized. I don't have an official quotation ready at the moment.
I'm starting out with Clojure and, despite having an understanding of recursion, am having trouble thinking of the "right" way to build a lazy-seq for the following function:
I want to build a list of all the frequencies starting from middle C. My first element would be 120 (the frequency of middle C). To get the second element, I'd multiply the first element, 120, by 1.059463 to get 127.13556. To the get the third I'd multiply the second element, 127.13556, by 1.059463, etc etc...
What's the best way to do this in Clojure?
You can use the iterate function for that.
(iterate #(* % 1.059463) 120)
If you are planning to expand this into something more complicated, then you would create a function that recursive calls itself inside a call to lazy-seq. (This is what iterate does internally.)
(defn increasing-frequencies
([] (increasing-frequencies 120))
([freq]
(cons freq (lazy-seq (increasing-frequencies (* freq 1.059463))))))
(nth (increasing-frequencies) 2) ;; => 134.69542180428002
If you start to use this in a tight loop, you may also want to generate a chunked lazy seq. This will pre-calculate the next few elements, instead of one by one.
(defn chunked-increasing-frequencies
([] (chunked-increasing-frequencies 120))
([freq]
(lazy-seq
(let [b (chunk-buffer 32)]
(loop [i freq c 0]
(if (< c 32)
(do
(chunk-append b i)
(recur (* i 1.059463) (inc c)))
(chunk-cons (chunk b) (chunked-increasing-frequencies i))))))))
Note: I would advise against doing this until you have measured a performance problem related to calculating individual elements.
(defn get-frequencies []
(iterate #(* 1.059463 %) 120))
See iterate
Or, if you want to use lazy-seq explicitly, you can do this:
(defn get-frequencies-hard []
(cons
120
(lazy-seq
(map #(* 1.059463 %) (get-frequencies-hard)))))
Which will cons 120 to a lazy seq of every value applied to the map function.
I am fairly new to lisp and this is one of the practice problems.
First of all, this problem is from simply scheme. I am not sure how to answer this.
The purpose of this question is to write the function, count-odd that takes a sentence as its input and count how many odd digits are contained in it as shown below:
(count-odd'(234 556 4 10 97))
6
or
(count-odd '(24680 42 88))
0
If possible, how would you be able to do it, using higher order functions, or recursion or both - whatever gets the job done.
I'll give you a few pointers, not a full solution:
First of all, I see 2 distinct ways of doing this, recursion or higher order functions + recursion. For this case, I think straight recursion is easier to grok.
So we'll want a function which takes in a list and does stuff, so
(define count-odd
(lambda (ls) SOMETHING))
So this is recursive, so we'd want to split the list
(define count-odd
(lambda (ls)
(let ((head (car ls)) (rest (cdr ls)))
SOMETHING)))
Now this has a problem, it's an error for an empty list (eg (count-odd '())), but I'll let you figure out how to fix that. Hint, check out scheme's case expression, it makes it easy to check and deal with an empty list
Now something is our recursion so for something something like:
(+ (if (is-odd head) 1 0) (Figure out how many odds are in rest))
That should give you something to start on. If you have any specific questions later, feel free to post more questions.
Please take first into consideration the other answer guide so that you try to do it by yourself. The following is a different way of solving it. Here is a tested full solution:
(define (count-odd num_list)
(if (null? num_list)
0
(+ (num_odds (car num_list)) (count-odd (cdr num_list)))))
(define (num_odds number)
(if (zero? number)
0
(+ (if (odd? number) 1 0) (num_odds (quotient number 10)))))
Both procedures are recursive.
count-odd keeps getting the first element of a list and passing it to num_odds until there is no element left in the list (that is the base case, a null list).
num_odds gets the amount of odd digits of a number. To do so, always asks if the number is odd in which case it will add 1, otherwise 0. Then the number is divided by 10 to remove the least significant digit (which determines if the number is odd or even) and is passed as argument to a new call. The process repeats until the number is zero (base case).
Try to solve the problem by hand using only recursion before jumping to a higher-order solution; for that, I'd suggest to take a look at the other answers. After you have done that, aim for a practical solution using the tools at your disposal - I would divide the problem in two parts.
First, how to split a positive integer in a list of its digits; this is a recursive procedure over the input number. There are several ways to do this - by first converting the number to a string, or by using arithmetic operations to extract the digits, to name a few. I'll use the later, with a tail-recursive implementation:
(define (split-digits n)
(let loop ((n n)
(acc '()))
(if (< n 10)
(cons n acc)
(loop (quotient n 10)
(cons (remainder n 10) acc)))))
With this, we can solve the problem in terms of higher-order functions, the structure of the solution mirrors the mental process used to solve the problem by hand:
First, we iterate over all the numbers in the input list (using map)
Split each number in the digits that compose it (using split-digits)
Count how many of those digits are odd, this gives a partial solution for just one number (using count)
Add all the partial solutions in the list returned by map (using apply)
This is how it looks:
(define (count-odd lst)
(apply +
(map (lambda (x)
(count odd? (split-digits x)))
lst)))
Don't be confused if some of the other solutions look strange. Simply Scheme uses non-standard definitions for first and butfirst. Here is a solution, that I hope follows Simply Scheme friendly.
Here is one strategy to solve the problem:
turn the number into a list of digits
transform into a list of zero and ones (zero=even, one=odd)
add the numbers in the list
Example: 123 -> '(1 2 3) -> '(1 0 1) -> 2
(define (digit? x)
(<= 0 x 9))
(define (number->digits x)
(if (digit? x)
(list x)
(cons (remainder x 10)
(number->digits (quotient x 10)))))
(define (digit->zero/one d)
(if (even? d) 0 1))
(define (digits->zero/ones ds)
(map digit->zero/one ds))
(define (add-numbers xs)
(if (null? xs)
0
(+ (first xs)
(add-numbers (butfirst xs)))))
(define (count-odds x)
(add-numbers
(digits->zero/ones
(number->digits x))))
The above is untested, so you might need to fix a few typos.
I think this is a good way, too.
(define (count-odd sequence)
(length (filter odd? sequence)))
(define (odd? num)
(= (remainder num 2) 1))
(count-odd '(234 556 4 10 97))
Hope this will help~
The (length sequence) will return the sequence's length,
(filter proc sequence) will return a sequence that contains all the elements satisfy the proc.
And you can define a function called (odd? num)
Hey i've been stuck on the following problem and cant seem to come up with the correct function.
Write a recursive function that, given a positive integer k, computes the product k:
(1-1/2)(1-1/3)(1-1/k)... as k decreases by one.
I cant seem to come up with the correct function i the program usually runs till it has no more memory left. Here is my method:
(define (fraction-product k)
(if (= k 0)
0
(* (- 1 (/ 1 (fraction-product (- k 1)))))))
thanks for any help in advance...
Do small cases by hand first.
Without trying to code it, hand-calculate what the answer should be for:
(fraction-product 1)
(fraction-product 2)
(fraction-product 3)
You should at least have three concrete examples in hand before you do these kinds of problems: not only does it help to clarify some confusion, but they can serve as sanity test cases when you get to actual code.
Is there a relationship between the answer you hand calculate between (fraction-product 1) and (fraction-product 2)? How about between (fraction-product 2) and (fraction-product 3)?
Do we have to worry about (fraction-product 0)? Check your problem statement.
Don't go straight to code when you see problems like this. Do small examples by hand first: compute what the answer should be. It will help kickstart your intuition on what the program is really trying to compute, and how to do it mechanically.
If you have time, see a book like How to Design Programs, which describes a systematic approach on designing these kinds of functions.
What are the arguments of the product? There is only one!
The product is therefore useless, since (* n) == (* n 1) == n.
This should tell you immediately that your algorithm doesn't do what you want.
A good strategy to find such bugs is to write all the parameters of function of separate lines…
Also, when k == 0, (fraction-product 0) returns 0.
Then (fraction-product 1) will compute (/ 1 (fraction-product 0)) == (/ 1 0) which is probably not what you want to do again…
Actually, it seems that you want to compute something completely different from a product of fractions… rather a recursive fraction (I forgot the name of such things).
Anyway, to do (1 - 1/2) * (1 - 1/3) * ... * (1 - 1/k) you could do something like
(define (f-p k)
(define (aux n) (- 1 (/ 1 n)))
(let loop ((i 2))
(if (> i k)
1 ;; base case: multiply by 1, i.e. "do nothing"
(* (aux i) (loop (+ i 1))))))
This can be optimised to use constant stack space, but it isn't the point, is it?
You got wrong the base case: it should state that if k is 1, then return 1 - when you're multiplying recursively you have to make sure that the recursion stops when the number 1 is reached, if you multiply by 0 the result will always be 0.
The recursive call is also mistaken, notice that you must multiply (- 1 (/ 1 k)) times the result of the recursion. Try something like this:
(define (fraction-product k)
(if (<= k 1)
1
(* (- 1 (/ 1 k))
(fraction-product (- k 1)))))
As suggested in #Axioplase's answer, the same procedure can be written in such a way that it uses constant stack space by using tail recursion - the recursive call is the last thing the procedure executes before returning and is thus in tail position:
(define (fraction-product k)
(let loop ((acc 1)
(k k))
(if (<= k 1)
acc
(loop (* acc (- 1 (/ 1 k))) (- k 1)))))
And just for fun, it's easy to realize that the same procedure can be written as simple as this:
(define (fraction-product k)
(/ 1 k))
i need to write a function which calculates how many elements on list with scheme language.
for example
(howMany 'a) returns 0
(howMany '(a b)) returns 1
(howMany '(a (b c))) returns 2
how can i do that? i did not want a working code, just only an idea for do that. so maybe you should consider to remove working codes. :) thank you
The fold answers will work. However, if this is homework, you may be trying to do this using only simple built-in functions. There are two possible answers.
Here's the naive way:
(define (howMany list)
(if (null? list)
0
(+ 1 (howMany (cdr list)))
)
)
(Your implementation of Scheme may have a function empty? instead of null?.)
However, this algorithm will take an amount of space linearly proportional to the number of elements in the list, because it will store (+ 1 ...) for each element of the list before doing any of the additions. Intuitively, you shouldn't need this. Here's a better algorithm that avoids that issue:
(define (howMany list)
(define (iter numSoFar restOfList)
(if (null? restOfList)
numSoFar
(iter (+ numSoFar 1) (cdr restOfList))
)
)
(iter 0 list)
)
(Bonus points: use Scheme's (let iter ...) syntax to write this more succinctly. I used this style because it's more clear if you only know a few Scheme primitives.)
This will most likely get down-voted for this phrase, but, I don't know scheme. I am, however, familiar with functional programming.
If there is no built-in for this, start by 'folding' the list with start value of 0 and add 1 on every additional fold.
It is simply counting the number of elements in the list.
(define howMany
(lambda (list)
(cond
[(not (list? list)) 0]
[(null? list) 0]
[else (+ 1 (howMany (cdr list)))])))