每一个正整数，可表示为最多三个回文正整数中的任何基础的总和b ≥5。   Cilleruelo等，2017

如果正整数在给定的基数中为回文，则该正整数在该基数中的表示（不带前导零）将向后读取相同的值。在下面，仅基b = 10将被考虑。

作为回文数之和的分解不是唯一的。例如，5可以直接表示为5或2, 3。类似地，132可以分解为44, 44, 44或121, 11。

挑战

给定一个正整数，将其和分解为三个或三个以下以正整数为基础的正整数。

附加规则

• 所使用的算法应适用于任意大的输入。但是，如果程序受内存，时间或数据类型的限制，则可以接受。

• 输入和输出可以通过任何合理的方式进行。输入和输出格式像往常一样灵活。

• 您可以选择为每个输入生成一个或多个有效分解，只要输出格式是明确的即可。

• 允许使用任何编程语言编写程序或功能。禁止出现标准漏洞。

• 以字节为单位的最短代码获胜。

例子

由于输入可以具有许多分解，因此这些只是示例而不是测试用例。每种分解显示在不同的行上。

Input  ->  Output

5     ->   5
           2, 3

15    ->   1, 3, 11
           9, 6

21    ->   11, 9, 1
           7, 7, 7

42    ->   22, 11, 9
           2, 7, 33

132   ->   44, 44, 44
           121, 11

345   ->   202, 44, 99
           2, 343

1022  ->   989, 33
           999, 22, 1

9265  ->   9229, 33, 3
           8338, 828, 99

Brachylog，7个字节

~+ℕᵐ.↔ᵐ

在线尝试！

出人意料的不是那么慢。

说明

(?)~+  .          Output is equal to the Input when summed
     ℕᵐ.          Each element of the Output is a positive integer
       .↔ᵐ(.)     When reversing each element of the Output, we get the Output

Python 2中，82 79个字节

f=lambda n:min([f(n-k)+[k]for k in range(1,n+1)if`k`==`k`[::-1]]or[[]],key=len)

在线尝试！

果冻，12 10 9 8字节

ŒṗDfU$ṪḌ

在线尝试！

这个怎么运作

ŒṗDfU$ṪḌ  Main link. Argument: n (integer)

Œṗ        Find all integer partitions of n.
  D       Convert each integer in each partition to base 10.
     $    Combine the two links to the left into a chain.
    U     Upend; reverse all arrays of decimal digits.
   f      Filter the original array by the upended one.
      Ṫ   Take the last element of the filtered array.
          This selects  the lexicographically smallest decomposition of those with
          the minimal amount of palindromes.
       Ḍ  Undecimal; convert all arrays of decimal digits to integers.

Python 2，117个字节

def f(n):p=[x for x in range(n+1)if`x`==`x`[::-1]];print[filter(None,[a,b,n-a-b])for a in p for b in p if n-a-b in p]

在线尝试！

打印列表列表，每个列表都是一个解决方案。Rod节省了9个字节。

JavaScript（ES6），115 ... 84 83字节

始终返回一个三元素的数组，其中未使用的条目将用零填充。

f=(n,b=a=0)=>(r=[b,a%=n,n-a-b]).some(a=>a-[...a+''].reverse().join``)?f(n,b+!a++):r

测试用例

f=(n,b=a=0)=>(r=[b,a%=n,n-a-b]).some(a=>a-[...a+''].reverse().join``)?f(n,b+!a++):r

console.log(JSON.stringify(f(5)))
console.log(JSON.stringify(f(15)))
console.log(JSON.stringify(f(21)))
console.log(JSON.stringify(f(42)))
console.log(JSON.stringify(f(132)))
console.log(JSON.stringify(f(345)))
console.log(JSON.stringify(f(1022)))
console.log(JSON.stringify(f(9265)))

R，126字节145字节

感谢Giuseppe打高尔夫球19个字节

function(n){a=paste(y<-0:n)
x=combn(c(0,y[a==Map(paste,Map(rev,strsplit(a,"")),collapse="")]),3)
unique(x[,colSums(x)==n],,2)}

在线尝试！

说明

R没有逆向转换字符串的本机方法，许多默认字符串操作不适用于数字。因此，首先我们将一系列正整数（加0）转换为字符。

接下来，我们产生一个向量为0和所有回文。字符串反转需要将每个数字按字符分割，反转向量的顺序，然后将它们粘贴回无间隙。

接下来，我要检查所有三个一组（这里是0的重要位置），幸运的是R具有一个内置的组合函数，该函数返回一个矩阵，每列组合。

我应用 colSums函数应用于矩阵，并仅保留等于提供的目标的元素。

最后，因为有两个0，所以将复制两个正整数的任何集合，因此我在列上使用了唯一函数。

输出是一个矩阵，其中每一列是一组加总到目标值的正回文整数。它是惰性的，当使用少于3个元素时返回0。

果冻，14字节

L<4aŒḂ€Ạ
ŒṗÇÐf

在线尝试！

非常非常低效。

果冻，17个字节

RŒḂÐfṗ3R¤YS⁼³$$Ðf

在线尝试！

-6个字节，得益于HyperNeutrino。

全部输出。但是，输出包含一些重复项。

欧姆V2，13个 12 10字节

#Dð*3ç⁇Σ³E

在线尝试！

Mathematica，49个字节

#~IntegerPartitions~3~Select~AllTrue@PalindromeQ&

在线尝试！

返回所有解决方案

-2〜MartinEnder〜字节

Haskell，90 86 79字节

-7个字节感谢Laikoni！

f=filter
h n=[f(>0)t|t<-mapM(\_->f(((==)<*>reverse).show)[0..n])"123",sum t==n]

在线尝试！

返回带有重复的所有解决方案的列表。

Java（OpenJDK 8），185字节

n->{for(int i=0,j=n,k;++i<=--j;)if(p(i))for(k=0;k<=j-k;k++)if(p(k)&p(j-k))return new int[]{j-k,k,i};return n;}
boolean p(int n){return(""+n).equals(""+new StringBuffer(""+n).reverse());}

在线尝试！

从TIO中删除1个字节以获取正确的数量，因为提交内容中不包含;lambda之后的内容。

质子 117字节

a=>filter(l=>all(p==p[by-1]for p:map(str,l)),(k=[[i,a-i]for i:1..a-1])+sum([[[i,q,j-q]for q:1..j-1]for i,j:k],[]))[0]

在线尝试！

输出解决方案

Pyth， 16 12  10字节

ef_I#`MT./

在这里尝试！

这个怎么运作

ef_I＃`MT。/〜完整程序。

        ./〜整数分区。
 f〜使用变量T过滤。
     MT〜将T的每个元素映射到字符串表示形式。
    ＃〜筛选。
  _I〜回文吗？（即不变超过反向？）
e〜获取最后一个元素。

05AB1E，17个字节

LʒÂQ}U4GXNãDO¹QÏ=

在线尝试！

将结果输出到三个列表中，如下所示：

• 长度为1的回文列表（原始编号IFF是回文）。

• 长度为2的回文列表。

• 长度为3的回文列表。

公理，900字节

R(x)==>return x;p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)
b:List INT:=[];o:INT:=0
f(a:NNI):List INT==(free b,o;o:=p(-1,o);w:=0;c:=#b;if c>0 then w:=b.1;e:=a-o;e>10000000=>R[];if w<e then repeat(w:=p(1,w);w>e=>break;b:=cons(w,b));g:List INT:=[];for i in #b..1 by-1 repeat(b.i>e=>break;g:=cons(b.i,g));if o>e then g:=cons(o,g);n:=#g;for i in 1..n repeat(x:=g.i;x=a=>R[x];3*x<a=>break;for j in i..n repeat(y:=g.j;t:=x+y;t>a=>iterate;t=a=>R[x,y];t+y<a=>break;for k in j..n repeat(z:=t+g.k;z=a=>R[x,y,g.k];z<a=>break)));[])
D(a:NNI):List INT==(free o;p(0,a)=1=>[a];o:=a;for j in 1..10 repeat(t:=f(a);#t>0=>R t);[])

测试代码

--Lista random di n elmenti, casuali compresi tra "a" e "b"
randList(n:PI,a:INT,b:INT):List INT==
    r:List INT:=[]
    a>b =>r
    d:=1+b-a
    for i in 1..n repeat
          r:=concat(r,a+random(d)$INT)
    r

test()==
   a:=randList(20,1,12345678901234)
   [[i,D(i)] for i in a]

如果该代码必须分解1,2,3个回文中的数字X，那么它的作用是在回文N <X附近尝试并分解2个回文中的XN；如果XN的分解成功，则返回3个回文。如果失败，则尝试先前的回文G <N <X并尝试在2个回文中分解XG等。Ungolf代码（但可能有一些错误）

 R(x)==>return x

-- se 'r'=0 ritorna 1 se 'a' e' palindrome altrimenti ritorna 0
-- se 'r'>0 ritorna la prossima palindrome >'a'
-- se 'r'<0 ritorna la prossima palindrome <'a'
p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)

b:List INT:=[]   -- the list of palindrome
o:INT:=0         -- the start value for search the first is a

--Decompose 'a' in 1 or 2 or 3 palindrome beginning with prev palindrome of o
--if error or fail return []
f(a:NNI):List INT==
    free b,o
    -- aggiustamento di o, come palindrome piu' piccola di o
    o:=p(-1,o)
    -- aggiustamento di b come l'insieme delle palindromi tra 1..a-o compresa
    w:=0;c:=#b
    if c>0 then w:=b.1 --in w la massima palindrome presente in b
    e:=a-o
    output["e=",e,"w=",w,"o=",o,"#b=",#b]
    e>10000000=>R[]   --impongo che la palindrome massima e' 10000000-1
    if w<e then       --se w<a-o aggiungere a b tutte le palindromi tra w+1..a-o
          repeat(w:=p(1,w);w>e=>break;b:=cons(w,b))
                      -- g e' l'insieme dei b palindromi tra 1..a-o,o
    g:List INT:=[];for i in #b..1 by-1 repeat(b.i>e=>break;g:=cons(b.i,g))
    if o>e then g:=cons(o,g)
    --output["g=",g,b]
    n:=#g
    for i in 1..n repeat
        x:=g.i
        x=a  =>R[x]
        3*x<a=>break
        for j in i..n repeat
           y:=g.j;t:=x+y
           t>a   =>iterate
           t=a   =>R[x,y]
           t+y<a =>break
           for k in j..n repeat
                z:=t+g.k
                z=a =>R[x,y,g.k]
                z<a =>break
    []

--Decompose 'a' in 1 or 2 or 3 palindrome
--if error or fail return []
dPal(a:NNI):List INT==
   free o
   p(0,a)=1=>[a]
   o:=a                  -- at start it is o=a
   for j in 1..10 repeat -- try 10 start values only
        t:=f(a)
        #t>0=>R t
   []

结果：

(7) -> [[i,D(i)] for i in [5,15,21,42,132,345,1022,9265] ]
   (7)
   [[5,[5]], [15,[11,4]], [21,[11,9,1]], [42,[33,9]], [132,[131,1]],
    [345,[343,2]], [1022,[999,22,1]], [9265,[9229,33,3]]]
                                                      Type: List List Any
                                   Time: 0.02 (IN) + 0.02 (OT) = 0.03 sec
(8) -> test()
   (8)
   [[7497277417019,[7497276727947,624426,64646]],
    [11535896626131,[11535888853511,7738377,34243]],
    [2001104243257,[2001104011002,184481,47774]],
    [3218562606454,[3218561658123,927729,20602]],
    [6849377785598,[6849377739486,45254,858]],
    [375391595873,[375391193573,324423,77877]],
    [5358975936064,[5358975798535,136631,898]],
    [7167932760123,[7167932397617,324423,38083]],
    [11779002607051,[11779000097711,2420242,89098]],
    [320101573620,[320101101023,472274,323]],
    [5022244189542,[5022242422205,1766671,666]],
    [5182865851215,[5182864682815,1158511,9889]],
    [346627181013,[346626626643,485584,68786]],
    [9697093443342,[9697092907969,443344,92029]],
    [1885502599457,[1885502055881,542245,1331]], [10995589034484,[]],
    [1089930852241,[1089930399801,375573,76867]],
    [7614518487477,[7614518154167,246642,86668]],
    [11859876865045,[11859866895811,9968699,535]],
    [2309879870924,[2309879789032,81418,474]]]
                                                      Type: List List Any
      Time: 0.25 (IN) + 115.17 (EV) + 0.13 (OT) + 28.83 (GC) = 144.38 sec

Java（OpenJDK 8），605字节

打印伪造品，但不被禁止afaik

a->{int i=0,j,k,r[]=new int[a-1];for(;i<a-1;r[i]=++i);for(i=0;i<a-1;i++){if(r[i]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse()))System.out.println(r[i]);for(j=0;j<a-1;j++){if(r[i]+r[j]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse())&(""+r[j]).equals(""+new StringBuffer(""+r[j]).reverse()))System.out.println(r[i]+" "+r[j]);for(k=0;k<a-1;k++)if(r[i]+r[j]+r[k]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse())&(""+r[j]).equals(""+new StringBuffer(""+r[j]).reverse())&(""+r[k]).equals(""+new StringBuffer(""+r[k]).reverse()))System.out.println(r[i]+" "+r[j]+" "+r[k]);}}}

在线尝试！

APL（Dyalog），51字节

{w/⍨⍵=+/¨w←(,y∘.,z),,(z←,∘.,⍨y),y←,x/⍨(⌽≡⊢)¨⍕¨x←⍳⍵}

在线尝试！

05AB1E，8个字节

ÅœR.ΔDíQ

在线尝试！

说明：

Ŝ          # integer partitions of the input
  R         # reversed (puts the shortest ones first)
   .Δ       # find the first one that...
     D Q    # is equal to...
      í     # itself with each element reversed

Perl 6，51个字节

{first *.sum==$_,[X] 3 Rxx grep {$_ eq.flip},1..$_}

在线尝试！

• grep { $_ eq .flip }, 1 .. $_ 产生一个从1到输入数字的所有回文数的列表。
• 3 Rxx 复制该列表三次。
• [X]使用叉积运算符来减少列表的列表X，从而得到从1到输入数字的所有3个元组的palindrominc数字的列表。
• first *.sum == $_ 查找第一个这样的三元组，其总和为输入数字。

Python 3，106字节

lambda n:[(a,b,n-a-b)for a in range(n)for b in range(n)if all(f'{x}'==f'{x}'[::-1]for x in(a,b,n-a-b))][0]

在线尝试！

在TIO链接中，我使用了更快（但长1字节）的版本，它将第一个有效结果用作生成器，而不是构建可能组合的整个列表并采用第一个。

红宝石，84字节

建立从0到n的3个回文的所有可能组合的列表，找到第一个其总和匹配的，然后修剪零。

->n{a=(0..n).select{|x|x.to_s==x.to_s.reverse};a.product(a,a).find{|x|x.sum==n}-[0]}

在线尝试！

加++，62字节

D,g,@,BDdbR=
D,l,@@,$b+=
D,k,@@*,
L,RÞgdVBcB]Gd‽kdG‽k€bF++A$Þl

在线尝试！

撰写说明时，约有50个字节打高尔夫球。定义一个lambda函数，该函数返回包含解决方案的列表的列表。

这个怎么运作

$1, 2$$3$$1$$n$$n$

$1, 2, ..., n$gRÞgg$A$

下一节可以分为三个其他部分：

BcB]
Gd‽k
dG‽k€bF

$A$[1 2 3 4 ...][[1] [2] [3] [4] ... ]$A$k

D,k,@@*,

此功能基本上什么也不做。它接收两个参数并将它们包装在一个数组中。但是，快速上桌‽是这里的魔术。它需要两个列表，并在这两个列表之间生成每一对元素。所以[1 2 3]和[4 5 6]生成[[1 4] [1 5] [1 6] [2 4] [2 5] [2 6] [3 4] [3 5] [3 6]]。然后，它接受其函数参数（在这种情况下为k），并在每对上运行该函数，在这种情况下，仅按原样返回该对。

$A$€bF

$1, 2$$3$$n$l$n$