などの一部の数字は、10を底とする回文です。数字を逆の順序で書くと、同じ数字になります。$14241$

いくつかの数字は2つの回文の合計です。たとえば、、またはです。$110=88+22$$2380=939+1441$

他の数字では、2回の回文では不十分です。たとえば、21は2回の回文の合計として書くことはできず、できる最善の方法はです。$21=11+9+1$

整数入力nを受け取り、n2つの回文の合計として分解できないth数を出力する関数またはプログラムを作成します。これは、OEIS A035137に対応しています。

1桁（0を含む）は回文です。

シーケンスの標準ルールが適用されます。

• 入出力は柔軟です
• 0インデックスまたは1インデックスを使用できます
• n番目の項、最初のn項、または無限シーケンスを出力できます

（補足：すべての整数は、最大3つのパリンドロームの合計として分解できます。）

テストケース（1-indexed）：

1 -> 21
2 -> 32
10 -> 1031
16 -> 1061
40 -> 1103

これはコードゴルフなので、最短の答えが勝ちです。

JavaScript（ES6）、 93 83 80  79バイト

@tshのおかげで1バイト節約

1 ^番目のインデックスが付けられた^番目の用語を返します。$n$

i=>eval("for(n=k=1;k=(a=[...k+[n-k]+k])+''!=a.reverse()?k-1||--i&&++n:++n;);n")

オンラインでお試しください！

どうやって？

与えられた、と両方が回文であるようなが存在するかどうかをテストします。このようなaが見つかった場合、は2つの回文の合計です。$n$$1\le k\le n$$k$$n-k$$k$$n$

ここでのコツは、、、および連結からなる単一の文字列をテストすることにより、とを同時に処理することです。$k$$n-k$$k$$n-k$$k$

例：

用：$n=2380$

• 最終的におよびに到達します$k=1441$$n-k=939$
• 文字列 " " をテストし、それが回文であることがわかります$1441\color{red}{939}1441$

コメント済み

注意：これはeval()読みやすさのないバージョンです。

i => {                       // i = index of requested term (1-based)
  for(                       // for loop:
    n = k = 1;               //   start with n = k = 1
    k =                      //   update k:
      ( a =                  //     split and save in a[] ...
        [...k + [n - k] + k] //     ... the concatenation of k, n-k and k
      ) + ''                 //     coerce it back to a string
      != a.reverse() ?       //     if it's different from a[] reversed:
        k - 1                //       decrement k; if the result is zero:
          || --i             //         decrement i; if the result is not zero:
            && ++n           //           increment n (and update k to n)
                             //         (otherwise, exit the for loop)
      :                      //     else:
        ++n;                 //       increment n (and update k to n)
  );                         // end of for
  return n                   // n is the requested term; return it
}                            //

ゼリー、 16 10  9バイト

Erik the Outgolferのおかげで-1バイト。最初の$n$項を出力します。

2_ŒḂƇ⁺ṆƲ#

オンラインでお試しください！

元のアプローチとは異なるアイデアを思いついた。思考プロセスを見てみましょう。

• 最初に、テストは次のように機能しました。その数の整数パーティションを生成し、非回文を含むパーティションをフィルターで除外し、長さ2の適格なリストの数をカウントしました。これは明らかに、コード長の点であまり効率的ではありませんでした。

• $N$の整数パーティションを生成してからフィルタリングすることには、長さと時間の効率という2つの主な欠点がありました。その問題を解決するために、私は最初に両方の数がパリンドロームでなければならないという条件で、N（すべての任意の長さのリストではない）に合計する整数のペア（x 、y ）のみを生成する方法を考え出すと思った。$(x, y)$$N$

• しかし、それでも、私はこれを行う「古典的な方法」に満足していませんでした。アプローチを切り替えました。ペアを生成する代わりに、プログラムで個々の回文に焦点を当てましょう。この方法で、Nより下のすべての回文$x$簡単に計算でき、N − xも回文である場合は、これで完了です。$N$$N-x$

コードの説明

2_ŒḂƇ⁺ṆƲ＃–モナドリンクまたはフルプログラム。引数：n。
2＃– 2 *から始まり、次の条件を満たす最初のn個の整数を見つけます...
 _ŒḂƇ⁺ṆƲ– ...ヘルパーリンク。内訳（現在の整数Nを呼び出す）：
    Ƈ–フィルター。範囲[1 ... N]を作成し、その範囲のみを保持します...
  ŒḂ– ...は回文です。例：21-> [1,2,3,4,5,6,7,8,9,11]
 _ –これらのパリンドロームのそれぞれをNから減算します。例：21-> [20,19、...、12,10]
     ⁺–前のリンクを複製します（追加のthereがあるかのように考えます）
            instead）の代わりに。これは、このリストに回文を保持するだけです。
            リストが空でない場合、それはペア（x、Nx）が見つかったことを意味します
            2つのパリンドロームが含まれています（そして明らかにx + Nx = Nなので、合計はNになります）。
      Ṇ–論理否定（このリストが空の整数を探しています）。
       Ʋ–最後の4つのリンクをグループ化します（基本的に_ŒḂƇ⁺Ṇを単一のモナドとして機能させます）。

^{*それ以外のゼロ以外の数字は動作します。}

ゼリー、11バイト

⁵ŻŒḂ€aṚ$EƲ#

オンラインでお試しください！

完全なプログラムはおおよそ次のように機能します。

1. 入力にzを設定します。
2. xを10に設定します。
3. Rを[]に設定します。
4. 0からxまでのすべての整数kについて、kとx-kの両方が回文的かどうかを確認します。
5. Lのすべての要素が等しい場合（つまり、xに合計されるすべてのペアの要素が両方とも回文的であるか、そのようなペアの要素のいずれか1つだけが回文的である場合）、zをz-1に設定してxを追加しますR。
6. z = 0の場合、Rを返して終了します。
7. xをx + 1に設定します。
8. 手順4に進みます。

ステップ5が実際にすべき仕事をしていないと思われるかもしれません。xに合計するすべてのペアがパリンドロームである場合、zを実際に減らすべきではありません。ただし、これは決して起こらないことを証明できます。

$k$$10\le k\le x$

$k$$(k,x-k)$$k+(x-k)=x$

$k$$k-1$$k$$D_F$$D_L$$k$$D_F=D_L>0$$k-1$$D'_F$$D'_L$$D_L>0$$D'_L=D'_F-1\ne D'_F$$k-1$$(k-1,x-(k-1))$$(k-1)+(x-(k-1))=k-1+x-k+1=x$

我々は設定で始まる場合、その結論をxと比べて値の大きいまたはに等しい10、我々はに加算することを非負整数のすべてのペアを持つことはできませんxは回文のペアも。

網膜、135 102バイト

K`0
"$+"{0L$`\d+
*__
L$`
<$.'>$.`>
/<((.)*.?(?<-2>\2)*(?(2)$)>){2}/{0L$`\d+
*__
))L$`
<$.'>$.`>
0L`\d+

オンラインでお試しください！n10を超えて遅すぎる。説明：

K`0

0を試すことから始めます。

"$+"{

繰り返しnます。

0L$`\d+
*__

現在のトライアル値を単項に変換し、インクリメントします。

L$`
<$.'>$.`>

合計が新しい試行値になる非負整数のすべてのペアを作成します。

/<((.)*.?(?<-2>\2)*(?(2)$)>){2}/{

2つのパリンドローム整数を含むペアが少なくとも1つ存在する間に繰り返します。

0L$`\d+
*__
))L$`
<$.'>$.`>

試用版の値をもう一度増やしてください。

0L`\d+

最終値を抽出します。

Haskell、68 67 63バイト

[n|n<-[1..],and[p a||p(n-a)|a<-[0..n]]]
p=((/=)=<<reverse).show

無限シーケンスを返します。

nいずれかaまたはn-aすべての回文ではないすべてを収集しますa <- [0..n]。

オンラインでお試しください！

Perl 5の -MList::Util=any -p、59の 55バイト

@NahuelFouilleulのおかげで-3バイト

++$\while(any{$\-reverse($\-$_)==reverse}0..$\)||--$_}{

オンラインでお試しください！

注：コマンドラインスイッチにany置き換えてgrep回避できます-Mが、現在のスコアリングルールでは、1バイト余分にコストがかかります。

R、115 111バイト

-4ジュゼッペのおかげ

function(n,r=0:(n*1e3))r[!r%in%outer(p<-r[Map(Reduce,c(x<-paste0),Map(rev,strsplit(a<-x(r),"")))==a],p,'+')][n]

オンラインでお試しください！

ほとんどの作業は関数の引数にまとめられており{}、複数ステートメントの関数呼び出しを削除し、オブジェクトの定義に必要な括弧を減らしていますr

基本的な戦略は、与えられた境界（0を含む）までのすべての回文を見つけ、すべてのペアワイズ和を見つけ、その出力にないn番目の数を取得することです。

の境界はn*1000、経験に基づいた推測から純粋に選択されたので、有効な選択肢としてそれを証明/反証する人をお勧めします。

r=0:(n*1e3)おそらくより効率的な範囲で改善できます。

Map(paste,Map(rev,strsplit(a,"")),collapse="")ここでマークの答えから引き裂かれ、信じられないほど賢いです。

r[!r%in%outer(p,p,'+')][n]私には少し非効率的です。

C＃（Visual C＃Interactive Compiler）、124バイト

n=>{int a=0;for(string m;n>0;)if(Enumerable.Range(0,++a).All(x=>!(m=x+""+(a-x)+x).Reverse().SequenceEqual(m)))n--;return a;}

オンラインでお試しください！

J、57/60バイト

0(](>:^:(1&e.p e.]-p=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)^:[~]

オンラインでお試しください！

リンクバージョンは、フッターが呼び出すことができる関数として保存するために、合計60の3バイトを追加します。

REPLでは、これを直接呼び出すことで回避できます。

   0(](>:^:(1 e.q e.]-q=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)^:[~] 1 2 10 16 40
21 32 1031 1061 1103

説明

一般的な構造は、Milesの回答によるこの手法の構造です。

(s(]f)^:[~]) n
          ]  Gets n
 s           The first value in the sequence
         ~   Commute the argument order, n is LHS and s is RHS
        [    Gets n
      ^:     Nest n times with an initial argument s
  (]f)         Compute f s
         Returns (f^n) s

これにより、元のループテクニックよりも数バイト節約できましたが、コア関数はJを記述する最初の試みであるため、多くの改善が可能です。

0(](>:^:(1&e.p e.]-p=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)^:[~]
0(]                                                 ^:[~] NB. Zero as the first term switches to one-indexing and saves a byte.
   (>:^:(1&e.p e.]-p=:(#~(-:|.)&":&>)&i.&>:)^:_)&>:)      NB. Monolithic step function.
                                                 >:       NB. Increment to skip current value.
   (>:^: <predicate>                        ^:_)          NB. Increment current value as long as predicate holds.
                   p=:(#~(-:|.)&":&>)&i.&>:               NB. Reused: get palindromes in range [0,current value].
                       #~(-:|.)&":&>                      NB. Coerce to strings keeping those that match their reverse.
                 ]-p                                      NB. Subtract all palindromes in range [0,current value] from current value.
    >:^:(1&e.p e.]-p                                      NB. Increment if at least one of these differences is itself a palindrome.

05AB1E、15 12 バイト

°ÝDʒÂQ}ãOKIè

@Grimyのおかげで-3バイト。

0インデックス付き。
非常に遅いため、ほとんどのテストケースでタイムアウトします。

オンラインそれを試してみてくださいまたは除去することにより、最初のいくつかの例を確認しますIè。

以前の15バイトバージョンよりずっと高速：

µNÐLʒÂQ}-ʒÂQ}g_

1インデックス付き。

$n$

説明：

°Ý              # Create a list in the range [0, 10**input]
  D             # Duplicate this list
   ʒÂQ}         # Filter it to only keep palindromes
       ã        # Take the cartesian product with itself to create all possible pairs
        O       # Sum each pair
         K      # Remove all of these sums from the list we duplicated
          Iè    # Index the input-integer into it
                # (after which the result is output implicitly)

µ               # Loop until the counter variable is equal to the (implicit) input-integer
 NÐ             #  Push the loop-index three times
   L            #  Create a list in the range [1, N] with the last copy
    ʒÂQ}        #  Filter it to only keep palindromes
        -       #  Subtract each from N
         ʒÂQ}   #  Filter it again by palindromes
             g_ #  Check if the list is empty
                #   (and if it's truthy: increase the counter variable by 1 implicitly)
                # (after the loop: output the loop-index we triplicated implicitly as result)

赤、142バイト

func[n][i: 1 until[i: i + 1 r: on repeat k i[if all[(to""k)= reverse
to""k(s: to""i - k)= reverse copy s][r: off break]]if r[n: n - 1]n < 1]i]

オンラインでお試しください！

1番目のインデックスが付けられたn番目の項を返します

Python 3、107バイト

p=lambda n:str(n)!=str(n)[::-1]
def f(n):
 m=1
 while n:m+=1;n-=all(p(k)+p(m-k)for k in range(m))
 return m

オンラインでお試しください！

回文チェックを反転すると、2バイト節約されました:)

参照用に、単純な正のチェック（109バイト）：

p=lambda n:str(n)==str(n)[::-1]
def f(n):
 m=1
 while n:m+=1;n-=1-any(p(k)*p(m-k)for k in range(m))
 return m

APL（NARS）、486バイト

r←f w;p;i;c;P;m;j
p←{k≡⌽k←⍕⍵}⋄i←c←0⋄P←r←⍬
:while c<w
    i+←1
    :if   p i⋄P←P,i⋄:continue⋄:endif
    m←≢P⋄j←1
    :while j≤m
         :if 1=p i-j⊃P⋄:leave⋄:endif
         j+←1
    :endwhile
    :if j=m+1⋄c+←1⋄r←i⋄:endif
:endwhile

ループを破るという言葉は何ですか？「：leave」だそうですよね？ {k≡⌽k←⍕⍵}in pは回文の検査です。ループ内のこの上記の関数は、セットPで見つかったすべての回文を格納します。Pの一部の要素wがiwがPにもある場合、これはiが正しくなく、インクリメントiがあることを意味します。結果：

  f 1
21
  f 2
32
  f 10
1031
  f 16
1061
  f 40
1103
  f 1000
4966
  f 1500
7536