#lang racket

(define (stream-zip-with f . argstreams) ;; merge pe oricâte argumente, nu se poate copia în loc de funcția din lab5
  (if (stream-empty? (car argstreams))
      empty-stream
      ;; un flux cu (f first1 first2 ... firstn) si apel rec
      (stream-cons
       (begin
         (apply f (map stream-first argstreams)))
       (apply stream-zip-with f (map stream-rest argstreams)))))
(define naturals
  (let loop ((n 0))
    (stream-cons n (loop (add1 n)))))
(define (show s n)
  (stream->list (stream-take s n)))

; Recursivitate

;---stivă/coadă
; rotate fără take/drop
;(define (rotate-left-q L n)
;(define (rotate-left-s L n)
      
;(rotate-left-q (range 20) 4)
;(rotate-left-s (range 20) 4)


; Funcționale

;---produs cartezian
;(define (cartesian-product A B)
;(cartesian-product '(1 2 3) '(a b c d))

;---prelucrare paralelă
;(define (hamming-distance A B)
;(hamming-distance '(G A T T A C A) '(G C T A C G A))

;(define (multiply M V)
;(define M '((1 2 3) 
;            (4 5 6)))
;(define V '(1 0 2))
;(multiply M V)

;---prelucrare paralelă cu padding
;v. (make-list n val)
;(define (add-poly P1 P2)
;(add-poly '(1 0 2) '(0 1 1 1 2))
    
;---prelucrare alternantă
;cu map
;(define (odd-pos L)
;(odd-pos '(10 9 1 5 2 6 7 0))

;cu fold
;(define (alternate L f1 f2)
;(alternate '(1 2 3 4 5 6 7) add1 sub1)         

;---prelucrare selectivă
;(define (two-sums L)
;(two-sums '((1 2) 10 20 (3 4 5) 30 (6) (7) 40 50))
  
; Legări

;---ciclări imbricate
;pattern:
;(define (func L)
;  (let outer-loop ((L L) (res '()))
;    (if (null? L)
;        (reverse res)
;        (let inner-loop (..sublist.. ..current-state..))
;          ... 
;          (outer-loop ..sublist.. (f new-val res))))))

;(define (encode L)
;(encode '(a a a b c c a a d))

; Fluxuri

;---iterate: x, f(x), f(f(x)) ...
;'(1) '(1 2 1) '(1 2 3 2 1) '(1 2 3 4 3 2 1) ...
;(define hills

;implicit
;(define hills-i
;(show hills-i 5)

;'(1) '(1 1) '(1 2 1) '(1 3 3 1) ...
;(define pascal-triangle
;(show pascal-triangle 10)

;'(1) '(1 1) '(1 1) '(1 1 1) '(1 1 1) '(1 1 1 1) '(1 1 1 1) ...
;(define one-lists
;(show one-lists 10)

;(define (dec-odd-positions L)
;(show (dec-odd-positions '(1 1 1 1 1)) 5)               

;---combinarea fluxului însuși cu alt flux
;(define (partial-unions s)
;(define naturals-lists
;  (stream-map list naturals))
;(show (partial-unions naturals-lists) 10)