## Archivi Categorie: SICP

### SICP – e ora? Continuo da qui.

Da un po’ di tempo mi trovo meno coinvolto con (l’ottimo) SICP. Anche gli esercizi, ultimamente mi sono limitato a seguire Bill the Lizard e altri schemers più bravi di me: SICP-Solutions e Drewiki.

Ecco Bill non è andato oltre con gli esercizi e a breve abbandonerà anche Drewiki. Resta sicp-ex, sempre ottimo. Poi ci sarebbero anche altri, io ho trovato questi:

AbdulFattaah Popoola, SICPBook – Solutions to SICP book exercises. Per quel che ho visto mette solo il codice senza commenti.

Phoenine, collins562, SICP-solutions. Anche qui solo codice, niente commenti.

Ivan Jovanovic, sicp. Anche qui solo il codice, mi sembra OK.

Poi c’è Gwern che devo ancora esaminare, per via di Haskell. Ha abbandonato SICP, passando ad altro. Ma ne riparlerò.

Quindi –almeno per il momento– non continuerò con SICP. Anche se è ottimo, ma va affrontato da giovane, quando si comincia. Non abbandono Scheme, cioè Racket, mi piace parecchio, anzi di più.

E poi chissà… 🤩

### SICP – cap. 2 – sets e recupero informazioni – 88 – esercizio Continuo da qui, copio qui.

Exercise 2.66: Implement the `lookup` procedure for the case where the set of records is structured as a binary tree, ordered by the numerical values of the keys.

Io quando ci sono gli esercizi chiamo Bill the Lizard 😋

The final part of [the] section asks us to consider a database that contains records, each of which has a `key` and some `data`. If the database is represented as an unordered list, a record can be looked up by its key using the following procedure.

``````(define (lookup given-key set-of-records)
(cond ((null? set-of-records) false)
((equal? given-key (key (car set-of-records)))
(car set-of-records))
(else (lookup given-key (cdr set-of-records)))))``````

We can define simple procedures for making a record out of a `key` and its `data`, and for extracting the `key` and `data` from an existing record in order to test the procedure above.

``````(define (key record) (car record))
(define (data record) (cdr record))
(define (make-record key data) (cons key data))

(define database
(list (make-record 1 'Bill)
(make-record 2 'Joe)
(make-record 3 'Frank)
(make-record 4 'John)))``````

We can start by including the `list->tree` and `partial-tree` procedures given for exercise 2.64 [qui], along with a few required supporting procedures.

``````(define (entry tree) (car tree))
(define (make-tree entry left right)
(list entry left right))

(define (list->tree elements)
(car (partial-tree elements (length elements))))

(define (partial-tree elts n)
(if (= n 0)
(cons '() elts)
(let ((left-size (quotient (- n 1) 2)))
(let ((left-result (partial-tree elts left-size)))
(let ((left-tree (car left-result))
(non-left-elts (cdr left-result))
(right-size (- n (+ left-size 1))))
(let ((this-entry (car non-left-elts))
(right-result (partial-tree (cdr non-left-elts)
right-size)))
(let ((right-tree (car right-result))
(remaining-elts (cdr right-result)))
(cons (make-tree this-entry left-tree right-tree)
remaining-elts))))))))``````

Raccolgo tutto il codice in `es-2.66.rkt`.

This makes it easier to convert the existing database to one structured as a binary tree. Finally, we can write the new implementation of `lookup` using `element-of-set?` as a guide.

``````(define (lookup given-key set-of-records)
(cond ((null? set-of-records) #f)
((= given-key (key (car set-of-records)))
(car set-of-records))
((< given-key (key (car set-of-records)))
(lookup given-key (left-branch set-of-records)))
((> given-key (key (car set-of-records)))
(lookup given-key (right-branch set-of-records)))))`````` sicp-ex propone, senza spiegazione, lo stesso codice di Bill.
Più articolata la versione di Drewiki.

Seguendo Bill, oltre che miei nuovi interessi, devo rivedere il mio progetto relativo a SICP 😯

🤩

### SICP – cap. 2 – sets e recupero informazioni – 87 Continuo da qui, copio qui.

We have examined options for using lists to represent sets and have seen how the choice of representation for a data object can have a large impact on the performance of the programs that use the data. Another reason for concentrating on sets is that the techniques discussed here appear again and again in applications involving information retrieval.

Consider a data base containing a large number of individual records, such as the personnel files for a company or the transactions in an accounting system. A typical data-management system spends a large amount of time accessing or modifying the data in the records and therefore requires an efficient method for accessing records. This is done by identifying a part of each record to serve as an identifying key. A key can be anything that uniquely identifies the record. For a personnel file, it might be an employee’s ID number. For an accounting system, it might be a transaction number. Whatever the key is, when we define the record as a data structure we should include a key selector procedure that retrieves the key associated with a given record.

Now we represent the data base as a set of records. To locate the record with a given key we use a procedure `lookup`, which takes as arguments a key and a data base and which returns the record that has that key, or false if there is no such record. `lookup` is implemented in almost the same way as `element-of-set?` [post precdenti]. For example, if the set of records is implemented as an unordered list, we could use

``````(define (lookup given-key set-of-records)
(cond ((null? set-of-records) false)
((equal? given-key
(key (car set-of-records)))
(car set-of-records))
(else
(lookup given-key
(cdr set-of-records)))))``````

Of course, there are better ways to represent large sets than as unordered lists. Information-retrieval systems in which records have to be “randomly accessed” are typically implemented by a tree-based method, such as the binary-tree representation discussed previously. In designing such a system the methodology of data abstraction can be a great help. The designer can create an initial implementation using a simple, straightforward representation such as unordered lists. This will be unsuitable for the eventual system, but it can be useful in providing a “quick and dirty” data base with which to test the rest of the system. Later on, the data representation can be modified to be more sophisticated. If the data base is accessed in terms of abstract selectors and constructors, this change in representation will not require any changes to the rest of the system.

🤢

### SICP – cap. 2 – sets come alberi binari – 86 Continuo da qui, copio qui.

Exercise 2.65: Use the results of Exercise 2.63 [qui] and Exercise 2.64 [qui] to give `Θ(n)` implementations of `union-set` and `intersection-set` for sets implemented as (balanced) binary trees.

Passo –al solito– la parola a Bill the Lizard 💥

We implemented `union-set` for the unordered list representation of sets back in exercise 2.59 [qui]. This implementation had to check all elements of one set for each element of the other, so it’s complexity was `O(n2)`, quite poor. We improved on this in exercise 2.62 [qui] when we wrote an implementation of `union-set` for the ordered list representation of sets, which was `O(n)`. The text supplied a similar implementation of `intersection-set` that was also `O(n)`. We could use these ordered set implementations as a guide to writing efficient implementations of `union-set` and `intersection-set` for balanced binary trees, but that wouldn’t require the results of the previous two exercises. Instead, we can use the `O(n)` implementations of all of the procedures we’ve built so far to perform the following steps:

• Convert the balanced binary trees to ordered lists.
• Perform the desired operation (`union-set` or `intersection-set`).
• Convert the resulting ordered set back to a balanced binary tree.
``````(define (union-set tree1 tree2)
(define (union-list set1 set2)
(cond ((null? set1) set2)
((null? set2) set1)
((= (car set1) (car set2))
(cons (car set1) (union-list (cdr set1) (cdr set2))))
((< (car set1) (car set2))
(cons (car set1) (union-list (cdr set1) set2)))
(else (cons (car set2) (union-list set1 (cdr set2))))))
(list->tree (union-list (tree->list-2 tree1)
(tree->list-2 tree2))))

(define (intersection-set tree1 tree2)
(define (intersection-list set1 set2)
(if (or (null? set1) (null? set2))
'()
(let ((x1 (car set1)) (x2 (car set2)))
(cond ((= x1 x2)
(cons x1
(intersection-list (cdr set1)
(cdr set2))))
((< x1 x2)
(intersection-list (cdr set1) set2))
((< x2 x1)
(intersection-list set1 (cdr set2)))))))
(list->tree (intersection-list (tree->list-2 tree1)
(tree->list-2 tree2))))``````

In the implementations above, I’ve just defined the earlier ordered set implementations of `union-set` and `intersection-set` as helper functions named `union-list` and `intersection-list`. With these helper functions, all `union-set` and `intersection-set` need to do is convert from tree to list and back from list to tree. We can define a few balanced trees to test that these new implementations work as expected.

Raccolgo il codice nel file `ex-2-65.rkt`. Servono anche `list->tree`, `partial-tree`, `make-tree`, `tree->list-1` e `tree->list-2`. OK anche sicp-ex e Drewiki.

🤢

### SICP – cap. 2 – sets come alberi binari – 85 – esercizio Continuo da qui, copio qui.

Exercise 2.64: The following procedure `list->tree` converts an ordered list to a balanced binary tree. The helper procedure `partial-tree` takes as arguments an integer `n` and list of at least `n` elements and constructs `a` balanced tree containing the first `n` elements of the list. The result returned by `partial-tree` is a `pair` (formed with `cons`) whose `car` is the constructed tree and whose `cdr` is the list of elements not included in the tree.

``````(define (list->tree elements)
(car (partial-tree
elements (length elements))))

(define (partial-tree elts n)
(if (= n 0)
(cons '() elts)
(let ((left-size
(quotient (- n 1) 2)))
(let ((left-result
(partial-tree
elts left-size)))
(let ((left-tree
(car left-result))
(non-left-elts
(cdr left-result))
(right-size
(- n (+ left-size 1))))
(let ((this-entry
(car non-left-elts))
(right-result
(partial-tree
(cdr non-left-elts)
right-size)))
(let ((right-tree
(car right-result))
(remaining-elts
(cdr right-result)))
(cons (make-tree this-entry
left-tree
right-tree)
remaining-elts))))))))``````

Write a short paragraph explaining as clearly as you can how `partial-tree` works. Draw the tree produced by `list->tree` for the list `(1 3 5 7 9 11)`.

What is the order of growth in the number of steps required by `list->tree` to convert a list of `n` elements?

Qua non ci provo; chiamo Bill the Lizard 💥

The `partial-tree` procedure works by dividing the list into three parts, a center element (the root node of the tree), everything before the center element, and everything after the center element. All the elements before the center element are then passed to a recursive call to `partial-tree` to create the left branch of the tree, and all the elements after the center element are passed recursively to `partial-tree to` create the right branch. These recursive call continue until no elements are remaining, and the balanced binary tree is assembled.

The tree produced by `list->tree` for the list `(1 3 5 7 9 11)` is: To verify this, we can simply call the procedure. Next we’re asked what is the order of growth in the number of steps required by `list->tree` to convert a list of n elements? The procedure only needs to visit each element of the list once, and it only performs a `cons` for each element it visits, so the number of steps is proportional to the size of the list, or `O(n)`.

sicp-ex risponde in modo simile, più conciso.
Risultato simile per Drewiki.
Insomma sono solo io che devo applicarmi di più 😐

🤢

### SICP – cap. 2 – sets come alberi binari – 84 . esercizio Continuo da qui, copio qui.

Exercise 2.63: Each of the following two procedures converts a binary tree to a list.

``````(define (tree->list-1 tree)
(if (null? tree)
'()
(append
(tree->list-1
(left-branch tree))
(cons (entry tree)
(tree->list-1
(right-branch tree))))))

(define (tree->list-2 tree)
(define (copy-to-list tree result-list)
(if (null? tree)
result-list
(copy-to-list
(left-branch tree)
(cons (entry tree)
(copy-to-list
(right-branch tree)
result-list)))))
(copy-to-list tree '()))``````
• Do the two procedures produce the same result for every tree? If not, how do the results differ? What lists do the two procedures produce for the trees in Figure 2.16 [post precedente]?
• Do the two procedures have the same order of growth in the number of steps required to convert a balanced tree with n elements to a list? If not, which one grows more slowly?

Al solito passo la parola a Bill the Lizard.

The `tree->list-1` procedure checks to see if the tree passed in is `null`, and if so returns an empty list. If the tree is not `null`, it creates a list by appending the left branch of the tree, the element at the root node, and the right branch of the tree. Elements of the left and right branches are flattened into lists using recursive calls to `tree->list-1`. The `tree->list-2` procedure defines a helper function `copy-to-list` that takes the tree and a `result-list` as arguments. When the tree is `null`, it returns the `result-list` that was passed in. The `copy-to-list` helper function also uses recursive calls to the left and right branches of the tree while building the final result list. These two procedures will produce the same results for every tree.

We’re asked to test the two procedures on the trees in figure 2.16.

Inserisco il codice, completo di quello del post precedente, in `es-2.63.rkt`. We can see from these results that both procedures return an in-order traversal for every tree.

We’re also asked if the two procedures have the same order of growth for a balanced tree, and if not, which one grows more slowly?

We can see from the results above and from inspecting the two procedures that each node of the tree is visited one time by each algorithm. What happens at each of those `n` steps is subtly different though. The second procedure simply calls cons at each step, which we’ll assume is a constant-time operation, so the `tree->list-2` procedure has a time complexity of `O(n)`. The first procedure calls append at each step, which we saw in section 2.2.1 has the following definition:

``````(define (append list1 list2)
(if (null? list1)
list2
(cons (car list1) (append (cdr list1) list2))))``````

From this definition we can see that the order of growth of append is proportional to the first list argument that’s passed in. In the case of `tree->list-1`, the first list argument is the left branch of the tree, which is about half of a node’s elements for a balanced tree. This means that for each recursive call, approximately half of the number of nodes will be in the first list argument as in the previous call. Since the number of elements is cut in half on each of the `n` calls to append, the `tree->list-1` procedure has a complexity of `O(nlog n)` for a balanced tree.

Già detto che 👽 Bill 💥 rockz?

Simile ma meno didascalica la soluzione di sicp-ex.
Descrittiva quella di Drewiki.

🤢

### SICP – cap. 2 – sets come alberi binari – 83 Continuo da qui, copio qui.

We can do better than the ordered-list representation by arranging the set elements in the form of a tree. Each node of the tree holds one element of the set, called the “entry” at that node, and a link to each of two other (possibly empty) nodes. The “left” link points to elements smaller than the one at the node, and the “right” link to elements greater than the one at the node. Figure 2.16 shows some trees that represent the set `{1, 3, 5, 7, 9, 11}`. The same set may be represented by a tree in a number of different ways. The only thing we require for a valid representation is that all elements in the left subtree be smaller than the node entry and that all elements in the right subtree be larger. Figure 2.16: Various binary trees that represent the set `{1, 3, 5, 7, 9, 11}`.

The advantage of the tree representation is this: Suppose we want to check whether a number `x` is contained in a set. We begin by comparing `x` with the entry in the top node. If `x` is less than this, we know that we need only search the left subtree; if `x` is greater, we need only search the right subtree. Now, if the tree is “balanced,” each of these subtrees will be about half the size of the original. Thus, in one step we have reduced the problem of searching a tree of size `n` to searching a tree of size `n/2` . Since the size of the tree is halved at each step, we should expect that the number of steps needed to search a tree of size n grows as `Θ(log ⁡n)`. (Halving the size of the problem at each step is the distinguishing characteristic of logarithmic growth, as we saw previously.) For large sets, this will be a significant speedup over the previous representations.

We can represent trees by using lists. Each node will be a list of three items: the entry at the node, the left subtree, and the right subtree. A left or a right subtree of the empty list will indicate that there is no subtree connected there. We can describe this representation by the following procedures:

Note: We are representing sets in terms of trees, and trees in terms of lists—in effect, a data abstraction built upon a data abstraction. We can regard the procedures `entry`, `left-branch`, `right-branch`, and `make-tree` as a way of isolating the abstraction of a “binary tree” from the particular way we might wish to represent such a tree in terms of list structure.

``````(define (entry tree) (car tree))
(define (make-tree entry left right)
(list entry left right))``````

Now we can write the `element-of-set?` procedure using the strategy described above:

``````(define (element-of-set? x set)
(cond ((null? set) false)
((= x (entry set)) true)
((< x (entry set))
(element-of-set?
x
(left-branch set)))
((> x (entry set))
(element-of-set?
x
(right-branch set)))))``````

Adjoining an item to a set is implemented similarly and also requires `Θ(log⁡ n)` steps. To adjoin an item `x`, we compare `x` with the node entry to determine whether `x` should be added to the right or to the left branch, and having adjoined `x` to the appropriate branch we piece this newly constructed branch together with the original entry and the other branch. If `x` is equal to the entry, we just return the node. If we are asked to adjoin `x` to an empty tree, we generate a tree that has `x` as the entry and empty right and left branches. Here is the procedure:

``````(define (adjoin-set x set)
(cond ((null? set) (make-tree x '() '()))
((= x (entry set)) set)
((< x (entry set))
(make-tree
(entry set)
(right-branch set)))
((> x (entry set))
(make-tree
(entry set)
(left-branch set)

The above claim that searching the tree can be performed in a logarithmic number of steps rests on the assumption that the tree is “balanced,” i.e., that the left and the right subtree of every tree have approximately the same number of elements, so that each subtree contains about half the elements of its parent. But how can we be certain that the trees we construct will be balanced? Even if we start with a balanced tree, adding elements with adjoin-set may produce an unbalanced result. Since the position of a newly adjoined element depends on how the element compares with the items already in the set, we can expect that if we add elements “randomly” the tree will tend to be balanced on the average. But this is not a guarantee. For example, if we start with an empty set and adjoin the numbers 1 through 7 in sequence we end up with the highly unbalanced tree shown in Figure 2.17. In this tree all the left subtrees are empty, so it has no advantage over a simple ordered list. One way to solve this problem is to define an operation that transforms an arbitrary tree into a balanced tree with the same elements. Then we can perform this transformation after every few `adjoin-set` operations to keep our set in balance. There are also other ways to solve this problem, most of which involve designing new data structures for which searching and insertion both can be done in `Θ(log n)` steps. ( Examples of such structures include B-trees and red-black trees. There is a large literature on data structures devoted to this problem. See Cormen et al. 1990.) Figure 2.17: Unbalanced tree produced by adjoining 1 through 7 in sequence.

🤢

### SICP – cap. 2 – Esempio: sets come liste ordinate – 82 – esercizio Continuo da qui, copio qui.

Exercise 2.62: Give a `Θ(n)` implementation of `union-set` for sets represented as ordered lists.

Uh! Aiuto 💥 Bill the Lizard 👽

Since the two sets are in order, we can simply step through each set comparing the first elements of each. At each step we decide which of the first two elements to place in the resulting set.

``````(define (union-set set1 set2)
(cond ((null? set1) set2)
((null? set2) set1)
((= (car set1) (car set2))
(cons (car set1) (union-set (cdr set1) (cdr set2))))
((< (car set1) (car set2))
(cons (car set1) (union-set (cdr set1) set2)))
(else (cons (car set2) (union-set set1 (cdr set2))))))``````

Anyone familiar with the mergesort algorithm will quickly recognize that this implementation of `union-set` is almost exactly the same procedure as the merge subroutine. It’s purpose is to quickly merge two sorted lists into one. The only difference is that the `union-set` implementation above only keeps one copy of duplicate elements. sicp-ex ha diverse soluzioni, Drewiki una sola ma OK 😊

🤢

### SICP – cap. 2 – Esempio: sets come liste ordinate – 81 – esercizio Continuo da qui, copio qui.

Exercise 2.61: Give an implementation of `adjoin-set` using the ordered representation. By analogy with `element-of-set?` show how to take advantage of the ordering to produce a procedure that requires on the average about half as many steps as with the unordered representation.

Al solito io chiamo Bill the Lizard 👽

The original implementation of `adjoin-set` made use of `element-of-set?` to check and see if the new element was already a member of the set. We no longer need to do this since we need to find the exact position in the set to insert the new element. As we scan through the set looking for the right position, we can simply return the set if we encounter the element we’re trying to place.

``````(define (adjoin-set x set)
(cond ((null? set) (cons x '()))
((= x (car set)) set)
((< x (car set)) (cons x set))
((> x (car set)) (cons (car set)

There are several different conditions, and we need to cover them all. First, since we’re no longer using `element-of-set`, we need to check to see if the set itself is null or empty. Second, if the we encounter the element we’re trying to add, we can just return the set. Next, if the element we’re adding is smaller than the first element of the set, we can simply `cons` the new element to the beginning of the set. Last, if the new element is greater than the first element of the set, we join the first element followed by the `adjoin-set` of the new element and the rest of the set. Like `element-of-set?`, this implementation should only scan through half the set on average before finding the correct insertion point for the new element.

Belle anche le soluzioni di sicp-ex e Drewiki 😊

🤢

### SICP – cap. 2 – Esempio: sets come liste ordinate – 80 Continuo da qui, copio qui.

One way to speed up our set operations is to change the representation so that the set elements are listed in increasing order. To do this, we need some way to compare two objects so that we can say which is bigger. For example, we could compare symbols lexicographically, or we could agree on some method for assigning a unique number to an object and then compare the elements by comparing the corresponding numbers. To keep our discussion simple, we will consider only the case where the set elements are numbers, so that we can compare elements using `>` and `<`. We will represent a set of numbers by listing its elements in increasing order. Whereas our first representation above allowed us to represent the set `{1, 3, 6, 10}` by listing the elements in any order, our new representation allows only the list `(1 3 6 10)`.

One advantage of ordering shows up in `element-of-set?`: In checking for the presence of an item, we no longer have to scan the entire set. If we reach a set element that is larger than the item we are looking for, then we know that the item is not in the set:

``````(define (element-of-set? x set)
(cond ((null? set) false)
((= x (car set)) true)
((< x (car set)) false)
(else (element-of-set? x (cdr set)))))``````

How many steps does this save? In the worst case, the item we are looking for may be the largest one in the set, so the number of steps is the same as for the unordered representation. On the other hand, if we search for items of many different sizes we can expect that sometimes we will be able to stop searching at a point near the beginning of the list and that other times we will still need to examine most of the list. On the average we should expect to have to examine about half of the items in the set. Thus, the average number of steps required will be about `n / 2`. This is still `Θ(n)` growth, but it does save us, on the average, a factor of 2 in number of steps over the previous implementation.

We obtain a more impressive speedup with `intersection-set`. In the unordered representation this operation required `Θ(n2)` steps, because we performed a complete scan of `set2` for each element of `set1`. But with the ordered representation, we can use a more clever method. Begin by comparing the initial elements, `x1` and `x2`, of the two sets. If `x1` equals `x2`, then that gives an element of the intersection, and the rest of the intersection is the intersection of the `cdr`s of the two sets. Suppose, however, that `x1` is less than `x2`. Since `x2` is the smallest element in `set2`, we can immediately conclude that `x1` cannot appear anywhere in `set2` and hence is not in the intersection. Hence, the intersection is equal to the intersection of `set2` with the `cdr` of `set1`. Similarly, if `x2` is less than `x1`, then the intersection is given by the intersection of `set1` with the `cdr` of `set2`. Here is the procedure:

``````(define (intersection-set set1 set2)
(if (or (null? set1) (null? set2))
'()
(let ((x1 (car set1)) (x2 (car set2)))
(cond ((= x1 x2)
(cons x1 (intersection-set
(cdr set1)
(cdr set2))))
((< x1 x2) (intersection-set
(cdr set1)
set2))
((< x2 x1) (intersection-set
set1
(cdr set2)))))))``````

To estimate the number of steps required by this process, observe that at each step we reduce the intersection problem to computing intersections of smaller sets—removing the first element from `set1` or `set2` or both. Thus, the number of steps required is at most the sum of the sizes of `set1` and `set2`, rather than the product of the sizes as with the unordered representation. This is `Θ(n)` growth rather than `Θ(n2)` —a considerable speedup, even for sets of moderate size.

🤢