¿Hay alguna manera de devolver una matriz de recursividad?

Puede devolver la referencia a la matriz creada en la función. Pero hay una trampa. Las matrices normales creadas dentro de una función tienen un alcance solo dentro de la función. Entonces, si devuelve el puntero de matriz, la ubicación de la dirección podría no ser válida. ¿La solución? Cree la matriz dinámicamente y devuelva el puntero.

¡Si! De hecho, esto es extremadamente útil: en lenguajes que no tienen iteración, ¡así es como se implementan el mapa y el filtro!

(define (map proc lst)
(cond
[(¿vacío? lst) vacío]
[else (cons (proc (primer lst)) (map proc (rest lst)))]))

Usado:

> (mapa (lambda (n) (* n 2)) ‘(1 2 3 4 5 6))
«(2 4 6 8 10 12)
> (mapa ((curry *) 2) ‘(1 2 3 4 5 6))
«(2 4 6 8 10 12)

Para la lista vacía, devuelva una lista vacía; de lo contrario, devuelva una lista que es la función proporcionada por el usuario aplicada al primer elemento, más el resultado para el resto de la lista (llamada recursiva).

Y aquí está el filtro:

(definir (filtro pred lst)
(cond
[(¿vacío? lst) vacío]
[(pred (primer lst)) (contras (primer lst) (filtro pred (rest lst)))]
[else (filter pred (rest lst))]))

Usado:

> (filtro (lambda (n) (cero? (módulo n 2))) ‘(1 2 3 4 5 6))
«(2 4 6)
> (¿filtrar incluso? ‘(1 2 3 4 5 6))
«(2 4 6)
> (¿filtro impar? ‘(1 2 3 4 5 6))
«(1 3 5)

Si el predicado devuelve verdadero, agregue el elemento al encabezado del resultado para el resto de la lista; de lo contrario, no te molestes en agregarlo.

Tenga en cuenta que estos están trabajando con listas enlazadas individualmente, de modo que obtener el primer elemento ( first ), la cola ( rest ) o agregar al frente ( cons ) son operaciones de tiempo constante.

También tenga en cuenta que no son recursivos de cola: en realidad usarán stack, porque la última operación son las cons , no la llamada recursiva. Esto se puede solucionar agregando un argumento acumulador que mantiene la lista mientras se construye. El único problema es que el resultado se revertirá, y debe pasar una lista vacía inicial, pero ambos pueden solucionarse mediante una función de contenedor:

(define (map proc lst)
(definir (map-impl proc lst acum)
(cond
[(¿vacío? lst) acumulado]
[else (map-impl proc (rest lst) (cons (proc (first lst)) acum))]))
(inversa (map-impl proc lst empty)))