Scheme

Ich glaube ich habs jetzt:

Code:
(define transpose
  (lambda (l)
       (cond
         ((empty? l) '())
           (else
            (cond
              ((empty? (car l)) '())
           (else
              (cons (firsts l)(transpose (remove-firsts l)))))
             ) 
           )
    )
  )

Vielen Dank für deine Hilfe!
 
Ich glaube ich habs jetzt:

Code:
(define transpose
  (lambda (l)
       (cond
         ((empty? l) '())
           (else
            (cond
              ((empty? (car l)) '())
           (else
              (cons (firsts l)(transpose (remove-firsts l)))))
             ) 
           )
    )
  )
Ja, so herum ist es sogar besser, da nun folgendes relativ auffällig ist:

Im Grunde hast du - bis auf eine Kleinigkeit - 2 Mal die gleiche Funktion definiert. Einmal firsts und dann remove-firsts. Diese Funktionen haben im Grunde die gleiche Struktur. Und zwar wird in beiden auf jedem Element einer Liste eine Funktion ausgeführt und das Ergebnis ist eine Liste die aus den Ergebnissen gebildet wird.

Da kann man sich gleich eine allgemeine Funktion bauen:
Code:
(define (funktion-auf  func  liste)
  (cond ((empty? liste) liste)
       (else (cons (func (car liste)) (funktion-auf func (cdr liste))))))

;; Funktion firsts:

(define (firsts x)
  (funktion-auf ?   x))

;; Funktion remove-firsts:

(define (remove-firsts x) 
  (funktion-auf  ? x))
Kannst ja mal überlegen was in die Fragezeichen eingesetzt werden muss. :)

Gruß
 
Stimmt, die sind ja echt total gleich. Man bin ich blind :) Danke für den Hinweis.
Meine Fassung sieht jetzt so aus:

Code:
(define hilfs-func
  (lambda (func l)
    (cond
      ((empty? l) '())
      (else
       (cons (func(car l))(hilfs-func func(cdr l)))))))


(define (firsts l)
  (hilfs-func car l))

(define (remove-firsts l)
  (hilfs-func cdr l))


(firsts '((1 2 3)(4 5 6) (7 8 9)))
(remove-firsts '((1 2 3) (4 5 6)))
     

(define transpose
  (lambda (l)
       (cond
         ((empty? l) '())
           (else
            (cond
              ((empty? (car l)) '())
           (else
              (cons (firsts l)(transpose (remove-firsts l)))))
             ) 
           )
    )
  )
 
Ja, sieht gut aus. Aber natürlich gibt es bereits eine Funktion die eine Funktion auf jedes Element einer Liste anwendet und eine Liste der Resultate zurückgbit, sie heißt map. :)

Wie angesprochen gibt es noch eine sehr elegante Möglichkeit eine Liste von Listen zu transponieren in Scheme, aber dazu braucht man noch eine andere Funktion; und das führt jetzt womöglich zu weit...

Gruß
 
Hi.

Irgendwie muss ich es jetzt doch loswerden, außerdem wollte ich schon immer mal einen Spoiler verwenden :)
Code:
(define (transpose a-list)
  (apply map list a-list))
Gruß
 
Zurück