दो पलिंड्रोम्स पर्याप्त नहीं हैं

Question

कुछ संख्याएं, जैसे कि , आधार 10 में palindromes हैं: यदि आप अंकों को रिवर्स ऑर्डर में लिखते हैं, तो आपको एक ही नंबर मिलता है।$14241$

कुछ संख्याएँ 2 पलिंड्रोम्स का योग हैं; उदाहरण के लिए, , या ।$110=88+22$$2380=939+1441$

अन्य संख्याओं के लिए, 2 पलिंड्रोम्स पर्याप्त नहीं हैं; उदाहरण के लिए, 21 को 2 तालिकाओं के योग के रूप में नहीं लिखा जा सकता है, और आप जो सबसे अच्छा कर सकते हैं वह है 3: ।$21=11+9+1$

एक फ़ंक्शन या प्रोग्राम लिखें जो पूर्णांक इनपुट लेता है nऔर nवें नंबर को आउटपुट करता है जिसे 2 palindromes के योग के रूप में विघटित नहीं किया जा सकता है। यह OEIS A035137 से मेल खाता है ।

एकल अंक (0 सहित) palindromes हैं।

अनुक्रम के लिए मानक नियम लागू होते हैं:

• इनपुट / आउटपुट लचीला है
• आप 0- या 1- इंडेक्सिंग का उपयोग कर सकते हैं
• आप nवें पद या पहले nशब्दों, या एक अनंत अनुक्रम का उत्पादन कर सकते हैं

(एक विचार के रूप में: सभी पूर्णांकों को अधिकतम 3 तालिकाओं के योग के रूप में विघटित किया जा सकता है ।)

परीक्षण के मामले (1-अनुक्रमित):

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

यह कोड-गोल्फ है, इसलिए सबसे छोटा उत्तर जीतता है।

Comments

अनंत आउटपुट भी दृश्यों के लिए एक मानक विकल्प नहीं है?

— असंबंधित स्ट्रिंग

@UnrelatedString हाँ, मैं इसे भी अनुमति दूंगा।

— रॉबिन राइडर

संबंधित

— लुइस मेंडो

@ एबिगेल ने सकारात्मक पूर्णांक को देखते हुए n, N- वें अनुक्रम OEIS का सदस्य प्रिंट किया? होनहार लगता है ...

— वैल का कहना है कि मोनिका

@Nit एक नए OEIS अनुक्रम को परिभाषित करते हैं a (n) = nth OEIS अनुक्रम जिसे उस अनुक्रम को उत्पन्न करने वाले सबसे अधिक गोल्फ वाले जेली फ़ंक्शन की तुलना में कम वर्णों में व्यक्त किया जा सकता है।

— agtoever

Answer 1

जावास्क्रिप्ट (ईएस 6),  93 83 80  79 बाइट्स

@ बाइट के लिए 1 बाइट का धन्यवाद सहेजा गया

$n$ ^वें कार्यकाल, 1-अनुक्रमित लौटाता है।

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 के संयोजन से बने एकल स्ट्रिंग का परीक्षण करके उसी समय $k$ और $n-k$ को प्रोसेस करना है ।$k$$n-k$$k$

उदाहरण:

के लिए $n=2380$ :

• हम अंततः $k=1441$ और n - k = 939 पर पहुंच गए$n-k=939$
• हम स्ट्रिंग " $1441\color{red}{939}1441$ " का परीक्षण करते हैं और पता लगाते हैं कि यह एक पैलिंड्रोम है

टिप्पणी की गई

NB: यह 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
}                            //

Comments

i=>eval("for(n=k=1;k=(s=[...k+[n-k]+k])+''!=s.reverse()?k-1||i--&&++n:++n;);n")79 बाइट्स

— tsh

इसके बजाय i=>eval("...")i=>eval`...`

— ईएस

इसके अलावा, यदि कोई रिटर्न निर्दिष्ट नहीं है, तो अंतिम अभिव्यक्ति का मूल्यांकन करने के लिए eval चूक, इसलिए आप ;nअंत में निकाल सकते हैं ।

— VFDan

@VFDan बैक-टिक ट्रिक के साथ काम नहीं करता है eval()क्योंकि यह एक स्ट्रिंग के लिए अपने तर्क को नहीं करता है। हटाने ;nसे एक सिंटैक्स त्रुटि होगी और केवल हटाने nसे फ़ंक्शन वापस आ जाएगा undefined।

— अरनुलद

Answer 2

जेली ,  16 10  9 बाइट्स

-1 बाइट थैंक्स टू एरिक द आउटगोलर । पहले $n$ शब्दों को आउटपुट करता है ।

2_ŒḂƇ⁺ṆƲ#

इसे ऑनलाइन आज़माएं!

मैंने अपने मूल दृष्टिकोण की तुलना में अलग विचार के साथ आने की कोशिश की। आइए विचार प्रक्रिया की समीक्षा करें:

• प्रारंभ में, परीक्षण ने निम्नानुसार काम किया: इसने उस संख्या के पूर्णांक विभाजन को उत्पन्न किया, फिर उन लोगों को फ़िल्टर किया, जिनमें गैर-पैलिंड्रोम्स भी शामिल थे, फिर गिना कि वहाँ कितनी लंबाई -2 पात्र सूचियाँ थीं। यह स्पष्ट रूप से कोड की लंबाई के मामले में बहुत कुशल नहीं था।

• $N$ के पूर्णांक विभाजन को उत्पन्न करना और फिर फ़िल्टर करना 2 मुख्य नुकसान थे: लंबाई और समय दक्षता। कि इस मुद्दे को हल करने के लिए, मैंने सोचा कि मैं पहले उत्पन्न करने के लिए एक विधि के साथ आ जाएगा केवल पूर्णांकों के जोड़े $(x, y)$ को उस राशि $N$ शर्त यह है कि दोनों संख्या विलोमपद होना चाहिए के साथ (सभी नहीं मनमाना-लंबाई सूची)।

• लेकिन फिर भी, मैं इस बारे में जाने के "क्लासिक तरीके" से संतुष्ट नहीं था। मैंने एप्रोच स्विच किया: जोड़े पैदा करने के बजाय , आइडियल पेइलड्रोम पर प्रोग्राम फोकस करें । इस तरह, कोई व्यक्ति केवल N के नीचे सभी palindromes $x$ गणना कर सकता है , और यदि N - x भी palindrome है, तो हम कर रहे हैं।$N$$N-x$

कोड स्पष्टीकरण

2_ 2 # - मोनाडिक लिंक या पूर्ण कार्यक्रम। तर्क: एन।
2 # - 2 * से शुरू होकर , पहले n पूर्णांक को खोजें जो संतुष्ट हो ...
 _ - ... सहायक लिंक। ब्रेकडाउन (वर्तमान पूर्णांक एन कॉल करें):
    Ƈ - फ़िल्टर। सीमा बनाता है [1 ... N] और केवल उन लोगों को रखता है ...
  Pal - ... पलिंड्रोम्स हैं। उदाहरण: 21 -> [1,2,3,4,5,6,7,8,9,11]
 _ - N. उदाहरण से उन प्रत्येक तालिकाओं को घटाएँ: 21 -> [20,19, ..., 12,10]
     Ate - पिछले लिंक को डुप्लिकेट करें (इसे ऐसे समझें जैसे कि अतिरिक्त ate थे
            ⁺ के बजाय)। यह केवल इस सूची में पैलिन्ड्रोम रखता है।
            यदि सूची गैर-रिक्त है, तो इसका मतलब है कि हमने एक जोड़ी (x, Nx) पाया है
            दो पलिंड्रोम्स होते हैं (और स्पष्ट रूप से x + Nx = N ताकि वे N को योग करें)।
      NOT - तार्किक नहीं (हम पूर्णांकों की तलाश कर रहे हैं जिसके लिए यह सूची खाली है)।
       Last - अंतिम 4 लिंक समूह (मूल रूप से _ as एक एकल मोनड के रूप में कार्य करें)।

^{* कोई अन्य गैर-शून्य अंक काम करता है, उस मामले के लिए।}

Answer 3

जेली , 11 बाइट्स

⁵ŻŒḂ€aṚ$EƲ#

इसे ऑनलाइन आज़माएं!

पूरा कार्यक्रम लगभग इसी तरह काम करता है:

1. इनपुट पर z सेट करें ।
2. X को 10 पर सेट करें ।
3. R पर सेट करें [] ।
4. प्रत्येक पूर्णांक k से 0 तक और x सहित , जाँचें कि क्या k और x - k दोनों पल्लिंडोमिक हैं।
5. यदि L के सभी तत्व समान हैं (अर्थात, यदि x के योग के सभी संभावित जोड़े में उनके दोनों तत्व palindromic हैं, या इस तरह के सभी जोड़े उनके तत्वों में से अधिकांश में palindromic हैं), z को z - 1 पर सेट करें और x को जोड़ दें से आर ।
6. यदि z = 0 , R और अंत लौटाएं ।
7. X से x + 1 पर सेट करें ।
8. चरण 4 पर जाएं।

आपको संदेह हो सकता है कि चरण 5 वास्तव में वह काम नहीं करना चाहिए जो उसे करना चाहिए। हमें वास्तव में z को घटाना नहीं चाहिए यदि सभी जोड़े जो कि x से जोड़ते हैं, वे स्पष्ट नहीं हैं। हालाँकि, हम यह साबित कर सकते हैं कि ऐसा कभी नहीं होगा:

चलो पहले एक पूर्णांक $k$ ताकि $10\le k\le x$ । हम हमेशा ऐसा कर सकते हैं, क्योंकि चरण 2 पर, हम x को 10 मानते हैं ।

यदि $k$ एक palindrome नहीं है, तो हमारे पास युग्म $(k,x-k)$ , जहाँ $k+(x-k)=x$ , इसलिए सभी युग्मों में दो palindromes नहीं हैं।

अगर, दूसरी तरफ, $k$ एक पलिंड्रोम है, तो हम यह साबित कर सकते हैं कि $k-1$ एक palindrome नहीं है। के पहले और अंतिम अंक चलो $k$ हो $D_F$ और $D_L$ क्रमशः। चूँकि $k$ एक palindrome है, $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 के लिए palindromes के जोड़े हैं।

Comments

आह, मुझे हरा भी यह - पहले n पदों 1 बाइट (मैं STDIN और के लिए चला गया बचाता हैŻŒḂ€aṚ$Ṁ¬µ#

— जोनाथन एलन

@JonathanAllan ओह LOL की उम्मीद नहीं थी। वैसे भी, किसी ने हम दोनों को पीटा। : D

— आउटगोल्फ

$(10, x-10)$$10$

$11$

Answer 4

रेटिना , 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+

अंतिम मान निकालें।

Answer 5

हास्केल, 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]।

इसे ऑनलाइन आज़माएं!

Answer 6

पर्ल 5 -MList::Util=any -p , 59 55 बाइट्स

-3 बाइट्स @NahuelFouilleul को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

नोट: anyद्वारा प्रतिस्थापित किया जा सकता है grepऔर -Mकमांड लाइन स्विच से बचा जा सकता है , लेकिन वर्तमान स्कोरिंग नियमों के तहत, एक और बाइट का खर्च आएगा।

Comments

छोटे सुधार, -3 बाइट्स , का उपयोग करते हुए फिर से करना

— नाहुएल फूइउल

और एक के +बाद एक को हटा दिया while।

— Xcali

Answer 7

आर , 115 111 बाइट्स

-4 Giuseppe के लिए धन्यवाद

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]मेरे लिए थोड़ा अक्षम पढ़ता है।

Comments

111 बाइट्स सिर्फ एक जोड़ी चीजों को पुनर्व्यवस्थित करके।

— ग्यूसेप

Answer 8

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 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;}

इसे ऑनलाइन आज़माएं!

Answer 9

जे , ५/६० बाइट्स

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

व्याख्या

सामान्य संरचना एक से इस तकनीक का है जवाब से मीलों :

(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

इसने मेरी मूल लूपिंग तकनीक पर कुछ बाइट्स बचाए, लेकिन चूंकि कोर फ़ंक्शन जम्मू लिखने का मेरा पहला प्रयास है, इसलिए अभी भी बहुत कुछ है जो बेहतर हो सकता है।

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.

Comments

यह मेरा एक पुराना प्रारूप है, जो तब से मैंने सीखी अन्य चाल को मिलाकर एक 41 चार समाधान तैयार करता है:1&(_:1&((e.((*&(-:|.)&":"0>:)&i.-))+])+)*

— मील

Answer 10

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)

Comments

12: °LDʒÂQ}ãOKIè(गति के लिए शायद 10 ^ x से बेहतर ऊपरी सीमा है)। मुझे लगता ∞DʒÂQ}ãOKहै कि तकनीकी रूप से एक 9 है, लेकिन यह पहले आउटपुट से पहले कई बार बाहर है।

— ग्रैमी जूल

@Grimy सुनिश्चित नहीं है कि कार्टेजियन उत्पाद अनंत सूचियों पर आलसी-लोडेड काम करता है। वैसे भी, 12-बायटर के लिए, यह दुर्भाग्य से गलत है। यह पूर्णांक को फ़िल्टर करता है जो समरूप 2 तालिकाओं द्वारा निर्मित किया जा सकता है, लेकिन पूर्णांक नहीं जो स्वयं palindromes हैं। आपका अनुक्रम (अनुगामी के बिना Iè) पसंद आता है: [1,21,32,43,54,65,76,87,98,111,131,141,151,...]लेकिन माना जाता है कि जैसे [*,21,32,43,54,65,76,87,98,201,1031,1041,1051,1052,...]( 1 / अनुक्रमित इनपुट का उपयोग करने से पहले 1/ पहले *इसे अनदेखा किया जा सकता है)।

— केविन क्रूज़सेन

@Grimy हम्म, मुझे लगता है कि सीधे-सीधे फिक्स 1-आधारित सूची Lको 0-आधारित पर बदल रहा है .. :)

— केविन क्रूज़सेन

Answer 11

लाल , 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-अनुक्रमित लौटाता है

Answer 12

पायथन 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

Answer 13

एपीएल (एनएआरएस), 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←⍕⍵}पी में पैलिंड्रोम के लिए परीक्षण है। लूप स्टोर में यह उपरोक्त फ़ंक्शन पी में पाए जाने वाले सभी पैलिंड्रोम को स्टोर करता है, अगर पी के कुछ तत्व w ऐसा है कि iw P में भी है इसका मतलब यह है कि i सही नहीं है और हमारे पास वेतन वृद्धि है। परिणाम:

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