#lang racket

;;;;**********************************************************************
;;; CS251 Spring 2017 PS6
;;; Your name:
;;;;**********************************************************************

;;;----------------------------------------------------------------------
;;; Solo Problem 1: It's A Factor

;;;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
;; You are given these three functions

(define (least-divisor-rec num) ;; Assume num is a postive integer
  (let ((limit (ceiling (sqrt num)))) ;; The largest divisor to be tested
    (define (search-for-divisor candidate)
      (if (> candidate limit)
          num
          (if (divisible-by? num candidate)
              candidate
              (search-for-divisor (+ candidate 2))))) 
    (if (divisible-by? num 2)
        2
        (search-for-divisor 3)))) 

(define (divisible-by? num divisor)
  (= (remainder num divisor) 0))

(define (factors-rec num)
  (let ((factor (least-divisor-rec num)))
    (if (= factor num)
        (list factor)
        (cons factor (factors-rec (quotient num factor))))))
;;;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

;; Flesh this out for Problem 1a
(define (hamming? num)
  (and (integer? num)
       (> num 0)
       (or (= num 1)
           (forall? 'expression1
                    'expression2
                    ))
       ))

;; Flesh this out for Problem 1b
(define (least-divisor-find num)
  (find 'expression1
        'expression2
        'expression3
        ))

;; Flesh this out for Problem 1c
(define (factors-genlist num)
  (map second
       (genlist 'expression1
                'expression2
                'expression3
                (list num 
                      'expression4
                      ))))

;; Flesh this out for Problem 1d
(define (factors-iterate-apply num)
  (iterate-apply 'expression1  
                 'expression2  
                 'expression3   
                 (list num null)))


;;;----------------------------------------------------------------------
;;; Solo Problem 2: Partial Reverses

;;;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
;; You are given these two functions
(define (partial-reverses xs)
  (partial-reverses-tail xs '() '()))

(define (partial-reverses-tail ys rev list-rev)
  (if (null? ys)
      (cons rev list-rev)
      (partial-reverses-tail (rest ys)
                             (cons (first ys) rev)
                             (cons rev list-rev)
                             )))
;;;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

;; Flesh this out for Problem 2a
(define (partial-reverses-iterate xs)
  (iterate-apply 'expression1 
                 'expression2
                 'expression3
                 'expression4
                 ))

;; Flesh this out for Problem 2b
(define (partial-reverses-foldl xs)
  (foldl 'expression1 
         'expression2 
         xs))

;;;----------------------------------------------------------------------
;;; Solo Problem 3: Diagonal Pairs

;; You are given the following function.
;; In Problem 3a, explain what it returns
(define (diagonal-pairs n)
  (foldr append null
         (map (λ (sum)
                (map (λ (fst) (cons fst (- sum fst)))
                     (range 0 (+ sum 1))))
              (range 0 (+ n 1)))))

;; Flesh out the following skeleton for Problem 3b
(define (diagonal-pairs-genlist n)
  (genlist 'next-function
           'done-function
           'keep-done-value
           'seed))

;; Flesh out the following skeleton for Problem 3c
(define (diagonal-pairs-iter n)
  (define (outer-tail ...outer-params...)
    (define (inner-tail ...inter-params...)
      ...inner-body...)
    ...outer-body...)
  (outer-tail ...args...))

;;;----------------------------------------------------------------------
;;; Helper Functions from PS4, PS5, and lectures

(define (iterate-apply next done? finalize state)
  (if (apply done? state)
      (apply finalize state)
      (iterate-apply next done? finalize (apply next state))))

(define (genlist next done? keepDoneValue? seed)
  (if (done? seed)
      (if keepDoneValue? (list seed) null)
      (cons seed
            (genlist next done? keepDoneValue? (next seed)))))

(define (forall? pred xs)
  (if (null? xs)
      #t
      (and (pred (car xs))
           (forall? pred (cdr xs)))))

(define (find pred not-found xs)
  (if (null? xs)
      not-found
      (if (pred (car xs))
          (car xs)
          (find pred not-found (cdr xs)))))