Q:

Set a starting value and count towards n and then back to the starting value

Basically I need to set a starting value (1) and count towards my n and back to one. And for each calculation I need to display the value.
This is what I have right now:
(define (teken-symbolen x y)
  (begin (display x) (display y) (display x)))

(define (teken-n x y n)
  (cond ((or(= n 0) (< n 0)) (display onmogelijk))
        ((= n 1) (teken-symbolen x y))
        (else (begin
                (teken-symbolen x y)
                (teken-n x y (- n 1))))))

What this does currently is display the value n only while I need to display every calculation from one towards my value n and back to one again all on a different line, which I figured I could use (newline) for.
Any help I would greatly appreciate.

A:

Think about what should happen when.. Eg. if you write
(begin (display 1)
       (display 2)
       (display 3))

In which order are the numbers displayed? So lets transform this to what you need to do. I have no idea why you think x and y are good values so I'm thinking you should have a contract.. Since you already know the first value (1) you only need n so I suggest:
(define (print-to-and-from n)
  ...)

Here are some expectations
(print-to-and-from 0) ; nothing printed (or whatever)
(print-to-and-from 1) ; 1 printed only once (perhaps)
(print-to-and-from 2) ; 1, 2, 1 printed
(print-to-and-from 3) ; 1, 2, 3, 2, 1 printed

You'll need to know that you are currently on 1 or 2 etc so you need a binding that is not part of the contract. This you can do with a helper. 
(define (print-to-and-from n)
  (define (helper cur)
    ; In here you can compare cur to n
    ; and increase cur on consecutive calls
    ...)
  (helper 1))

Now if you looked at the outcomes from 2 and 3 in terms of relation to 2 and 3 you'll see that the second recursion of (print-to-and-from 3) is the same as (print-to-and-from 2). Thus you'd like the default case to print before and after the next recursion so that you print 1, then do the 2, 3, 2, you get the control back and print 1 from the first step. Just like the first code in my anser except the second display is a call to the helper. 
Also notice that when it stops it only prints the stop value once, even when it is 1. Thus you base case should only print the current value. 
NB It might be easier to make the helper a global variable. That is done with lambda lifting. eg. make all closure variables bound ones:
(define (print-to-and-from-helper cur n)
  ; In here you can compare cur to n
  ; and increase cur on consecutive calls
  ...)

(define (print-to-and-from n)
  (print-to-and-from-helper 1 n))

This doesn't change the program much except you need to write a little more. The advantage is that you can test the helper individually. Good luck!

