회문 번호 (모른 경우)는 앞뒤로 같은 숫자를 읽습니다 (예 : 11). 첫 번째 15 비 대칭 수는 다음과 같습니다 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26. 이것은 A029742 입니다. 나는 지속적 으로이 숫자가 필요하지만 스티커 메모 패드는 매우 작으므로 코드는 가능한 짧아야합니다.

규칙

• 각 제출은 전체 프로그램 또는 함수 여야합니다 (예 : C에서는 헤더없이 함수를 정의 할 수는 없지만 필요한 헤더로 함수를 정의 할 수 있음).
• 가능하면 프로그램을 테스트 할 수있는 사이트에 대한 링크를 제공하십시오.
• 프로그램은에 아무 것도 쓰지 않아야합니다 STDERR.
• 입력을 인수로 또는에서 STDIN(또는 언어에서 가장 가까운 대안으로) 취할 수 있습니다 .
• 프로그램은 바이트 에 따라 점수가 매겨 집니다. 일반적인 문자 세트는 UTF-8입니다. 다른 문자를 사용하는 경우 지정하십시오.
• 표준 허점 은 금지되어 있습니다.

테스트 사례

1
==> 10

-----

5
==> 15

-----

12
==> 23

채점

이것은 code-golf 이므로 바이트 수가 가장 적습니다.

제출물

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

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

헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

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

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

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

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

/* 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 바이트

e.f!_I`

테스트 스위트

설명:

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.

하스켈, 38 바이트

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

0부터 시작하는 인덱스를 사용합니다. ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11-> 23.

숫자를 유지할지 여부에 대한 테스트는로 (/=)<*>reverse$show x변환됩니다 (show x) /= (reverse (show x)). 즉, 숫자 의 문자열 표현이 문자열 표현의 반전과 같은지 확인합니다.

Brachylog , 14 11 바이트

;0{<≜.↔¬}ⁱ⁽

페이탈 라이즈 할 수있는 -3 바이트 탱크

설명

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

온라인으로 사용해보십시오!

젤리, 9 바이트

@ Sp3000 덕분에 1 바이트 .

ṚḌ_
0dz#Ṫ

온라인으로 사용해보십시오!

테스트 스위트.

설명

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 바이트

암호:

µNÂÂQ>i¼

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

클로저, 62 바이트

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

인덱스가 0입니다. 목록 이해를 사용하여 지연되지 않은 무한한 범위의 비회 문적 숫자를 생성하고 i하나를 취하십시오 . 온라인으로보십시오 : https://ideone.com/54wXI3

PowerShell v2 +, 65 바이트

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

입력 된 많은 일치 항목 을 찾을 때까지 ( 0초기화되지 않은 경우의 암시 적 값) 에서 숫자를 반복 한 다음 마지막 항목을 출력합니다. 루프를 초기화하지 않으므로 암시 적입니다.$i$args[0]$j=0

각 반복마다 우리는 사전 증분 $i하고 $i반대 가 아닌지 확인합니다 . 그렇다면, 우리는 회문이 아닌 것을 발견 했으므로 증가 $j합니다. 그런 다음 루프는 필요한만큼 계속됩니다.

예

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

파이썬 2, 60 바이트

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

nvia 인수를 입력 하고 n회문이 아닌 숫자를 반환 하는 1 개의 인덱스 함수입니다 .

작동 원리

이것은 회귀가 아닌 숫자가 발견 될 때까지 i범위의 정수를 연속적으로 테스트하는 철저한 재귀 검색입니다 . 이후 사전 증가, 후 반환됩니다. 숫자가 회문으로되어 있는지 테스트하는 것은 문자열로 변환하고 반전 한 다음 원래 문자열과 반전 된 문자열이 같은지 확인하여 수행됩니다.[1,∞)nii-1

코드는 논리적으로 다음과 같습니다.

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)

그 자체는 본질적으로 :

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

Ideone에서 사용해보십시오

클로저, 62 바이트

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

다른 답변과는 다른 접근법이지만 길이는 같습니다.

R , 133 117 93 76 바이트

JayCe 덕분에 -16 바이트 주세페 덕분에 -41 바이트.

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

온라인으로 사용해보십시오!

넷째 (gforth) , 103 99 바이트

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

온라인으로 사용해보십시오!

설명

n 번 반복합니다. 각 반복은 숫자가 자신과 반대가 될 때까지 카운터를 1 씩 증가시켜 다음과 같이 회문이 아닌 숫자를 찾습니다.

Ungolfed Code

일반적으로 코드를 "ungolf"하지는 않지만이 코드가 다소 지저분하므로 도움이 될 것이라고 생각했습니다.

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

코드 설명

: 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 

펄 6 , 29 바이트

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

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

용법:

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)

실제로 17 바이트

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

온라인으로 사용해보십시오!

값은 1 인덱스입니다. 첫 번째 R를 로 바꾸면 쉽게 색인이 0으로 변경 될 수 있습니다 r. 그러나 R처음에 입력 한 것이기 때문에 그와 함께합니다.

회문이 아닌 숫자는를 만족 a(n) ≈ n + 10하므로 2n+9충분한 상한입니다.

설명:

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

자바 스크립트 (ES6), 54 바이트

1 기반 인덱싱을 사용합니다. 7624 번째 숫자까지만 작동합니다.

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

용법

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

자바 스크립트 (ES6), 59 바이트

재귀를 사용하지 않으므로 훨씬 더 큰 입력을 처리 할 수 ​​있습니다.

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

용법

(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

자바 스크립트 (외부 라이브러리 사용) (97 바이트)

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

lib에 링크 : https://github.com/mvegh1/Enumerable

코드 설명 : 라이브러리에는 Sequence라는 정적 메서드가 있습니다. 여기서 첫 번째 param은 시퀀스 생성을 보장 할 요소 수를 정의하고 두 번째 매개 변수는 현재 반복 값 "i"를 허용하는 조건 자입니다. 술어는 정수를 문자열로 변환하고 _.From을 호출하여 char 배열로 변환합니다. char 배열은 char 배열의 반전과 비교되며, 같지 않으면 char 배열이 다시 문자열로 결합되어 반환됩니다. 그렇지 않으면 아무것도 반환되지 않습니다 (즉, 결과는 정의되지 않으므로 라이브러리는 항상 무시합니다). 마지막으로 시퀀스의 마지막 요소, 즉 N 번째 요소가 반환됩니다.

C, 84 바이트

함수 f(n)는 정수를 가져와 비 회문 숫자를 n반환합니다 n-th(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;}

Ideone에서 테스트하십시오 !

상당히 사소한 코드이므로 개선의 여지가 있습니다.

루비, 54 바이트

이 함수는 1- 색인이며 부분적으로 Dom Hastings의 Javascript answer를 기반으로 합니다. 나는 특히 마지막 삼항 조건에서 골프를 더 잘하는 방법이 있다고 생각합니다. 또한이 함수는 현재 문자열을 반환하며 나중에 편집해야 할 수도 있습니다. 모든 골프 제안은 환영합니다.

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

언 골프 드 :

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 바이트

1 기반이며 알고리즘은 정말 순진합니다.

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

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

v 함수입니다. "⍎⌽⍕"r 문자열에서 숫자 r을 traslate하고 해당 문자열을 뒤집고 문자열에서 숫자로 traslate합니다. 테스트 및 도움말 기능 :

  ⍝ 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

껍질 , 6 바이트

예 ↔:)

!fS≠↔N

온라인으로 사용해보십시오!

설명

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

Perl 5 , 33 + 1 ( -p) = 34 바이트

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

온라인으로 사용해보십시오!

C # 7, 89 바이트

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

1 인덱스 시도 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

나는 이것이 C # 7의 언어 기능을 사용하지 않는다고 생각하지만, 내가 테스트 한 것이기 때문에 거기에 넣었다.

Japt , 14 12 11 10 9 바이트

1- 색인

@UµX¦sw}f

시도 해봐

자바 8, 117 95 94 바이트

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

0 인덱스

설명:

여기에서 시도하십시오.

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 바이트

?>!~<>;i;'T

온라인으로 사용해보십시오!

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