gibi bazı sayılar, 10 tabanındaki palindromlardır: sayıları ters sırada yazarsanız aynı sayıyı alırsınız.$14241$

Bazı sayılar 2 palindromun toplamıdır; örneğin, veya .$110=88+22$$2380=939+1441$

Diğer numaralar için 2 palindrom yeterli değildir; örneğin, 21, 2 palindromun toplamı olarak yazılamaz ve yapabileceğiniz en iyi şey 3: .$21=11+9+1$

Tamsayı girişi alan nve n2 palindromun toplamı olarak ayrıştırılamayan th sayısını veren bir fonksiyon veya program yazın . Bu, OEIS A035137'ye karşılık gelir .

Tek rakam (0 dahil) palindrom'dur.

Diziler için standart kurallar geçerlidir:

• giriş / çıkış esnek
• 0- veya 1- indeksleme kullanabilirsiniz
• çıkış olabilir ninci terimi, ya da ilk nterim, ya da sonsuz bir dizi

(Bir yazı tipi olarak: tüm tam sayılar en fazla 3 palindromun toplamı olarak ayrıştırılabilir .)

Test durumları (1 indeksli):

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

Bu kod golf, bu yüzden en kısa cevap kazanır.

JavaScript (ES6),  93 83 80  79 bayt

@Tsh sayesinde 1 bayt kaydedildi

İade ^inci terim, 1-endekslendi.$n$

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

Çevrimiçi deneyin!

Nasıl?

Verilen , orada olup olmadığını test etmek herhangi böyle de o ve palindromes bulunmaktadır. Eğer böyle bir bulursak , o zaman iki palindromun toplamıdır.$n$$1\le k\le n$$k$$n-k$$k$$n$

Buradaki hile , , ve birleştirilmesinden yapılan tek bir dizgiyi test ederek aynı anda ve .$k$$n-k$$k$$n-k$$k$

Örnek:

İçin :$n=2380$

• sonunda ve$k=1441$$n-k=939$
• " " dizesini test ediyoruz ve bunun bir palindrom olduğunu öğrendik$1441\color{red}{939}1441$

Yorumlananlar

Not: Bu eval()okunabilirlik olmadan bir sürümüdür .

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

Jöle ,  16 10  9 bayt

Outgolfer Erik sayesinde -1 bayt . İlk terimini çıkarır.$n$

2_ŒḂƇ⁺ṆƲ#

Çevrimiçi deneyin!

Orijinal yaklaşımımla karşılaştırıldığında farklı bir fikir bulmaya çalıştım. Düşünme sürecini gözden geçirelim:

• İlk olarak, test şu şekilde çalıştı: Bu sayının tamsayı bölümlerini oluşturdu, sonra palindrom içermeyenleri süzüldü, daha sonra kaç tane uzunluk-2 uygun listenin olduğunu saydı. Bu açıkça kod uzunluğu açısından verimli değildi.

• tamsayı bölümlerini oluşturmak ve sonra filtrelemek 2 ana dezavantaja sahipti: uzunluk ve zaman verimliliği. Bu sorunu çözmek için, bir ilk oluşturmak için bir yöntem ile girer düşünce sadece tamsayılar çiftleri bu miktar her iki numara palindrom olmak şartıyla ile (tüm rasgele uzunlukta listeleri).$N$( x , y ) N$(x, y)$$N$

• Ama yine de, bu konuda "klasik yoldan" memnun değildim. Yaklaşımları değiştirdim: çift üretmek yerine , programı bireysel palindromlara odaklayalım . Bu şekilde, bir kişi altındaki tüm palindrom'larını hesaplayabilir ve aynı zamanda palindrom ise, o zaman tamamlanır.$x$$N$$N-x$

Kod Açıklaması

2_ŒḂƇ⁺ṆƲ # - Monadic bağlantı veya Tam program. Tartışma: n.
2 # - 2 * 'den başlayarak, tatmin edici ilk n tam sayılarını bulun ...
 _ŒḂƇ⁺ṆƲ - ... yardımcı bağlantı. Arıza (mevcut tamsayıyı N çağır)
    Filter - Filtre. Menzili yaratır [1 ... N] ve sadece ...
  ŒḂ - ... palindromlardır. Örnek: 21 -> [1,2,3,4,5,6,7,8,9,11]
 _ - Bu palindromların her birini N'den çıkarın. Örnek: 21 -> [20,19, ..., 12,10]
     Link - Önceki bağlantıyı çoğalt (başka bir ek varmış gibi düşün)
            yerine ⁺). Bu sadece palindromları bu listede tutar.
            Liste boş değilse, o zaman bu bir çift bulduk demektir (x, Nx)
            iki palindrom içerir (ve tabii ki x + Nx = N, bu yüzden N'ye gelirler).
      NOT - Mantıksal DEĞİL (bu listenin boş olduğu tam sayıları arıyoruz).
       4 - Son 4 bağı grupla (temelde _ŒḂƇ⁺Ṇ tek bir monad olarak davranır).

^{* Herhangi bir sıfır olmayan rakam, bu konuda çalışır.}

Jöle , 11 bayt

⁵ŻŒḂ€aṚ$EƲ#

Çevrimiçi deneyin!

Tam program kabaca böyle çalışır:

1. Ayar z girişine.
2. Set x için 10 .
3. Ayar R için [] .
4. Her tamsayı için k den 0'a kadar ve dahil x hem olsun, çek k ve k - x palindromic bulunmaktadır.
5. Eğer L' nin bütün elementleri eşitse (yani, x'e eşit tüm muhtemel çiftlerin her ikisi de elementlerinin palindromikse veya bütün bu çiftlerin elementlerinden en fazla birinin palindromik olması durumunda), z ' yi z' ye ayarlayın ve x ekleyin için R .
6. Eğer z = 0 , geri dönüş , R ve sonunda.
7. Takım x için , x + 1 .
8. 4. adıma gidin.

5. adımda aslında yapması gereken işi yapmadığından şüphelenebilirsiniz. Biz gerektiği gerçekten eksiltme değil z tüm çiftleri için toplamı ki, eğer x palindromic bulunmaktadır. Ancak bunun asla gerçekleşmeyeceğini ispatlayabiliriz:

İlk bir tamsayı seçelim böylece . Bunu her zaman yapabiliriz, çünkü, 2. adımda, x'i 10 olarak başlatıyoruz .$k$$10\le k\le x$

Eğer bir palindrom değilse, o zaman çiftimiz ; burada , bu nedenle tüm çiftlerin iki palindromu yoktur.$k$$(k,x-k)$$k+(x-k)=x$

Öte yandan, bir palindrom ise, o zaman bir palindrom olmadığını kanıtlayabiliriz . İlk ve son rakam Let olmak ve sırasıyla. Yana bir palindrom olduğu . İlk ve son rakamları Let be ve sırasıyla. beri , . Bu nedenle, bir palindrom değildir ve çiftine sahibiz , burada .$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$

Biz ayarı ile başlarsak Biz sonucuna x daha büyük bir değere kadar veya eşit 10'a , biz toplamı o negatif olmayan tamsayılar tüm çiftleri var olamaz x palindrom çifti olun.

Retina , 135 102 bayt

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

Çevrimiçi deneyin! n10 ya da daha fazlası için çok yavaş . Açıklama:

K`0

0'ı deneyerek başlayın.

"$+"{

Tekrarlayın n.

0L$`\d+
*__

Mevcut deneme değerini unary'e dönüştürün ve arttırın.

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

Yeni deneme değerini özetleyen tüm negatif olmayan tam sayı çiftlerini oluşturun.

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

İki palindromik tamsayı içeren en az bir çift varken tekrarlayın.

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

Deneme değerini tekrar artırın ve genişletin.

0L`\d+

Son değeri çıkarın.

Haskell, 68 67 63 bayt

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

Sonsuz bir dizi döndürür.

Herkesi toplayın nya ada n-aherkes için bir palindrome değil a <- [0..n].

Çevrimiçi deneyin!

Perl 5 -MList::Util=any -p , 59 55 bayt

@NahuelFouilleul sayesinde -3 bayt

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

Çevrimiçi deneyin!

Not: komut satırı anahtarının anyyerini alabilir grepve önleyebiliriz -M, ancak geçerli puanlama kuralları uyarınca, bu bir byte'a mal olur.

R , 115 111 bayt

-4, Giuseppe sayesinde

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]

Çevrimiçi deneyin!

Çalışmanın çoğu, {}çok ifadeli bir işlev çağrısını kaldırmak ve nesneyi tanımlamak için gereken parantezleri azaltmak için işlev argümanlarına paketlenir.r

Temel strateji, belirli bir sınırlamaya kadar (0 dahil) tüm palindromları bulmak, tüm çift toplamları bulmak ve sonra o çıktıda olmayan n.

Sınırı n*1000Ben geçerli bir seçenek olarak çürütmek / herkes edildiğinin ispatı teşvik böylece, eğitimli bir tahmininden tamamen seçildi.

r=0:(n*1e3)muhtemelen daha verimli bir ciltleme ile iyileştirilebilir.

Map(paste,Map(rev,strsplit(a,"")),collapse="")Burada Mark'ın cevabından yırtık ve bana inanılmaz zekice.

r[!r%in%outer(p,p,'+')][n]bana biraz verimsiz okuyor.

C # (Visual C # Etkileşimli Derleyici) , 124 bayt

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

Çevrimiçi deneyin!

J , 57/60 bayt

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

Çevrimiçi deneyin!

Bağlantılı sürüm, altbilginin arayabileceği bir işlev olarak kaydetmek için toplamda 60 bayt ekler.

REPL'de doğrudan arayarak bu önlenir:

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

açıklama

Genel yapısı, bir gelen bu tekniğin olmasıdır cevap tarafından 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

Bu, orijinal döngü tekniğimin bir kaç baytını kurtardı, ancak çekirdek işlevi J yazma konusundaki ilk girişimim olduğundan, hala geliştirilebilecek çok şey var.

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 bayt

°ÝDʒÂQ}ãOKIè

@Grimy sayesinde -3 bayt .

0 endeksli.
Çok yavaş, bu yüzden çoğu test vakası için zaman aşımına uğradı.

Çevrimiçi deneyin veya ilk birkaç vakayı kaldırarak doğrulayınIè .

Çok daha hızlı önceki 15 byter sürümü:

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

1 endeksli.

$n$

Açıklama:

°Ý              # 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)

Kırmızı , 142 bayt

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]

Çevrimiçi deneyin!

N-terim, 1 dizeli

Python 3 , 107 bayt

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

Çevrimiçi deneyin!

Palindrom kontrolünü ters çevirme 2 bayt kaydetti :)

Düz ileri pozitif kontrol referansı için (109 bayt):

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 bayt

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

Döngü kırmak için kelime nedir? Görünüşe göre ": ayrılmak", değil mi? {k≡⌽k←⍕⍵}p, palindrom için yapılan testtir. Döngüdeki bu yukarıdaki işlev, P kümesindeki tüm palindromu depolar, eğer P'nin w bir elemanı için iw de P ise öyledir, bu i'nin doğru olmadığı ve i artışının olduğu anlamına gelir. Sonuçlar:

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