Деякі числа, наприклад, , є паліндромами основи 10: якщо ви пишете цифри у зворотному порядку, ви отримуєте те саме число.$14241$

Деякі числа є сумою 2 паліндром; наприклад, , або .$110=88+22$$2380=939+1441$

Для інших чисел 2 паліндроми недостатньо; наприклад, 21 не можна записати як суму 2 паліндром, і найкраще, що ви можете зробити, це 3: .$21=11+9+1$

Напишіть функцію або програму, яка приймає цілі введення nта виводить nчисло, яке не можна розкласти як суму 2 паліндромів. Це відповідає OEIS A035137 .

Одноцифрові цифри (включаючи 0) - паліндроми.

Застосовуються стандартні правила для послідовностей:

• вхід / вихід гнучки
• ви можете використовувати 0- або 1- індексацію
• Ви можете вивести цей nтермін, або перші nумови, або нескінченну послідовність

(Як сторонне позначення: всі цілі числа можуть бути розкладені як сума щонайменше 3 паліндром.)

Тестові приклади (1-індексований):

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

Це код-гольф, тому найкоротша відповідь виграє.

JavaScript (ES6),  93 83 80  79 байт

Збережено 1 байт завдяки @tsh

Повертає ^й термін, 1-індексований.$n$

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

Спробуйте в Інтернеті!

Як?

З огляду на $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 байт

-1 байт завдяки Еріку Переможнику . Виводить перші $n$ доданків.

2_ŒḂƇ⁺ṆƲ#

Спробуйте в Інтернеті!

Я намагався придумати іншу ідею порівняно зі своїм оригінальним підходом. Давайте розглянемо процес мислення:

• Спочатку тест працював наступним чином: він генерував цілі розділи цього числа, потім відфільтрував ті, що також містили непаліндри, а потім підрахував, скільки списків, які мають відповідність довжині 2. Це, очевидно, не надто ефективно з точки зору довжини коду.

• Генерування цілих розділів $N$ і потім фільтрація мали 2 основні недоліки: тривалість та ефективність у часі. Щоб вирішити цю проблему, я подумав, що спершу придумаю метод для генерування лише пар цілих чисел $(x, y)$ що дорівнюють $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]
     ⁺ - Скопіюйте попереднє посилання (подумайте про це, ніби було додаткове ŒḂƇ
            замість ⁺). Це лише зберігає паліндроми у цьому списку.
            Якщо список не порожній, то це означає, що ми знайшли пару (x, Nx)
            містить два паліндроми (і, очевидно, x + Nx = N, тому вони дорівнюють N).
      Ṇ - логічний НЕ (ми шукаємо цілі числа, для яких цей список порожній).
       Ʋ - Згрупуйте останні 4 ланки (в основному змушуйте _ŒḂƇ⁺Ṇ діяти як одна монада).

^{* Будь-які інші ненульові цифри з цього питання працюють.}

Желе , 11 байт

⁵ŻŒḂ€aṚ$EƲ#

Спробуйте в Інтернеті!

Повна програма приблизно працює так:

1. Встановіть z на вхід.
2. Набір х до 10 .
3. Встановіть R на [] .
4. Для кожного цілого k від 0 до і включає x , перевірте, чи обидва k і x - k є паліндромними.
5. Якщо всі елементи L рівні (тобто якщо будь-які всі можливі пари, що дорівнюють x, мають обидва їх елементи паліндромні, або всі такі пари мають щонайменше один з їх елементів бути паліндромними), встановіть z до z - 1 і додайте x для R .
6. Якщо z = 0 , поверніть R і закінчіть.
7. Встановіть х на х + 1 .
8. Перейдіть до кроку 4.

Ви можете підозрювати, що крок 5 насправді не виконує належну роботу. Нам дійсно не слід декремент z, якщо всі пари, що дорівнюють x , паліндромні. Однак ми можемо довести, що цього ніколи не станеться:

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

Повторіть, поки існує принаймні одна пара, що містить два паліндромні цілі числа.

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 байт

-3 байти завдяки @NahuelFouilleul

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

Спробуйте в Інтернеті!

Примітка: anyможе бути замінено grepі уникнути -Mперемикання командного рядка, але згідно з поточними правилами балів, це коштувало б ще одного байта.

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.&>:)^:_)&>:)^:[~]

Спробуйте в Інтернеті!

Пов'язана версія додає 3 байти на загальну кількість 60, щоб зберегти як функцію, яку колонтитул може викликати.

У системі 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è

-3 байти завдяки @Grimy .

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]

Спробуйте в Інтернеті!

Повертає n-й термін, 1-індексований

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

Що таке слово для розриву петлі? Здається, це ": піти", правда? {k≡⌽k←⍕⍵}в p - тест на паліндром. Ця вище функція в циклі зберігає весь паліндром, знайдений у множині P, якщо для якогось елемента w P є такий, що 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