Haskell, 38 bytes

([x|x<-[1..],(/=)<*>reverse$show x]!!) 

Uses 0-based index. ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11 -> 23.

The test whether to keep a number (/=)<*>reverse$show x translates to (show x) /= (reverse (show x)), i.e check if the string representation of the number does not equal the reverse of the string representation.

Brachylog, 14 11 bytes

;0{<≜.↔¬}ⁱ⁽ 

-3 bytes tanks to Fatalize

Explanation

; { }ⁱ⁽ -- Find the nth number 0 -- (starting with 0) < -- which is bigger then the previous one ≜ -- make explicit (otherwise it fucks up) . -- which is the output ↔ -- and if reversed ¬ -- is not the output 

Try it online!

Jelly, 9 bytes

1 bytes thanks to @Sp3000.

ṚḌ_ 0dz#Ṫ 

Try it online!

Test suite.

Explanation

DUḌ_ Helper link. Check if x is not palindrome. D Convert to decimal. U Reverse. Ḍ Convert back to integer. _ Subtract x from the result above. For 23, this will yield 32-23 = 9. Only yield 0 (falsy) if x is palindrome. If x is not a palindrome, it will return a truthy number. 0dz#Ṫ Main link. 0 Start from 0. # Find the first numbers: ³ <input> Ç where the above link returns a truthy number. Ṫ Yield the last of the matches. 

05AB1E, 8 bytes

Code:

µNÂÂQ>i¼ 

Uses CP-1252 encoding. Try it online!.

Clojure, 62 bytes

#(nth(for[i(range):when(not=(seq(str i))(reverse(str i)))]i)%) 

0-indexed. Generate lazily infinite range of non-palindromic numbers using list comprehension and take ith one. See it online: https://ideone.com/54wXI3

PowerShell v2+, 65 bytes

for(;$j-lt$args[0]){if(++$i-ne-join"$i"["$i".length..0]){$j++}}$i 

Loops through numbers from 0 (implicit value for uninitialized $i) until we find input $args[0] many matches, then outputs the last one. Note that we don't initialize the loop, so $j=0 is implicit.

Each iteration, we pre-increment $i, and check if it's not-equal to $i reversed. If so, that means we've found a non-palindrome, so increment $j. The loop then continues as many times as necessary.

Examples

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 100 120 PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 5 15 PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 55 70 PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 212 245 

Python 2, 60 bytes

f=lambda n,i=0,j=1:j>n and i-1or f(n,i+1,j+(`i`!=`i`[::-1])) 

A one-indexed function that takes input of n via argument and returns the nth non-palindromic number.

How it works

This is an exhaustive recursive search, which consecutively tests integers i in the range [1,∞) until n non-palindromic numbers have been found; since i is pre-incremented, i-1 is then returned. Testing whether a number is palindromic is performed by converting to a string, reversing, and then checking whether the original and reversed strings are equal.

The code is logically equivalent to:

def f(n,test=0,count=1): if count>n: return test elif str(test)!=reversed(str(test)): return f(n,test+1,count+1) else: return f(n,test+1,count) 

which itself is essentially:

def f(n): test=0 count=1 while count<=n: if str(test)!=reversed(str(test)): count+=1 test+=1 return test-1 

Try it on Ideone

Clojure, 62 bytes

#(nth(filter(fn[i](not=(seq i)(reverse i)))(map str(range)))%) 

A quite different approach than the other answer, but equal length.

R, 133 117 93 76 bytes

-16 bytes thanks to JayCe. -41 bytes thanks to Giuseppe.

x=scan();while({F=F+any((D=T%/%10^(1:nchar(T)-1)%%10)!=rev(D));F<=x})T=T+1;T 

Try it online!

Forth (gforth), 103 99 bytes

: f 9 swap 0 do begin 1+ dup 0 over begin 10 /mod >r swap 10 * + r> ?dup 0= until = 0= until loop ; 

Try it online!

Explanation

Loop n times, each iteration finds the next non-palindromic number by incrementing a counter by 1 until the number doesn't equal itself reversed

Ungolfed Code

Normally I wouldn't "ungolf" the code, but since this code is somewhat messy I figured it would help

: reverse ( s -- s ) 0 swap begin 10 /mod >r swap 10 * + r> ?dup 0= until ; : f ( s -- s ) 9 swap 0 0 do begin 1+ dup dup reverse = 0= until loop ; 

Code Explanation

: f \ start a new word definition 9 \ start at 9, since all positive ints < 10 are palindromic swap 0 \ set up loop parameters from 0 to n-1 do \ start a counted loop begin \ start an indefinite loop 1+ dup \ increment counter and place a copy on the stack ( Reverse ) 0 over \ add 0 to the stack (as a buffer) and copy the top counter above it begin \ start another indefinite loop 10 /mod \ get the quotient and remainder of dividing the number by 10 >r \ store the quotient on the return stack swap 10 * \ multiply the current buffer by 10 + \ add the remainder to the buffer r> \ grab the quotient from the return stack ?dup \ duplicate if not equal to 0 0= \ check if equal to 0 until \ end inner indefinite loop if quotient is 0 ( End Reverse ) = 0= \ check if counter =/= reverse-counter until \ end the outer indefinite loop if counter =/= reverse-counter loop \ end the counted loop ; \ end the word definition 

Perl 6, 29 bytes

{grep({$_!= .flip},^Inf)[$_]} 

( uses 0 based index )

{ # The $_ is implied above grep( # V { $_ != $_.flip }, # only the non-palindromic elements of ^Inf # an Infinite list ( 0,1,2,3 ...^ Inf ) )[ $_ ] # grab the value at the given index } 

Usage:

my &non-palindrome = {grep({$_!= .flip},^Inf)[$_]} say non-palindrome 1 - 1; # 10 say non-palindrome 5 - 1; # 15 say non-palindrome 12 - 1; # 23 # this also works: say non-palindrome 0..20; # (10 12 13 14 15 16 17 18 19 20 21 23 24 25 26 27 28 29 30 31 32) 

Actually, 17 bytes

;τR9+;`$;R=Y`M@░E 

Try it online!

Values are 1-indexed. This could be easily changed to 0-indexed by replacing the first R with r. But, R is what I initially typed, so that's what I'm going with.

The nonpalindromic numbers satisfy a(n) ≈ n + 10, so 2n+9 is a sufficient upper bound.

Explanation:

;τR9+;`$;R=Y`M@░E ;τ9+R; push n, range(1,(2*n)+10) `$;R=Y`M@░ take values that are not palindromic E take nth element 

JavaScript (ES6), 54 bytes

Uses 1-based indexing. Only works up until the 7624th number.

d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a 

Usage

d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a d(1) 10 d(123) 146 d(7624) 7800 d(7625) // Uncaught RangeError: Maximum call stack size exceeded 

JavaScript (ES6), 59 bytes

Doesn't use recursion and so can handle much larger inputs.

i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a") 

Usage

(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(1) 10 (i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(7625) 7801 (i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(123456) 124579 

Javascript (using external library) (97 bytes)

n=>_.Sequence(n,i=>{i=_.From(i+"");if(!i.Reverse().SequenceEqual(i)){return i.Write("")}}).Last() 

Link to lib: https://github.com/mvegh1/Enumerable

Code explanation: Library has static method called Sequence, where first param defines how many elements the sequence will guarantee to create, and the 2nd parameter is a predicate accepting the current iteration value, "i". The predicate converts the integer to a string, which gets converted to a char array by calling _.From. The char array is compared against the reversal of the char array, and if they are not equal the char array is joined back into a string and returned. Otherwise, nothing is returned (i.e the result is undefined, which the library will always ignore). Finally, the last element of the sequence, i.e the Nth element is returned

C, 84 bytes

Function f(n) takes integer n and returns n-th non-palindromic number (1 based).

g(n,r){return n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;} 

Test it on Ideone!

It's fairly trivial code, thus there is probably space for improvement.

Ruby, 54 bytes

This function is 1-indexed and is partially based on Dom Hastings's Javascript answer. I think there's a way to golf this better, especially with that last ternary condition. Also, this function currently returns a string, which may need to be edited later. Any golfing suggestions are welcome.

f=->x,y=?9{x<1?y:(y.next!.reverse!=y)?f[x-1,y]:f[x,y]} 

Ungolfed:

def f(x, y="9") if x<1 return y else y = y.next if y.reverse != y return f(x-1, y) else return f(x, y) end end end 

C++ (GCC), 148 bytes

It's 1-based and the algorithm is really naive

#import <iostream> using namespace std;int n,i=1;string s;main(){cin>>n;while(s=to_string(i+1),(n+=equal(begin(s),end(s),s.rbegin()))-i++);cout<<i;} 

APL NARS 35 chars

r←v a;c r←c←0 A:r+←1⋄c+←r≠⍎⌽⍕r⋄→A×⍳c<a 

it is the function v; "⍎⌽⍕"r traslate number r in string, reverse that string, traslate from string to number. Test and help functions:

 ⍝ return the one string for the basic types ('Char', 'Int', 'Float', 'Complex or Quaternion or Oction') ⍝ or one string for composite types ('Tensor 3' 'Tensor 4' etc 'Matrix', 'List', 'String') ⍝ follow the example in: https://codegolf.stackexchange.com/a/39745 type←{v←⍴⍴⍵⋄v>2:'Tensor ',⍕v⋄v=2:'Matrix'⋄(v=1)∧''≡0↑⍵:'String'⋄''≡0↑⍵:'Char'⋄v=1:'List'⋄⍵≢+⍵:'Complex or Quaternion or Oction'⋄⍵=⌈⍵:'Int'⋄'Float'} h←{'Int'≢type ⍵:¯1⋄(⍵<1)∨⍵>2e5:¯1⋄v ⍵} h 1 10 h 1.32 ¯1 h 7878 8057 h¨3 5 12 13 15 23 h 6 7 8 ¯1 h '123' ¯1 h '1' ¯1 h 1.0 10 h 1.0003 ¯1 h ¯2 ¯1 h 0 ¯1 h 200000 201200 h 200001 ¯1 

Husk, 6 bytes

Yay for ↔ :)

!fS≠↔N 

Try it online!

Explanation

 f N -- filter the naturals by: S≠ -- is it not equal to.. ↔ -- ..itself reversed ! -- index into that list 

Perl 5, 33 + 1 (-p) = 34 bytes

map{1until++$\!=reverse$\}1..$_}{ 

Try it online!

C# 7, 89 bytes

n=>{int i=9;for(;n-->0;)if(Enumerable.SequenceEqual(++i+"",(""+i).Reverse()))i++;return i;} 

1 indexed Try on Repl.It

n=> int i = 9; | Start at 9. Iterate exactly n times. Assume n >= 1 for(;n-->0;) | Iterate n times if(EnumerableSequenceEqual( | Compare two sequences ++i+"",(""+i).Reverse()) | Generate the forward and backward strings, which behave like char sequences for Linq i++ | If the sequences are equal, the number is a palindrome. Increment i to skip return i; | Return the number after the for loop exits 

I don't think this uses any language features from c# 7, but I put there since that's what I tested against

Java 8, 117 95 94 bytes

n->{int r=10;for(;n-->0;)if((++r+"").contains(new StringBuffer(r+"").reverse()))r++;return r;} 

0-indexed

Explanation:

Try it here.

n->{ // Method with integer as both parameter and return-type int r=10; // Result-integer, starting at 10 for(;n-->0;) // Loop an amount of times equal to the input if((++r+"") // First raise `r` by 1, and then check if `r` .contains(new StringBuffer(r+"").reverse())) // is the same as `r` reversed (and thus a palindrome) r++; // And if it is: raise `r` by 1 again return r;} // Return result-integer 

Japt, 14 ... 9 7 bytes

0-indexed.

Ȧsw}iU 

Try it

Ȧsw}iU :Implicit input of integer U È :Function taking an integer X as an argument ¦ : Test for inequality with s : Convert to string w : Reverse } :End function iU :Get the Uth integer that returns true 

TCC, 11 bytes

?>!~<>;i;'T 

Try it online!

 | Printing is implicit ?> | Find n-th number for which the following is "T": !~ | If not equal... <>; | reverse. No value specified, so input is assumed. i; | Input, since double semicolons are ignored 'T | ... print string "T"