모든 양의 정수는 b ≥5의 모든 b 에서 최대 3 개의 회문 양수의 합으로 표현할 수 있습니다 .   Cilleruelo et al., 2017

양의 정수는 앞에 0이없는 해당 염기의 표현이 같은 역으로 읽 히면 주어진 염기에서 회 문학 입니다. 다음에서는 b = 10 기준 만 고려됩니다.

회문 숫자의 합으로서 분해는 독특하지 않다 . 예를 들어로 5직접 5또는의 합계로 표현할 수 있습니다 2, 3. 마찬가지로 또는로 132분해 할 수 있습니다 .44, 44, 44121, 11

도전

양의 정수가 주어지면, 합 10을 밑수 10에서 회문 식인 3 개 이하의 양의 정수로 생성합니다.

추가 규칙

• 사용 된 알고리즘은 임의로 큰 입력에 작동해야합니다. 그러나 프로그램이 메모리, 시간 또는 데이터 유형 제한에 의해 제한되는 경우 허용됩니다.

• 입력 및 출력은 합리적인 방법 으로 수행 할 수 있습니다 . 입력 및 출력 형식은 평소처럼 유연합니다.

• 출력 형식이 명확하지 않은 한 각 입력에 대해 하나 이상의 유효한 분해를 생성하도록 선택할 수 있습니다.

• 모든 프로그래밍 언어의 프로그램 또는 기능 이 허용 됩니다 . 표준 허점 은 금지되어 있습니다.

• 바이트 단위의 최단 코드가 이깁니다.

예

입력에는 많은 분해가있을 수 있으므로 테스트 사례가 아닌 예제입니다. 각 분해는 다른 라인에 표시됩니다.

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

파이썬 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.

파이썬 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]

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

각 목록이 솔루션 인 목록 목록을 인쇄합니다. 로드가 9 바이트를 절약했습니다.

자바 스크립트 (ES6), 115 ... 84 83 바이트

사용하지 않는 항목은 0으로 채워지는 3 요소 배열을 항상 반환합니다.

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

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이 있기 때문에 두 개의 양의 정수 세트가 복제되므로 열에 고유 한 함수를 사용합니다.

출력은 각 열이 목표 값에 합한 양의 pallindromic 정수 세트 인 행렬입니다. 3 개보다 적은 요소가 사용되면 게으르고 0을 반환합니다.

젤리 , 14 바이트

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

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

매우, 매우 비효율적.

젤리 , 17 바이트

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

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

HyperNeutrino 덕분에 -6 바이트

모든 방법으로 출력합니다. 그러나 출력은 일부 중복으로 구성됩니다.

옴 v2 , 13 12 10 바이트

#Dð*3ç⁇Σ³E

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

매스 매 티카, 49 바이트

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

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

모든 솔루션을 반환

-2 ~ MartinEnder ~ 바이트

하스켈 , 90 86 79 바이트

Laikoni 덕분에 -7 바이트!

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 바이트를 제거하십시오 .

양성자 , 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 개를 발견하면; 실패하면 이전 palindrome G <N <X를 시도하고 2 개의 palindrome 등에서 XG를 분해하십시오. Ungolf code (그러나 버그가 발생할 수 있습니다)

 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

자바 (OpenJDK 8) 605 바이트

Dupe를 인쇄하지만 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

펄 6 , 51 바이트

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

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

• grep { $_ eq .flip }, 1 .. $_ 1에서 입력 번호까지 모든 회문 번호 목록을 생성합니다.
• 3 Rxx 이 목록을 세 번 복제합니다.
• [X]cross-product operator를 사용하여 해당 목록을 줄입니다 X. 결과적으로 1에서 입력 번호까지의 팔린 트로마 민 숫자의 3 개의 튜플 목록이 나타납니다.
• first *.sum == $_ 입력 번호에 해당하는 첫 번째 3 튜플을 찾습니다.

파이썬 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 개의 회 문의 가능한 모든 조합의 목록을 작성하고, 합계가 일치하는 첫 번째 회문을 찾은 다음 0을 제거합니다.

->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 바이트가 골프를 쳤다. 솔루션이 포함 된 목록 목록을 반환하는 람다 함수를 정의합니다.

작동 원리

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