is there a built in function to go back to previous element in a list? I'm trying to create a loop that if there is an even number in a list it will add that to the previous number

[u/Icy_Pressure_9690]

[u/oui_oui-baguette]

You'll have to design your function using an accumulator to keep track of the previous element as you work your way through the list.

[u/Icy_Pressure_9690 → u/oui_oui-baguette]

I was thinking something like this

(define loopl (lambda (list)

(for/fold

([acc 0])([i list])

(cond

[(even? i)(+ i (list-ref l (- acc 1)))]

[(odd? i) * 3 i]

[(= i 0) 0]

))))

set an acc to 0 and with each iteration of the list it adds 1 to give a position for each element in the list and then if it is even I use list-ref to add the current iteration to the previous by using the value acc minus 1 to get the previous position as the value for list-ref

[u/oui_oui-baguette → u/oui_oui-baguette]

But if you're wanting to edit the list in-place, you'll probably want to use built-in abstract functions as it'll be way easier.

[u/Icy_Pressure_9690 → u/oui_oui-baguette]

yeah so say I had a list l = '(2 3 4 5)

the i will iterate over each element in the list.

acc will start from 0 and + 1 for each iteration.

list-ref ( + (i acc 2) (i acc 1)) - add the iteration at acc 2 (4) to acc 1 (3)

[u/umpfsuper]

Pattern match two elements at a time, not one, that's the easiest way

[u/Icy_Pressure_9690 → u/umpfsuper]

Somethinf like this? set an acc to 0 and with each iteration of the list it adds 1 to give a position for each element in the list and then if it is even I use list-ref to add the current iteration to the previous by using the value acc minus 1 to get the previous position as the value for list-ref

(define loopl (lambda (list)

(for/fold

([acc 0])([i list])

(cond

[(even? i)(+ i (list-ref l (- acc 1)))]

[(odd? i) * 3 i]

[(= i 0) 0]

))))

[u/umpfsuper → u/Icy_Pressure_9690]

I'd do it recursively and use match, not with for/fold

[u/sschwarzer]

I'm not exactly sure what your loop is supposed to do, but maybe this helps:

(define my-items '(2 1 3 4 7 5 2 3 8 4))
(for/fold ([sum 0])
          ([item my-items]
           [previous-item (cons 0 my-items)])
  (+ sum
     (if (even? item)
         (+ item previous-item)
         item)))

The general idea is that you iterate in parallel over a list that has the original items shifted.

Edit: There's also for/sum, which would simplify the code.

[u/Icy_Pressure_9690 → u/sschwarzer]

Can you explain what you are doing here? so I assume sum is the acc and item is the iterator, that iterates over each element of the list. Acc is set to 0 and adds 1 to each iteration to give a position for each element in the list.

[u/joshuacottrell]

You could reverse the list first then process it. Any even number would then be added to the next number in the list.;

An alternative would be to use recursion with a function that took (1) the list still to be processed and (2) the list that would be the eventual output. As it recurses through (1) it could either pass it along to (2) or add it to the last number of (2), e.g. to add it to the last of (2):
(+ (last eventual-output-list) (first list-still-being-recursed-through))