Scheme

[sanni7]

Ich glaube ich habs jetzt:

(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!

 

[deepthroat]

Ich glaube ich habs jetzt:

(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:

(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ß

 

[sanni7]

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

(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)))))
             ) 
           )
    )
  )

 

[deepthroat]

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ß

 

[sanni7]

Ein anderes Mal gerne für heute reicht es erst einmal

Gruß

 

[deepthroat]

Hi.

Irgendwie muss ich es jetzt doch loswerden, außerdem wollte ich schon immer mal einen Spoiler verwenden

Spoiler

(define (transpose a-list)
  (apply map list a-list))

Gruß