Hello,
I am trying to create the following recursive function:

Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)

(defun doubleodd (list)
(when list
(if (oddp (car list)) (setf (car list) (* (car list) 2)))
(doubleodd (cdr list))
)
)

When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?

(doubleodd '(1 2 3 4 5))

evaluates to:
26410
NIL

Thank you for your help.
Mark

On 2022-11-22, ME Jones <markjones@shawday.com> wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?

(defun doubleodd (l)
(if (null l)
nil
(if (oddp (car l))
(cons (* 2 (car l)) (doubleodd (cdr l)))
(cons (car l) (doubleodd (cdr l))))))

In a recursive function with a list, 2 important things to remember:

you apply the function on the car of the list then your recursive call
goes on the cdr.

Once the list is null, you return a nil to end the recursion.

Lisp is mostly a functional language, avoid the usage of (setf) inside
a function unless it's to change the value of a lexical
variable. Otherwise, you function is called destructive.

2 books to read absolutely to understand Lisp and its philosophy:

Ansi Common Lisp
On Lisp

Both from Paul Graham. The second one is not printed anymore, but
available at low cost from lulu.com

>
> (doubleodd '(1 2 3 4 5))
>
> evaluates to:
> 26410
> NIL
>
> Thank you for your help.
> Mark

ME Jones <markjones@shawday.com> writes:
> I am trying to create the following recursive function:
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)

I would first break this out into a function that conditionally doubles
a single number:

(defun double-odd-1 (n)
(cond ((oddp n) (+ n n))
(t n)))

and then a tail-recursive function that applies DOUBLE-ODD-1 to each
element of a list, consing it up into a new list that is in reverse
order. Then, at the end, reverse the new list "in place" using
nreverse:

(defun double-odd (xs &optional acc)
(defun f (n) (+ n n))
(cond ((null xs) (nreverse acc))
(t (double-odd (cdr xs) (cons (double-odd-1 (car xs)) acc)))))

Using an accumulation parameter allows the recursive call to be the
function's final value, which means the compiler can actually turn it
into a simple jump rather than pushing one level deeper into a stack on
every call. That is kind of a lame explanation, but it is a very
important idiom in functional programming, so you should probably spend
some time studying it to understand it, e.g. by doing a web search on
"tail recursion" and looking at explanations in the results.

Pure functional style would also prefer using reverse instead of
nreverse, but using nreverse this way is a Common Lisp idiom.

Finally, notice that the pattern of creating a new list by applying some
function to every element of an old list is very common, and CL (and
related languages) usually have a built-in for it, called some variant
of "map". In CL's case, that function is called MAPCAR, so you would
simply write:

(defun double-odd (xs)
(mapcar #'double-odd-1 xs))

where DOUBLE-ODD-1 is as defined above.

On Mon, 21 Nov 2022 20:32:08 -0800 (PST)
ME Jones <markjones@shawday.com> wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values
> in the list. What am i doing wrong?
>
> (doubleodd '(1 2 3 4 5))
>
> evaluates to:
> 26410
> NIL

Others have explained what you're doing wrong but I'm wondering in which
implementation (doubleodd '(1 2 3 4 5)) returns 26410 .I tried clisp
and SBCL and the code just returns NIL which is what I would have expected.
No matter what happens earlier , the recursion will terminate by calling
doubleodd with argument NIL .Try the following modified version and study
its output.

(defun doubleodd2 (list &aux ret)
(format t "Received ~S~%" list)
(when list
(if (oddp (car list)) (setf (car list) (* (car list) 2)))
(setq ret (doubleodd (cdr list)))
(format t "Got back ~S~%" ret)
ret))
--
And my personal favourite - carries out > 400 circumcisions per week. I
think he uses the foreskins in his Fortune 500 company making wallets
that expand into suitcases when rubbed.
http://www.freeratio.org/showthread.php?p=7302620#post7302620

On Tue, 22 Nov 2022 00:44:24 -0800
Paul Rubin <no.email@nospam.invalid> wrote:
> ME Jones <markjones@shawday.com> writes:
> > I am trying to create the following recursive function:
> > Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> I would first break this out into a function that conditionally doubles
> a single number:
>
> (defun double-odd-1 (n)
> (cond ((oddp n) (+ n n))
> (t n)))
>
> and then a tail-recursive function that applies DOUBLE-ODD-1 to each
> element of a list, consing it up into a new list that is in reverse
> order. Then, at the end, reverse the new list "in place" using
> nreverse:
>
> (defun double-odd (xs &optional acc)
> (defun f (n) (+ n n))
What's this for ?

> (cond ((null xs) (nreverse acc))
> (t (double-odd (cdr xs) (cons (double-odd-1 (car xs)) acc)))))
>
> Using an accumulation parameter allows the recursive call to be the
> function's final value, which means the compiler can actually turn it
> into a simple jump rather than pushing one level deeper into a stack on
> every call. That is kind of a lame explanation, but it is a very
> important idiom in functional programming, so you should probably spend
> some time studying it to understand it, e.g. by doing a web search on
> "tail recursion" and looking at explanations in the results.

On Tue, 22 Nov 2022 05:54:33 -0000 (UTC)
ST <usenet.233ph@slmail.me> wrote:
> On 2022-11-22, ME Jones <markjones@shawday.com> wrote:
> > Hello,
> > I am trying to create the following recursive function:
> >
> > Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
> >
> > (defun doubleodd (list)
> > (when list
> > (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> > (doubleodd (cdr list))
> > )
> > )
> >
> > When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?
>
>
> (defun doubleodd (l)
> (if (null l)
> nil
> (if (oddp (car l))
> (cons (* 2 (car l)) (doubleodd (cdr l)))
> (cons (car l) (doubleodd (cdr l))))))
>
> In a recursive function with a list, 2 important things to remember:
>
> you apply the function on the car of the list then your recursive call
> goes on the cdr.
>
> Once the list is null, you return a nil to end the recursion.
>
> Lisp is mostly a functional language, avoid the usage of (setf) inside
> a function unless it's to change the value of a lexical
> variable. Otherwise, you function is called destructive.

Common Lisp is a multi-paradigm language and it is up to individual preference
when one should use SETF .But SETF is specified to return the new value assigned
so that is another reason the general idea the opening poster had would not
work. For example

* (let ((l (list 1 2)))
(setf (car l) (* 2 (car l))))
2

* (let ((l (list 1 2)))
(setf (car l) (* 2 (car l)))
l)

(2 2)

> 2 books to read absolutely to understand Lisp and its philosophy:
>
> Ansi Common Lisp
> On Lisp
>
> Both from Paul Graham. The second one is not printed anymore, but
> available at low cost from lulu.com

Personally I don't believe in language "philosophies" , the concept is
too vague and subjective. I'll just note that "On Lisp" also exists at
http://www.paulgraham.com/onlisptext.html .

Paul Rubin <no.email@nospam.invalid> writes:

> ME Jones <markjones@shawday.com> writes:
>> I am trying to create the following recursive function:
>> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> I would first break this out into a function that conditionally doubles
> a single number:
>
> (defun double-odd-1 (n)
> (cond ((oddp n) (+ n n))
> (t n)))

This is specific enough that I would make it a lambda. Are we going to
need it for anything other than this exercise?

> and then a tail-recursive function that applies DOUBLE-ODD-1 to each
> element of a list, consing it up into a new list that is in reverse
> order.

I don't see this as a use-case for an accumulating parameter. Some
tutorials will want the plain hand-written recursive solution, but
really the way to go is surely with mapcar as you suggest:

> Finally, notice that the pattern of creating a new list by applying some
> function to every element of an old list is very common, and CL (and
> related languages) usually have a built-in for it, called some variant
> of "map". In CL's case, that function is called MAPCAR, so you would
> simply write:
>
> (defun double-odd (xs)
> (mapcar #'double-odd-1 xs))
>
> where DOUBLE-ODD-1 is as defined above.

(defun doubleodd (list)
(mapcar (lambda (x) (if (oddp x) (* 2 x) x)) list))

--
Ben.

On Monday, November 21, 2022 at 8:32:11 PM UTC-8, mark...@shawday.com wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?
>
> (doubleodd '(1 2 3 4 5))

There are a lot of other answers about how to update the function. I just want to
point out some other somewhat subtle issues with the code as presented here.

First off, the code uses (SETF (CAR LIST) ...) which will destructively mutate
the list. Generally as a beginner in the language you don't want to do destructive
list operations. It is really an optimization and can cause some very hard-to-debug
problems. So it is best to avoid it until you have a good understanding of lisp.

As an example of that, you are invoking your DOUBLEODD function with a constant
argument of '(1 2 3 4 5). And the code then destructively modifies that constant
list. This is undefined behavior in Common Lisp and must be avoided. You cannot
predict the results of doing this. There is no requirement that the compiler or in
this case the run time warn you about doing something like this. Common Lisp
allows you to do unwise things that might be prohibited in other languages.

On Tue, 22 Nov 2022 12:46:16 -0000 (UTC)
Spiros Bousbouras <spibou@gmail.com> wrote:
> On Mon, 21 Nov 2022 20:32:08 -0800 (PST)
> ME Jones <markjones@shawday.com> wrote:
> > Hello,
> > I am trying to create the following recursive function:
> >
> > Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
> >
> > (defun doubleodd (list)
> > (when list
> > (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> > (doubleodd (cdr list))
> > )
> > )
> >
> > When i evaluate i am not getting back a list and it's missing some values
> > in the list. What am i doing wrong?
> >
> > (doubleodd '(1 2 3 4 5))
> >
> > evaluates to:
> > 26410
> > NIL
>
> Others have explained what you're doing wrong but I'm wondering in which
> implementation (doubleodd '(1 2 3 4 5)) returns 26410 .I tried clisp
> and SBCL and the code just returns NIL which is what I would have expected.

As Tom Russ points out in <13c89cae-ff57-4ce6-a97b-740b584e1944n@googlegroups.com> ,
modifying a quoted object is undefined behaviour so it was wrong of me to expect
anything from (doubleodd '(1 2 3 4 5)) .But

(doubleodd (list 1 2 3 4 5))

should return NIL .

On Monday, November 21, 2022 at 8:32:11 PM UTC-8, ME Jones wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?
>
> (doubleodd '(1 2 3 4 5))
>
> evaluates to:
> 26410
> NIL
>
> Thank you for your help.
> Mark

Thank you all, for the help, very much appreciated.

I am learning and for sure will be making mistakes and i really appreciate the feedback, coding help, and references to reading material.

Here are the four functions that I have been working on:

I am still uncertain with large_atom because I am trying to accomplish without using let or higher order functions such as mapcar, and also solving using recursion and not iterative.

Again, Thank You!

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;The largest value greater than 0 in the list at any level of lists of integers.
;Example: (large_atom '((1 2) 3 ( 2 3 (1 9)))) -> 9
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun large_atom (lst)
(if (and (null (cdr lst)) (not (listp (car lst)))) (car lst)
(if (listp (car lst))
(let (
(x (large_atom (car lst)))
(y (if (null (cdr lst)) '() (large_atom (cdr lst))))
)
(if (null y) x (if (> x y) x y))
)
(let (
(z (large_atom (cdr lst)))
)
(if (> (car lst) z) (car lst) z)
)
)
)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
a list where all the integers are bigger than the input integer.
;Example: (biggerthan 3 '(1 2 3 4 5)) -> ( 4 5 )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun biggerthan (val L)
(cond
((null L) nil)
((> (car L) val) (cons (car L)
(biggerthan val (cdr L))))
(t (biggerthan val (cdr L)))
)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;A list where all the odd numbers have been doubled.
;Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun doubleodd (l)
(if (null l) nil
(if (oddp (car l))
(cons (* 2 (car l)) (doubleodd (cdr l)))
(cons (car l) (doubleodd (cdr l)))
)
)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;The product of all the even integers in a list.
;Example: (evenprod '(1 2 3 4 5)) -> 8 ; because 2 * 4 = 8
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun evenprod (l)
(if (null l) nil
(if (evenp (car l))
(* (car l) (evenprod (cdr l)))
(evenprod (cdr l))
)
)
)

ME Jones <markjones@shawday.com> writes:

> I am learning and for sure will be making mistakes and i really
> appreciate the feedback, coding help, and references to reading
> material.

When I ventured out into Common Lisp some years back, I found

https://www.cs.cmu.edu/~dst/LispBook/book.pdf

a very nice read, with lots of small recursive exercises.

Have fun! For me, learning a Lisp language (the whole family really
"clicked" wich me) was a great eye-opener, connecting an awful lot of
loose ends I encountered while using other languages and paradigms.

Best regards

Axel

Spiros Bousbouras <spibou@gmail.com> writes:
>> (defun double-odd (xs &optional acc)
>> (defun f (n) (+ n n))
> What's this for ?

Woops, sorry, f is a leftover from testing. Just delete that line. I
first tried to define the helper function internally like one would do
in Scheme, but it didn't work. I think in CL you are supposed to do it
with FLET but I didn't bother.

Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
> This is specific enough that I would make it a lambda. Are we going to
> need it for anything other than this exercise?

It's just to be more understandable. Of course in real life I'd use
mapcar, or maybe FLET with a lambda. I didn't want to introduce (or
look up) more complicated syntax since this was a tutorial example.

> I don't see this as a use-case for an accumulating parameter.

The idea is to avoid recursing on the stack out to the length of the
list.

> Some tutorials will want the plain hand-written recursive solution,

True, and we saw some posts showing how to do that. It's usually
preferable to use tail recursion when you can, though, so I showed how
to do that.

> but really the way to go is surely with mapcar as you suggest: ...
> (defun doubleodd (list)
> (mapcar (lambda (x) (if (oddp x) (* 2 x) x)) list))

Yep.

On 2022-11-22, ME Jones <markjones@shawday.com> wrote:
>
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> a list where all the integers are bigger than the input integer.
> ;Example: (biggerthan 3 '(1 2 3 4 5)) -> ( 4 5 )
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>
> (defun biggerthan (val L)
> (cond
> ((null L) nil)
> ((> (car L) val) (cons (car L)
> (biggerthan val (cdr L))))
> (t (biggerthan val (cdr L)))
> )
> )

Shorter, simpler, clearer:

(loop :for x :in '(1 2 3 4 5)
:when (> x 3) collect x)

On Tue, 22 Nov 2022 14:46:00 -0800
Paul Rubin <no.email@nospam.invalid> wrote:
> Spiros Bousbouras <spibou@gmail.com> writes:
> >> (defun double-odd (xs &optional acc)
> >> (defun f (n) (+ n n))
> > What's this for ?
>
> Woops, sorry, f is a leftover from testing. Just delete that line. I
> first tried to define the helper function internally like one would do
> in Scheme, but it didn't work. I think in CL you are supposed to do it
> with FLET but I didn't bother.

Yes , if you want to make it local , you use FLET or LABELS .

On Tue, 22 Nov 2022 12:21:06 -0800 (PST)
ME Jones <markjones@shawday.com> wrote:
> Thank you all, for the help, very much appreciated.
>
> I am learning and for sure will be making mistakes and i really appreciate
> the feedback, coding help, and references to reading material.
>
> Here are the four functions that I have been working on:
>
> I am still uncertain with large_atom because I am trying to accomplish
> without using let or higher order functions such as mapcar, and also
> solving using recursion and not iterative.

I'm not sure what you mean not using LET .What construct are you trying to
avoid ? Anyway , I didn't test your code but it looks correct to me with
1 exception :

[...]

> (defun evenprod (l)
> (if (null l) nil
> (if (evenp (car l))
> (* (car l) (evenprod (cdr l)))
> (evenprod (cdr l))
> )
> )
> )

Should be
if (null l) 1

--
vlaho.ninja/prog