Wolfram Language (Mathematica), 88 85 76 bytes

(For[i=k=j=p=0,k<#,i~FreeQ~p||k++,i=i|p;p+=If[p>++j&&FreeQ[i,p-j],-j,j]];p)& 

Try it online!

1-indexed.

Explanation

For[ 

For loop.

i=k=j=p=0 

Start with i (\$=\{a_1, a_2, \ldots\}\$), k (number of duplicates found), j (\$=n\$), p(\$=a_{n-1}\$) equal to 0.

k<# 

Repeat while k is less than the input.

i=i|p 

Append p to i using the head Alternatives (a golfier version of List in this case).

p+=If[p>++j&&FreeQ[i,p-j],-j,j] 

Increment j. If p is greater than j (i.e. \$a_{n-1} > n\$) and p-j is not in i (i.e. \$a_{n-1} - n\$ is new), then increment p by -j. Otherwise, increment p by j.

i~FreeQ~p||k++ 

Each iteration, increment k if p is not in i (the || (= or) short-circuits otherwise).

... ;p 

Return p.

Python 2, 91 bytes

k=input();n=0;l=n, while k:n+=1;x=l[-1]-n;u=x+2*n*(x<1or x in l);k-=u in l;l+=u, print l[n] 

Try it online!

1-indexed.

Python 2, 78 bytes

n=input() l=[];d=x=0 while n:d-=1;l+=x,d;x+=[d,-d][x+d in l];n-=x in l print x 

Try it online!

APL (Dyalog Unicode), 56 54 49 48 bytes (SBCS)

Saved 2 7 bytes thanks to @ovs!

Saved 1 byte thanks to @Adám

0∘{×⍵:r,⍣d⊢(r,⍺)∇⍵-d←⍺∊⍨r←(⊃((≤∨⍺∊⍨-)⌷-,+)≢)⍺⋄⍬} 

Try it online!

Can be f k. Recursively builds up the first k duplicates.

⍺ holds Recamán's sequence (in reverse), and is set to 0 if no argument is given (at the start). If k (⍵) is 0, it returns an empty array (⍬). Otherwise, it computes the next term r. If r is present in ⍺, it calls itself with r,⍺ as the left argument and ⍵-1 as the right argument, and prepends r to the result of that. If not, it just returns (r,⍺) f ⍵, hoping for the next iteration to find a duplicate.

⎕IO←0 has to be used before using this, since it relies on 0-indexing.

0∘ ⍝ Default argument to start off the sequence {×⍵: ⍝ If k is greater than 1: r←(⊃((≤∨⍺∊⍨-)⌷-,+)≢)⍺ ≢ ⍝ Current n is the size of ⍺. ⊃ ⍝ First element of ⍺ (a_{n-1}) ⌷ ⍝ Index into -,+ ⍝ a_{n-1} - n, a_{n-1} + n using (≤∨⍺∊⍨-) ⍝ another train to return 1 or 0 ≤ ⍝ If a_{n-1} is not greater than n ∨ ⍝ or - ⍝ a_{n-1} - n ⍺∊⍨ ⍝ is already in a, ⍝ use a+n, otherwise a-n d←⍺∊⍨r ⍝ Whether or not r (a_n) is a duplicate (r,⍺)∇⍵-d (r,⍺) ⍝ Add r to ⍺, because it's part of Recaman's sequence ⍵-d ⍝ Decrement k if r is a duplicate ∇ ⍝ Call itself, find the next duplicates r(,⍣d)(r,⍺)∇⍵-d ⍣d ⍝ If d is 0, just return (r,⍺)∇⍵-d r , ⍝ Otherwise, add r to the list of duplicates (which is returned from (r,⍺)∇⍵-d ⋄⍬ ⍝ If k is 0, return an empty array } ``` 

05AB1E, 25 bytes

Outputs the nth item 1-indexed

¾ˆµ¯D¤N-DŠD0›*åN·*+©å½®Dˆ 

Try it online!

JavaScript (ES6), 66 59 bytes

Returns the N-th term, 0-indexed.

i=>(g=x=>!g[x+=x>n&!g[x-n]?-n:n]||i--?g(g[n++,x]=x):x)(n=0) 

Try it online!

How?

We use g() as our main recursive function and as an object to keep track of the duplicates.

i => ( // given i g = x => // g = recursive function and generic object !g[x += // update x: x > n & !g[x - n] ? // if x is greater than n and x - n was not visited so far: -n // subtract n from x : // else: n // add n to x ] // if x is not a duplicate || i-- ? // or x is a duplicate but not the one we're looking for: g(g[n++, x] = x) // increment n, mark x as visited and do a recursive call : // else: x // stop recursion and return x )(n = 0) // initial call to g() with n = x = 0 

Pyth, 34 33 bytes

J][email protected]}K+=G-eJZ*yZ|}GJ<G0~+JKQ1 

Try it online!

Outputs the n first duplicates.

_{*waits for Jelly or one of the new stack languages to enter*}

Rust, 160 bytes

|k|{let(mut a,mut r,mut n,mut i,mut v)=(vec!(0),0,1usize,0,0);while i<k{v=if v>n&&!a.contains(&(v-n)){v-n}else{v+n};if a.contains(&v){r=v;i+=1}a.push(v);n+=1}r} 

Try it online!

Ungolfed:

|k| { let mut a=vec!(0); let mut r=0; let mut n=1usize; let mut i=0; let mut v=r; while i < k { v = if v > n && !a.contains(&(v-n)) { v - n } else { v + n }; if a.contains(&v) { r = v; i += 1 } a.push(v); n += 1 } r }