読者です 読者をやめる 読者になる 読者になる

牌語備忘録 -pygo

あくまでもメモです。なるべくオフィシャルの情報を参照してください。

牌語備忘録 -pygo

2.2.3 Sequences as Conventional Interfaces の Sequence OperationsをPythonでやってみた

SICP Python

SICP2.2.3 Sequences as Conventional Interfaces(慣習的な作用する配列) の Sequence Operations(配列操作) あたりを Python でやってみた

scheme
;2.2.3  Sequences as Conventional Interfaces
;Sequence Operations
(define (filter predicate sequence)
  (cond ((null? sequence)
         ())
        ((predicate (car sequence))
         (cons (car sequence)
               (filter predicate (cdr sequence))))
        (else (filter predicate (cdr sequence)))))
(filter odd? (list 1 2 3 4 5));(1 3 5)

(define (accumulate op initial sequence)
  (if (null? sequence)
      initial
      (op (car sequence)
          (accumulate op initial (cdr sequence)))))
(accumulate + 0 (list 1 2 3 4 5));15
(accumulate * 1 (list 1 2 3 4 5));120
(accumulate cons () (list 1 2 3 4 5));(1 2 3 4 5)


(define (enumerate-interval low high)
  (if (> low high)
      ()
      (cons low (enumerate-interval (+ low 1) high))))
(enumerate-interval 2 7);(2 3 4 5 6 7)

To enumerate the leaves of a tree, we can use14

(define (enumerate-tree tree)
  (cond ((null? tree)
         ())
        ((not (pair? tree)) (list tree))
        (else (append (enumerate-tree (car tree))
                      (enumerate-tree (cdr tree))))))
(enumerate-tree (list 1 (list 2 (list 3 4)) 5));(1 2 3 4 5)

;; 1.1.4  Compound Procedures
(define (square x)(* x x))
;; 1.2.2  Tree Recursion
(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1)) 
                 (fib (- n 2))))))

(define (list-fib-squares n)
  (accumulate cons
              ()
              (map square
                   (map fib
                        (enumerate-interval 0 n)))))
(list-fib-squares 10);(0 1 1 4 9 25 64 169 441 1156 3025)

(define (product-of-squares-of-odd-elements sequence)
  (accumulate *
              1
              (map square
                   (filter odd? sequence))))
(product-of-squares-of-odd-elements (list 1 2 3 4 5));225
python
def filter(prodicate, sequence):
    if not sequence:
        return []
    if prodicate(sequence[0]):
        return [sequence[0]] + filter(prodicate, sequence[1:])
    return filter(prodicate, sequence[1:])
#odd? == lambda x:x%2
print filter(lambda x:x%2, [1,2,3,4,5]) #[1, 3, 5]

def accumulate(op, initial, sequence):
    if not sequence:
        return initial
    return op(sequence[0], accumulate(op, initial, sequence[1:]))
print accumulate(lambda x,y:x + y, 0, [1,2,3,4,5])#15
print accumulate(lambda x,y:x * y, 1, [1,2,3,4,5])#120
print accumulate(lambda x,y:[x] + y, [], [1,2,3,4,5])#[1, 2, 3, 4, 5]

def enumerate_interval(low, high):
    if low > high:
        return []
    return [low] + enumerate_interval(low + 1, high)
print enumerate_interval(2, 7)#[2, 3, 4, 5, 6, 7]
#
def enumerate_tree(tree):
    if not tree:
        return []
    if not isinstance(tree, list):
        return [tree]
    return enumerate_tree(tree[0]) + enumerate_tree(tree[1:])
print enumerate_tree([1,[2,[3,4]],5])#[1, 2, 3, 4, 5]

#1.1.4  Compound Procedures
def square(x):
    return x * x
#1.2.2  Tree Recursion
def fib(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    return fib(n - 1) + fib(n - 2)

def list_fib_squares(n):
    return accumulate(lambda x,y:[x] + y,
                      [],
                      map(square, map(fib, enumerate_interval(0,n))))
print list_fib_squares(10)#[0, 1, 1, 4, 9, 25, 64, 169, 441, 1156, 3025]

def product_of_squares_of_odd_elements(sequence):
    return accumulate(lambda x,y:x * y,
               1,
               map(square, filter(lambda x:x % 2, sequence)))
print product_of_squares_of_odd_elements([1,2,3,4,5])#225