Erstellen Sie k-Größe Permutationen, ohne weitere Funktionen zu definieren

Question

ist es möglich, Scheme-Funktion (eine Funktion - es wichtig) zu implementieren, die eine Liste und k erhalten, und die Permutationen in der Größe von k abrufen, zum Beispiel: (1 2 3) , k = 2 ergibt {(1,1), (1,2), (1,3), (2,1), (2,2), ...} (9 Optionen).

Answer 1

Es ist möglich, alles zu tun, ohne etwas zu definieren, solange Sie Lambda haben:

(define (fib n) 
    ;; bad internal definition 
    (define (helper n a b) 
    (if (zero? n) 
     a 
     (helper (- n 1) b (+ a b)))) 
    (helper n 0 1)) 

Mit Z combinator:

(define Z 
    (lambda (f) 
    ((lambda (g) 
     (f (lambda args (apply (g g) args)))) 
    (lambda (g) 
     (f (lambda args (apply (g g) args))))))) 

(define (fib n) 
    ((Z (lambda (helper) 
     (lambda (n a b) 
      (if (zero? n) 
       a 
       (helper (- n 1) b (+ a b)))))) 
    n 0 1)) 

Jetzt sind wir nie Z Aufruf so können wir den Wert ersetzen Z für Z in der Funktion und es wird das gleiche tun:

(define (fib n) 
    (((lambda (f) 
     ((lambda (g) 
     (f (lambda args (apply (g g) args)))) 
     (lambda (g) 
     (f (lambda args (apply (g g) args)))))) 
    (lambda (helper) 
     (lambda (n a b) 
     (if (zero? n) 
      a 
      (helper (- n 1) b (+ a b)))))) 
    n 0 1)) 

Dort gehen Sie, Sa ved von Alonzo Church.

Answer 2

Es ist nicht nur möglich, es ist einfach. Verwenden Sie einfach einen loop:

(define permute 
    (lambda (k lst) 
    (let loop ((result (map list lst)) 
       (i 1)) 
     (if (= i k) 
      result 
      (loop 
      ;; code to add each element of the original list 
      ;; to each element of the result list 
      (1+ i))))))