Problème de devoirs de système, besoin d'aide

Question

Ok, un de mes problèmes de devoirs est de prendre une liste de listes et de renvoyer la voiture de chaque sous-liste comme une liste. Je l'ai à l'endroit où je peux imprimer les valeurs, mais ce n'est pas une liste. Pour être honnête, je n'ai aucune idée de la façon de produire des listes. Voici ce que j'ai obtenu:

(define (car-print alist) 
    (if (null? alist) 
     (newline) 
     (begin 
     (write (car (car alist))) (display " ") 
    (car-print(cdr alist))))) 

Ceci est un moyen peu coûteux de le faire, peut-être un peu d'aide sur la résolution de ce problème serait très appréciée. Pas nécessairement la réponse complète, mais les étapes pour y arriver. Merci.

Answer 1

Mon régime est un peu rouillé. Et j'ai juste un interprète dr-scheme à portée de main ...

Vous devez consommer votre liste et retourner seulement le premier élément de chaque sous-liste.

Pour créer une liste vous devez utiliser la directive contre, et vous n'avez pas besoin de le sortir, vous devez le retourner comme résultat de la fonction (mais vous devriez déjà le savoir).

Si vous devez imprimer le résultat, vous devez séparer le calcul de la sortie et résoudre les problèmes d'impression dans une seconde étape.

Pour la construction d'une liste que vous avez plusieurs construction, le plus fondamental est par contre, il faut un élément générique (également une liste) et faites-le précéder à une liste (celle null, aussi)

(cons 1) => error: cons need two parameters 
(cons 1 null) => (list 1) 
(cons 1 2) => error: need a value (first parameter) and a list (the second one) 
(cons 1 (cons 2 null) => (list 1 2) 

Maintenant à tes devoirs. En général, je ne posterai pas de code devoirs mais, cette fois, je pense que vous êtes juste un soupçon loin de la solution, donc il est un possible un

(define (car-list alist) 
    (cond 
    ((null? alist) null) 
    (else (cons (car(car alist)) (car-list (cdr alist)))) 
) 
) 
; tail recursion version usage: (car-acc-list alist null) 
(define (car-acc-list alist acc) 
    (cond 
    ((null? alist) acc) 
    (else (car-acc-list (cdr alist) (cons (car(car alist)) acc))) 
) 
) 

je cond, au lieu de si la cause » Je pense que cela permet un meilleur formatage de votre code. Sa structure est simple: une liste de clauses, avec la condition de test (ou sinon) comme voiture et action à effectuer si la condition est satisfaite en tant que cdr. Si l'action résout à une valeur ((null? Alist) null) la fonction renvoie avec cette valeur comme valeur de retour. Si la récursivité est déclenchée, la fonction revient à la fin de la récursivité.

Il existe deux versions de la solution, vous devez utiliser le programme pas à pas/débogueur pour étudier leurs différences. Par ailleurs, j'ai utilisé drscheme pour tester le code, c'est un merveilleux logiciel gratuit (lgpl). Les différences mineures sont avec d'autres environnements de schéma mais le code devrait être très basique et donc il devrait fonctionner sans problèmes partout.

Answer 2

Pour concevoir une fonction, vous devez savoir ce que sont vos outils. Pour les listes, vous avez:

cons : n l -> (n l) 
Construct a list out of an element and a list, placing the element n 
at the head of the list 

car : l -> n 
Return the head of the list 

cdr : l -> l 
Return the tail of the list 

Vous voulez écrire une fonction firstl qui consomme une liste de listes et retourne une liste. Quelques exemples sont:

(firstl (list (list 1 2 3) (list 9 2 3) (list 4 7 3))) -> (1 9 4) 
(firstl (list (list 1 2 3))) -> (1) 
(firstl '()) ->() 

Le dernier exemple devrait vous donner votre premier indice: si l'argument est une liste vide, retourner une liste vide.

(define (firstl lol)  ; list-of-lists (no laughing!) 
    (if (null? lol) 
    '() 
    .... ; more stuff goes here for the recursive "else" clause. Hint: use cons 
)) 

Answer 3

Vous devez utiliser la fonction map:

> (define lst '((1 2 3) (4 5 6) (7 8 9))) 
;Value: lst 
> (map car lst) 
;Value: (1 4 7)