Question

Please, help me with one simple exercise on the Scheme.

Write function, that return count of atoms on the each level in the
list. For example:

(a (b (c (d e (f) k 1 5) e))) –> ((1 1) (2 1) (3 2) (4 5) (5 1))

My Solution:

(define (atom? x)
  (and (not (pair? x)) (not (null? x))))
(define (count L)
  (cond ((null? L) 0)
        ((pair? (car L))
         (count (cdr L)))
        (else
         (+ 1 (count (cdr L))))))
(define (fun L level)
  (cons 
   (list level (count L))
   (ololo L level)))
(define (ololo L level)
  (if (null? L)
      '()
      (if (atom? (car L))
          (ololo (cdr L) level)            
          (fun (car L) (+ level 1)))))
(fun '(a (b (c (d e (f) k 1 5) e))) 1)

It’s work fine, but give not correctly answer for this list:

(a (b (c (d e (f) (k) 1 5) e)))

is:

((1 1) (2 1) (3 2) (4 4) (5 1))

But we assume that ‘f’ and ‘k’ on the one level, and answer must be:

((1 1) (2 1) (3 2) (4 4) (5 2))

How should I edit the code to make it work right?

---

UPD (29.10.12):
My final solution:

(define A '(a (b (c (d e (f) k 1 5) e))))

(define (atom? x)
  (and (not (pair? x)) (not (null? x))))

(define (unite L res)
  (if (null? L) (reverse res)
      (unite (cdr L) (cons (car L) res))))

(define (count-atoms L answ)
  (cond ((null? L) answ)
        ((pair? (car L))
         (count-atoms (cdr L) answ))
        (else
         (count-atoms (cdr L) (+ answ 1)))))

(define (del-atoms L answ)   
  (cond ((null? L) answ)
        ((list? (car L))
         (begin
         (del-atoms (cdr L) (unite (car L) answ))))
        (else
         (del-atoms (cdr L) answ))))

(define (count L)
(define (countme L level answ)
  (if (null? L)  (reverse answ)
      (countme (del-atoms L '()) (+ level 1) (cons (cons level (cons (count-atoms L 0) '())) answ))))
  (countme L 1 '()))

(count A)

What can you say about this?

Answer 1

Do you know what you get if you run this?

(fun '(a (b (c (d e (f) k 1 5) e)) (a (b (c)))) 1)

You get this:

((1 1) (2 1) (3 2) (4 5) (5 1))

The whole extra nested structure that I added on the right has been ignored. Here is why…

Each recursion of your function does two things:

1. Count all the atoms at the current “level”
2. Move down the level till you find an s-expression that is a pair (well, not an atom)

Once it finds a nested pair, it calls itself on that. And so on

What happens in oLoLo when fun returns from the first nested pair? Why, it returns! It does not keep going down the list to find another.

Your function will never find more than the first list at any level. And if it did, what would you to do add the count from the first list at that level to the second? You need to think carefully about how you recur completely through a list containing multiple nested lists and about how you could preserve information at each level. There’s more than one way to do it, but you haven’t hit on any of them yet.