Un nombre palindromique (au cas où vous ne le sauriez pas) est un nombre qui se lit de la même manière en arrière et en avant (exemple, 11). Les 15 premiers numéros non palindromiques sont: 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26. Ceci est A029742 . J'ai constamment besoin de ces chiffres, mais mon bloc-notes est très petit, donc votre code doit être aussi court que possible.

Règles

• Chaque soumission doit être un programme ou une fonction complète (par exemple, en C, vous ne pouvez pas simplement définir une fonction sans en-têtes, mais vous pouvez définir une fonction AVEC les en-têtes nécessaires).
• Si c'est possible, fournissez un lien vers un site où votre programme peut être testé.
• Votre programme ne doit rien écrire STDERR.
• Vous pouvez prendre la saisie comme argument ou de STDIN(ou l'alternative la plus proche dans votre langue).
• Les programmes sont notés en octets . Le jeu de caractères habituel est UTF-8, si vous en utilisez un autre, veuillez le préciser.
• Les failles standard sont interdites.

Cas de test

1
==> 10

-----

5
==> 15

-----

12
==> 23

Notation

C'est le code-golf , donc le moins d'octets gagne.

Soumissions

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

/* 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>

Pyth, 7 octets

e.f!_I`

Suite de tests

Explication:

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 octets

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

Utilise un index basé sur 0. ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11-> 23.

Le test de maintien ou non d'un nombre se (/=)<*>reverse$show xtraduit par (show x) /= (reverse (show x)), c'est- à -dire vérifier si la représentation sous forme de chaîne du nombre n'est pas égale à l'inverse de la représentation sous forme de chaîne.

Brachylog , 14 11 octets

;0{<≜.↔¬}ⁱ⁽

-3 octets réservoirs à fataliser

Explication

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

Essayez-le en ligne!

Gelée, 9 octets

1 octets grâce à @ Sp3000 .

ṚḌ_
0dz#Ṫ

Essayez-le en ligne!

Suite de tests.

Explication

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 octets

Code:

µNÂÂQ>i¼

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Clojure, 62 octets

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

0 indexé. Générez une plage paresseusement infinie de nombres non palindromiques en utilisant la compréhension de la liste et prenez icelle-ci. Voir en ligne: https://ideone.com/54wXI3

PowerShell v2 +, 65 octets

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

Boucle à travers les nombres de 0(valeur implicite pour non initialisé $i) jusqu'à ce que nous trouvions l'entrée de $args[0]nombreuses correspondances, puis génère la dernière. Notez que nous n'initialisons pas la boucle, c'est donc $j=0implicite.

Chaque itération, nous pré-incrémentons $iet vérifions si elle n'est pas égale à $iinversée. Si c'est le cas, cela signifie que nous avons trouvé un non-palindrome, alors incrémentez $j. La boucle se poursuit ensuite autant de fois que nécessaire.

Exemples

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 octets

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

Fonction à un index qui prend en entrée l' nargument via et retourne le ne nombre non palindromique.

Comment ça marche

Il s'agit d'une recherche récursive exhaustive, qui teste consécutivement des nombres entiers idans la plage [1,∞)jusqu'à ce que ndes nombres non palindromiques aient été trouvés; puisque iest pré-incrémenté, i-1est ensuite renvoyé. Tester si un nombre est palindromique est effectué en convertissant en chaîne, en inversant, puis en vérifiant si les chaînes d'origine et inversées sont égales.

Le code est logiquement équivalent à:

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)

qui lui-même est essentiellement:

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

Essayez-le sur Ideone

Clojure, 62 octets

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

Une approche assez différente de l'autre réponse, mais de longueur égale.

R , 133 117 93 76 octets

-16 octets grâce à JayCe. -41 octets grâce à Giuseppe.

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

Essayez-le en ligne!

Forth (gforth) , 103 99 octets

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

Essayez-le en ligne!

Explication

Boucle n fois, chaque itération trouve le prochain nombre non palindromique en incrémentant un compteur de 1 jusqu'à ce que le nombre ne soit pas égal à lui-même inversé

Code non golfé

Normalement, je ne "dégonfle" pas le code, mais comme ce code est un peu compliqué, je me suis dit que cela aiderait

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

Explication du code

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

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

(utilise un index basé sur 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
}

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)

En fait, 17 octets

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

Essayez-le en ligne!

Les valeurs sont indexées 1. Cela pourrait être facilement changé en 0 indexé en remplaçant le premier Rpar r. Mais Rc'est ce que j'ai initialement tapé, c'est donc ce que je veux dire.

Les nombres non palindromiques satisfont a(n) ≈ n + 10, ainsi 2n+9est une limite supérieure suffisante.

Explication:

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

Utilise l'indexation basée sur 1. Fonctionne uniquement jusqu'au numéro 7624.

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 octets

N'utilise pas de récursivité et peut donc gérer des entrées beaucoup plus importantes.

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 (à l'aide d'une bibliothèque externe) (97 octets)

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

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication du code: la bibliothèque a une méthode statique appelée séquence, où le premier paramètre définit le nombre d'éléments que la séquence garantira de créer, et le deuxième paramètre est un prédicat acceptant la valeur d'itération actuelle, "i". Le prédicat convertit l'entier en une chaîne, qui est convertie en un tableau de caractères en appelant _.From. Le tableau de caractères est comparé à l'inversion du tableau de caractères, et s'ils ne sont pas égaux, le tableau de caractères est joint à nouveau dans une chaîne et renvoyé. Sinon, rien n'est retourné (ie le résultat n'est pas défini, ce que la bibliothèque ignorera toujours). Enfin, le dernier élément de la séquence, c'est-à-dire le Nième élément est retourné

C, 84 octets

La fonction f(n)prend un entier net retourne n-thun nombre non palindromique (basé sur 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;}

Testez-le sur Ideone!

C'est un code assez trivial, donc il y a probablement de la place pour des améliorations.

Rubis, 54 octets

Cette fonction est indexée 1 et est partiellement basée sur la réponse Javascript de Dom Hastings . Je pense qu'il y a un moyen de mieux jouer au golf, surtout avec cette dernière condition ternaire. De plus, cette fonction retourne actuellement une chaîne, qui devra peut-être être modifiée ultérieurement. Toutes les suggestions de golf sont les bienvenues.

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

Non golfé:

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 octets

Il est basé sur 1 et l'algorithme est vraiment naïf

#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 caractères

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

c'est la fonction v; "⍎⌽⍕" r traslate nombre r dans la chaîne, inversez cette chaîne, traslate de chaîne en nombre. Fonctions de test et d'aide:

  ⍝ 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

Husk , 6 octets

Ouais pour ↔:)

!fS≠↔N

Essayez-le en ligne!

Explication

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

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

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

Essayez-le en ligne!

C # 7, 89 octets

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

1 indexé 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

Je ne pense pas que cela utilise des fonctionnalités de langage de c # 7, mais je l'ai mis car c'est ce que j'ai testé

Japt , 14 12 11 10 9 octets

1 indexé

@UµX¦sw}f

Essayez-le

Java 8, 117 95 94 octets

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

0 indexé

Explication:

Essayez-le ici.

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 octets

?>!~<>;i;'T

Essayez-le en ligne!

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