Um número palíndrico (caso você não saiba) é um número que lê o mesmo para trás e para a frente (exemplo, 11). Os primeiros números 15 não palindrómicos são: 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26. Este é o A029742 . Eu preciso constantemente desses números, mas meu bloco de anotações é muito pequeno, portanto seu código deve ser o mais curto possível.

Regras

• Cada envio deve ser um programa ou função completo (por exemplo, em C, você não pode simplesmente definir uma função sem cabeçalhos, mas pode definir uma função COM os cabeçalhos necessários).
• Se possível, forneça um link para um site onde seu programa possa ser testado.
• Seu programa não deve escrever nada para STDERR.
• Você pode receber informações como argumento ou de STDIN(ou a alternativa mais próxima em seu idioma).
• Os programas são pontuados de acordo com os bytes . O conjunto de caracteres usual é UTF-8; se você estiver usando outro, especifique.
• As brechas padrão são proibidas.

Casos de teste

1
==> 10

-----

5
==> 15

-----

12
==> 23

Pontuação

Isso é código-golfe , então o mínimo de bytes vence.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

/* Configuration */

var QUESTION_ID = 79251; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Pitão, 7 bytes

e.f!_I`

Suíte de teste

Explicação:

e.f!_I`
e.f!_I`ZQ    Implicit variable introduction.
 .f     Q    Find the first Q numbers whether the following is truthy,
             starting at 1, where Q is the input.
      `Z     Convert the number to a string.
     _I      Check if it's the same when reversed.
    !        Logical not.
 e           Return the last element of the list.

Haskell, 38 bytes

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

Usa índice baseado em 0. ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11-> 23.

O teste para manter um número é (/=)<*>reverse$show xtraduzido (show x) /= (reverse (show x)), ou seja, verifique se a representação em cadeia do número não é igual ao reverso da representação em cadeia.

Braquilog , 14 11 bytes

;0{<≜.↔¬}ⁱ⁽

-3 bytes de tanques para Fatalizar

Explicação

; {      }ⁱ⁽        --  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

Experimente online!

Geléia, 9 bytes

1 bytes graças a @ Sp3000 .

ṚḌ_
0dz#Ṫ

Experimente online!

Suíte de teste.

Explicação

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

Código:

µNÂÂQ>i¼

Usa a codificação CP-1252 . Experimente online! .

Clojure, 62 bytes

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

Indexado a 0. Gere um intervalo infinitamente lento de números não palindrômicos usando a compreensão de lista ei um. Veja on-line: https://ideone.com/54wXI3

PowerShell v2 +, 65 bytes

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

Faz um loop através de números de 0(valor implícito para não inicializado $i) até encontrarmos $args[0]muitas correspondências de entrada e, em seguida, produz a última. Observe que não inicializamos o loop, portanto, $j=0está implícito.

A cada iteração, pré-incrementamos $ie verificamos se não é igual a $iinvertida. Nesse caso, significa que encontramos um não-palíndromo, então incremente $j. O loop continua quantas vezes for necessário.

Exemplos

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]))

Uma função indexada que recebe entrada de n argumento via e retorna o nnúmero não palindrômico.

Como funciona

Esta é uma pesquisa recursiva exaustiva, que testa consecutivamente números inteiros ino intervalo [1,∞)até que nnúmeros não palindrômicos sejam encontrados; já que ié pré-incrementado,i-1 é retornado. Testar se um número é palíndrico é realizado convertendo-se em uma sequência, revertendo e verificando se as seqüências originais e as revertidas são iguais.

O código é logicamente equivalente a:

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)

que em si é essencialmente:

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

Experimente no Ideone

Clojure, 62 bytes

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

Uma abordagem bem diferente da outra resposta, mas com o mesmo comprimento.

R , 133 117 93 76 bytes

-16 bytes graças ao JayCe. -41 bytes graças a Giuseppe.

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

Experimente online!

Quarto (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 ;

Experimente online!

Explicação

Loop n vezes, cada iteração encontra o próximo número não palindrômico, incrementando um contador em 1 até que o número não seja igual a si mesmo invertido

Código Ungolfed

Normalmente eu não "desdobrava" o código, mas como esse código é um pouco confuso, achei que ajudaria

: 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
;

Código Explicação

: 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)[$_]}

(usa índice baseado em 0)

{         # 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
}

Uso:

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)

Na verdade, 17 bytes

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

Experimente online!

Os valores são indexados em 1. Isso pode ser facilmente alterado para indexado 0, substituindo o primeiro Rporr . Mas, Ré o que eu digitei inicialmente, então é com isso que eu vou.

Os números não palíndricos satisfazem a(n) ≈ n + 10, assim 2n+9como um limite superior suficiente.

Explicação:

;τ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

Usa indexação baseada em 1. Só funciona até o número 7624.

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

Uso

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

Não usa recursão e, portanto, pode lidar com entradas muito maiores.

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

Uso

(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 (usando biblioteca externa) (97 bytes)

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

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

Explicação do código: A biblioteca possui um método estático chamado Sequence, onde o primeiro parâmetro define quantos elementos a sequência garantirá criar, e o segundo parâmetro é um predicado que aceita o valor atual da iteração, "i". O predicado converte o número inteiro em uma sequência, que é convertida em uma matriz de caracteres chamando _.From. A matriz de caracteres é comparada com a reversão da matriz de caracteres e, se elas não forem iguais, a matriz de caracteres será juntada novamente em uma string e retornada. Caso contrário, nada será retornado (ou seja, o resultado é indefinido, que a biblioteca sempre ignorará). Finalmente, o último elemento da sequência, ou seja, o enésimo elemento é retornado

C, 84 bytes

A função f(n)recebe um número inteiro ne retorna n-thum número não palíndrico (baseado em 1).

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;}

Teste em Ideone!

É um código bastante trivial, portanto, provavelmente há espaço para melhorias.

Ruby, 54 bytes

Essa função é indexada em 1 e é parcialmente baseada na resposta Javascript de Dom Hastings . Eu acho que há uma maneira de jogar isso melhor, especialmente com essa última condição ternária. Além disso, atualmente, essa função retorna uma string, que pode precisar ser editada posteriormente. Todas as sugestões de golfe são bem-vindas.

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

É baseado em 1 e o algoritmo é realmente ingênuo

#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 caracteres

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

é a função v; "⍎⌽⍕" r traduz o número r na string, inverte a string, traduz da string para o número. Teste e funções de ajuda:

  ⍝ 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: /codegolf//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

Casca , 6 bytes

Yay for ↔:)

!fS≠↔N

Experimente online!

Explicação

 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..$_}{

Experimente online!

C # 7, 89 bytes

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

1 tentativa indexada de 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

Eu não acho que isso use nenhum recurso de linguagem do c # 7, mas eu coloquei lá, já que foi contra isso que testei

Japt , 14 12 11 10 9 bytes

Indexado 1

@UµX¦sw}f

Tente

Java 8, 117 95 94 bytes

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

Indexado a 0

Explicação:

Experimente aqui.

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

TCC, 11 bytes

?>!~<>;i;'T

Experimente 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"