partition of number without using consecutive integers

Question

I am following the cs61a spring 2015 class.

One of the problem in the scheme project is:

Implement the list-partitions procedure, which lists all of the ways to partition a positive integer total without using consecutive integers. The contents of each partition must be listed in decreasing order. Hint: Define a helper procedure to construct partitions. The built-in append procedure creates a list containing all the elements of two argument lists. The cons-all procedure in questions.scm adds a first element to each list in a list of lists.

The number 5 has 4 partitions that do not contain consecutive integers:

5

4, 1

3, 1, 1

1, 1, 1, 1, 1

The following partitions of 5 are not included because of consecutive integers:

3, 2

2, 2, 1

2, 1, 1, 1

I found one solution but cannot understand it

;; List all ways to partition TOTAL without using consecutive numbers.
(define (apply-to-all proc items)
  (if (null? items)
      '() 
      (cons (proc (car items))
            (apply-to-all proc (cdr items)))))

(define (cons-all first rests)
  (apply-to-all (lambda (rest) (cons first rest)) rests))

(define (caar x) (car (car x)))
(define (cadr x) (car (cdr x)))
(define (cddr x) (cdr (cdr x)))
(define (cadar x) (car (cdr (car x))))
(define (cdar x) (cdr (car x)))

(define (partitions-r a b)
  (if (= a 0) nil
    (append (cons-all a (list-partitions b))
            (cons-f (partitions-r (- a 1) (+ b 1))
    ))
  ))

(define (cons-f lst)
  (cond 
        ((eq? lst nil) nil)
        ((eq? (cdar lst) nil) lst)

        ((< (caar lst) (cadar lst)) (cons-f (cdr lst)))
        ((= (caar lst) (+ 1 (cadar lst))) (cons-f (cdr lst)))
        (else (cons (car lst) (cons-f (cdr lst))))
))

(define (list-partitions total)
  (cond ((= total 1) '((1)) )
        ((= total 0) '(()) )
        (else (append nil (partitions-r total 0)))
))

; For these two tests, any permutation of the right answer will be accepted.
(list-partitions 5)
; expect ((5) (4 1) (3 1 1) (1 1 1 1 1))
(list-partitions 7)
; expect ((7) (6 1) (5 2) (5 1 1) (4 1 1 1) (3 3 1) (3 1 1 1 1) (1 1 1 1 1 1 1))

What does the function partitions-r and cons-f do? Thank you very much!

score 0 · Answer 1 · answered Aug 18 '17 at 15:51

Don't know Scheme, but recursive generation in pseudocode might look like:

function Partitions(N, LastValue, list):
if N = 0 
   print list
else
    for i from  Min(LastValue, N) downto  1
        if (i != LastValue - 1)    //reject consecutive number
            Partitions(N - i, i, list  + [i]);

partition of number without using consecutive integers

1 Answers1