Nth नॉन-पैलिंड्रोमिक नंबर प्रिंट करें


22

एक पलिंड्रोमिक संख्या (यदि आपको पता नहीं है) एक संख्या है जो एक ही पीछे और आगे की ओर पढ़ती है (उदाहरण, 11)। पहले 15 नॉन-पलिंडोमिक नंबर हैं 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26:। यह A029742 है । मुझे लगातार इन नंबरों की आवश्यकता है, लेकिन मेरा चिपचिपा नोट पैड बहुत छोटा है, इसलिए आपका कोड यथासंभव छोटा होना चाहिए।

नियम

  • प्रत्येक सबमिशन एक पूर्ण प्रोग्राम या फ़ंक्शन होना चाहिए (जैसे C में, आप केवल हेडर के बिना फ़ंक्शन को परिभाषित नहीं कर सकते हैं, लेकिन आप आवश्यक हेडर के साथ फ़ंक्शन को परिभाषित कर सकते हैं)।
  • यदि यह संभव है, तो उस साइट का लिंक प्रदान करें जहां आपके कार्यक्रम का परीक्षण किया जा सकता है।
  • आपके प्रोग्राम को कुछ भी नहीं लिखना चाहिए STDERR
  • आप एक तर्क के रूप में या STDIN(या अपनी भाषा में निकटतम विकल्प) से इनपुट ले सकते हैं ।
  • कार्यक्रम बाइट्स के अनुसार बनाए जाते हैं । सामान्य वर्ण सेट UTF-8 है, यदि आप एक और कृपया निर्दिष्ट का उपयोग कर रहे हैं।
  • मानक खामियों को मना किया जाता है।

परीक्षण के मामलों

1
==> 10

-----

5
==> 15

-----

12
==> 23

स्कोरिंग

यह , इसलिए कम से कम बाइट्स जीतता है।

प्रस्तुतियाँ

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।


1
कोई टेस्टकेस?
लीक नून

@ केनीलाऊ मैं कुछ करूँगा।
जॉर्ज गिब्सन

क्या हम 0-आधारित इंडेक्स का उपयोग कर सकते हैं, इसलिए 154 नंबर होगा?
nimi

@nimi या तो, लेकिन कृपया निर्दिष्ट करें कि आपका 0-अनुक्रमित है।
जॉर्ज गिब्सन

@nimi क्षमा करें, यही मेरा मतलब है, स्पष्ट करने के लिए संपादित किया गया है।
जॉर्ज गिब्सन

जवाबों:


9

अजगर, 7 बाइट्स

e.f!_I`

परीक्षण सूट

स्पष्टीकरण:

e.f!_I`
e.f!_I`ZQ    Implicit variable introduction.
 .f     Q    Find the first Q numbers whether the following is truthy,
             starting at 1, where Q is the input.
      `Z     Convert the number to a string.
     _I      Check if it's the same when reversed.
    !        Logical not.
 e           Return the last element of the list.

5

हास्केल, 38 बाइट्स

([x|x<-[1..],(/=)<*>reverse$show x]!!)

0-आधारित सूचकांक का उपयोग करता है। ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11-> 23

परीक्षण एक नंबर रखने के लिए है कि क्या (/=)<*>reverse$show xकरने के लिए अनुवाद (show x) /= (reverse (show x))करता है, तो संख्या की स्ट्रिंग प्रतिनिधित्व स्ट्रिंग प्रतिनिधित्व के रिवर्स बराबर नहीं है, यानी की जांच।


4

ब्रेकीलॉग , 14 11 बाइट्स

;0{<≜.↔¬}ⁱ⁽

-3 बाइट्स टैंक को घातक बनाते हैं

व्याख्या

; {      }ⁱ⁽        --  Find the nth number
 0                  --      (starting with 0)
   <                --      which is bigger then the previous one
    ≜               --      make explicit (otherwise it fucks up)
      .             --      which is the output
       ↔            --      and if reversed
        ¬           --      is not the output

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


;İ{ℕ≜.↔¬}ᶠ⁽t2 बाइट्स कम है।
घातक

वास्तव में, का उपयोग करते हुए iterate: 1 बाइट कम है;0{<≜.↔¬}ⁱ⁽
Fatalize

3

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

1 बाइट्स @ Sp3000 के लिए धन्यवाद ।

ṚḌ_
0dz#Ṫ

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

परीक्षण सूट।

व्याख्या

DUḌ_   Helper link. Check if x is not palindrome.

D      Convert to decimal.
 U     Reverse.
  Ḍ    Convert back to integer.
   _   Subtract x from the result above.
       For 23, this will yield 32-23 = 9.
       Only yield 0 (falsy) if x is palindrome.
       If x is not a palindrome,
       it will return a truthy number.


0dz#Ṫ  Main link.

0      Start from 0.
   #   Find the first         numbers:
  ³                   <input>
 Ç         where the above link returns a truthy number.
    Ṫ  Yield the last of the matches.

1
मजेदार तथ्य: प्रयास करें123Ṛ
Sp3000

@ Sp3000 वास्तव में बहुत दिलचस्प है!
लीक नून

तुम गिरा सकते हो ³। यदि आप इनपुट को STDIN पर रखते हैं, तो आप इसे भी छोड़ सकते हैं 0। (जेली के नवीनतम संस्करण में, ṚḌ_ø#Ṫयह भी काम करता है, लेकिन यह इस चुनौती से नया है।)
डेनिस

मेरे लिए काम नहीं करता है ...
लीक नून

7 बाइट्स लेकिन यह नई सुविधाओं का उपयोग कर सकता है
caird coinheringaahing

3

05AB1E , 8 बाइट्स

कोड:

µNÂÂQ>i¼

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!


यह 05AB1E के पुराने संस्करण के साथ कुछ करने की संभावना है, लेकिन जिज्ञासा से बाहर: डबल द्विभाजित क्यों Â? PS इसे पढ़ने वाले किसी और के लिए: अब 5 बाइट्स हो सकते हैं µNÂʽ
केविन क्रूज़सेन

@ केविनक्रूजसेन: संभवतः एन (केवल स्टैक के शीर्ष) का कोई निहित उत्पादन नहीं होने के कारण। इसके अलावा, यह 4 बाइट्स हो सकता है क्योंकि ½यह भी निहित है।
एमिग्ना

@ मिग्ना आह, पूरी तरह ½से निहित होने के बारे में भूल गया , भले ही मैंने इसे एक टिप में उल्लेख किया था जो मैंने खुद लिखा था ..>। सोचा ¼(1 से बढ़ाव counter_variable ) µएक पल के लिए लूप के लिए निहित था , लेकिन वास्तव में ½( अगर स्टैक के शीर्ष 1 है: इसके बजाय
काउंटर_वर्जेबल बढ़ाएं

3

क्लोजर, 62 बाइट्स

#(nth(for[i(range):when(not=(seq(str i))(reverse(str i)))]i)%)

0 अनुक्रमित। सूची बोध का उपयोग करके गैर-विस्मृत संख्याओं के आलसी अनंत रेंज उत्पन्न करें और iवें को लें । इसे ऑनलाइन देखें: https://ideone.com/54wXI3


2

PowerShell v2 +, 65 बाइट्स

for(;$j-lt$args[0]){if(++$i-ne-join"$i"["$i".length..0]){$j++}}$i

जब तक हम इनपुट से कई मैच नहीं पाते हैं , तब तक संख्याओं के माध्यम से 0(असमान के लिए अंतर्निहित मूल्य $i) से लूप्स $args[0], फिर अंतिम एक को आउटपुट करता है। ध्यान दें कि हम लूप को इनिशियलाइज़ नहीं करते हैं, इसलिए $j=0यह निहित है।

प्रत्येक पुनरावृत्ति, हम पूर्व-वृद्धि करते हैं $i, और जांचते हैं कि क्या यह $iउलट के बराबर नहीं है। यदि हां, तो इसका मतलब है कि हमने एक गैर-तालमेल पाया है, इसलिए वेतन वृद्धि $j। लूप तब आवश्यकतानुसार कई बार जारी रहता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 100
120

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 5
15

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 55
70

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 212
245

2

पायथन 2, 60 बाइट्स

f=lambda n,i=0,j=1:j>n and i-1or f(n,i+1,j+(`i`!=`i`[::-1]))

एक-अनुक्रमित फ़ंक्शन जो nतर्क के माध्यम से इनपुट लेता है और nवें गैर-पैलिंड्रोमिक संख्या को लौटाता है ।

यह काम किस प्रकार करता है

यह एक संपूर्ण पुनरावर्ती खोज है, जो कि पूर्ण - iसीमा में [1,∞)तब तक पूर्णांक का परीक्षण करती है, जब तक कि nगैर-पैलिंड्रोमिक संख्या नहीं मिली है; चूंकि iपूर्व-वृद्धि हुई है, i-1फिर वापस लौटा दी गई है। यह जांचना कि क्या कोई संख्या एक पैलिन्ड्रोमिक है जिसे स्ट्रिंग में परिवर्तित करके, उलट कर, और फिर जांच की जाती है कि क्या मूल और उलट तार बराबर हैं।

कोड तार्किक रूप से इसके बराबर है:

def f(n,test=0,count=1):
    if count>n:
        return test
    elif str(test)!=reversed(str(test)):
        return f(n,test+1,count+1)
    else:
        return f(n,test+1,count)

जो स्वयं अनिवार्य रूप से है:

def f(n):
    test=0
    count=1
    while count<=n:
        if str(test)!=reversed(str(test)):
            count+=1
        test+=1
    return test-1

Ideone पर इसे आज़माएं


2

क्लोजर, 62 बाइट्स

#(nth(filter(fn[i](not=(seq i)(reverse i)))(map str(range)))%)

अन्य उत्तर की तुलना में काफी अलग दृष्टिकोण, लेकिन समान लंबाई।


2

आर , 133 117 93 76 बाइट्स

-16 बाइट्स जेसीई को धन्यवाद। -41 बाइट्स Giuseppe के लिए धन्यवाद।

x=scan();while({F=F+any((D=T%/%10^(1:nchar(T)-1)%%10)!=rev(D));F<=x})T=T+1;T

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


1
आप कुछ बाइट्स का दुरुपयोग कर सकते हैं F, आदि: TIO । इसके अलावा, आप लूप को क्यों सीमित कर रहे हैं (0:97)+10?
JayCe

1
मेरे उत्तर से टिप # 3 का उपयोग करें अंक निकालने के लिए R में गोल्फिंग के लिए टिप्स ; आप कर सकते हैं all(D==rev(D))जहां Dअंकों का एक वेक्टर है। मेरा मानना ​​है कि एक whileलूप कम होगा, और जैसा कि @JayCe पूछता है, आप केवल 10 और 107 के बीच की संख्या की जांच क्यों कर रहे हैं?
Giuseppe

@Giuseppe अपनी सिफारिशों के साथ अद्यतन किया गया। अभी भी थोड़ा उलझन में है कि एक whileही समय में बाइट को बचाने के लिए लूप कैसे लागू किया जाए ।
रॉबर्ट एस।

1
@RobertS। यदि आपके कोई प्रश्न हैं, तो मुझे आर चैटरूम में पिंग करने के लिए स्वतंत्र महसूस करें !
Giuseppe

2

फोर्थ (gforth) , 103 99 बाइट्स

: f 9 swap 0 do begin 1+ dup 0 over begin 10 /mod >r swap 10 * + r> ?dup 0= until = 0= until loop ;

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

व्याख्या

लूप n बार, प्रत्येक पुनरावृत्ति अगले गैर-तालमेल संख्या को 1 से एक काउंटर बढ़ाकर तब तक प्राप्त करता है जब तक कि संख्या स्वयं ही उलट न हो।

अघोषित कोड

आम तौर पर मैं कोड को "अनलोड" नहीं करूंगा, लेकिन चूंकि यह कोड कुछ गड़बड़ है, इसलिए मुझे लगा कि इससे मदद मिलेगी

: reverse ( s -- s )
    0 swap 
    begin 
        10 /mod
        >r swap
        10 * +
        r> ?dup 0=
    until 
; 

: f ( s -- s )
    9 swap 0
    0
    do
        begin
            1+ dup dup
            reverse =
        0= until
    loop
;

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

: f                \ start a new word definition
  9                \ start at 9, since all positive ints < 10 are palindromic
  swap 0           \ set up loop parameters from 0 to n-1
  do               \ start a counted loop       
    begin          \ start an indefinite loop
      1+ dup       \ increment counter and place a copy on the stack
      ( Reverse )
      0 over       \ add 0 to the stack (as a buffer) and copy the top counter above it
      begin        \ start another indefinite loop
        10 /mod    \ get the quotient and remainder of dividing the number by 10
        >r         \ store the quotient on the return stack
        swap 10 *  \ multiply the current buffer by 10
        +          \ add the remainder to the buffer
        r>         \ grab the quotient from the return stack
        ?dup       \ duplicate if not equal to 0
        0=         \ check if equal to 0
      until        \ end inner indefinite loop if quotient is 0
      ( End Reverse )
      = 0=         \ check if counter =/= reverse-counter            
    until          \ end the outer indefinite loop if counter =/= reverse-counter
  loop             \ end the counted loop
;                  \ end the word definition 

1

पर्ल 6 , 29 बाइट्स

{grep({$_!= .flip},^Inf)[$_]}

(0 आधारित सूचकांक का उपयोग करता है)

{         # The $_ is implied above
  grep(   # V
    { $_ != $_.flip }, # only the non-palindromic elements of
    ^Inf               # an Infinite list ( 0,1,2,3 ...^ Inf )
  )[ $_ ]              # grab the value at the given index
}

उपयोग:

my &non-palindrome = {grep({$_!= .flip},^Inf)[$_]}

say non-palindrome 1  - 1; # 10
say non-palindrome 5  - 1; # 15
say non-palindrome 12 - 1; # 23

# this also works:
say non-palindrome 0..20;
# (10 12 13 14 15 16 17 18 19 20 21 23 24 25 26 27 28 29 30 31 32)

1

दरअसल, 17 बाइट्स

;τR9+;`$;R=Y`M@░E

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

मान 1-अनुक्रमित हैं। पहले की जगह यह आसानी से करने के लिए बदला जा सकता है 0 अनुक्रमित Rके साथ r। लेकिन, Rक्या मैंने शुरू में टाइप किया है, इसलिए मैं इसके साथ जा रहा हूं।

गैर-महत्वपूर्ण संख्या संतुष्ट करती है a(n) ≈ n + 10, इसलिए 2n+9पर्याप्त ऊपरी सीमा है।

स्पष्टीकरण:

;τR9+;`$;R=Y`M@░E
;τ9+R;             push n, range(1,(2*n)+10)
      `$;R=Y`M@░   take values that are not palindromic
                E  take nth element

1

जावास्क्रिप्ट (ईएस 6), 54 बाइट्स

1-आधारित अनुक्रमण का उपयोग करता है। केवल 7624 वें नंबर तक काम करता है।

d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a

प्रयोग

d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a
d(1)
10
d(123)
146
d(7624)
7800
d(7625)
// Uncaught RangeError: Maximum call stack size exceeded

जावास्क्रिप्ट (ईएस 6), 59 बाइट्स

पुनरावृत्ति का उपयोग नहीं करता है और इसलिए बहुत बड़े आदानों को संभाल सकता है।

i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a")

प्रयोग

(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(1)
10
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(7625)
7801
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(123456)
124579

1

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (97 बाइट्स)

n=>_.Sequence(n,i=>{i=_.From(i+"");if(!i.Reverse().SequenceEqual(i)){return i.Write("")}}).Last()

लिंक ऑफ लिब: https://github.com/mvegh1/Enumerable

कोड स्पष्टीकरण: लाइब्रेरी में सीक्वेंस नामक स्थैतिक विधि होती है, जहां पहला परम परिभाषित करता है कि अनुक्रम बनाने के लिए कितने तत्व अनुक्रम की गारंटी देंगे, और दूसरा पैरामीटर वर्तमान पुनरावृत्ति मान "i" को स्वीकार करने वाला एक विधेय है। विधेय पूर्णांक को एक स्ट्रिंग में परिवर्तित करता है, जो _.From को कॉल करके एक वर्ण सरणी में परिवर्तित हो जाता है। वर्ण सरणी की तुलना वर्ण सरणी के उत्क्रमण के विरुद्ध की जाती है, और यदि वे समान नहीं हैं, तो वर्ण सरणी वापस स्ट्रिंग में शामिल हो जाती है और वापस आ जाती है। अन्यथा, कुछ भी नहीं लौटाया जाता है (अर्थात परिणाम अपरिभाषित है, जिसे पुस्तकालय हमेशा अनदेखा करेगा)। अंत में, अनुक्रम का अंतिम तत्व, अर्थात Nth तत्व वापस आ गया है

यहां छवि विवरण दर्ज करें


1

सी, 84 बाइट्स

फ़ंक्शन f(n)पूर्णांक लेता है nऔर n-thगैर-पैलिंड्रोमिक संख्या (1 आधारित) देता है।

g(n,r){return n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;}

Ideone पर यह परीक्षण !

यह काफी तुच्छ कोड है, इस प्रकार शायद सुधार के लिए जगह है।


के n=n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)-s||s++);n=s;बजाय सुझावreturn n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;
छत

1

रूबी, 54 बाइट्स

यह फ़ंक्शन 1-अनुक्रमित है और आंशिक रूप से डोम हेस्टिंग्स के जावास्क्रिप्ट उत्तर पर आधारित है । मुझे लगता है कि यह बेहतर करने के लिए एक रास्ता है, विशेष रूप से उस अंतिम टर्नरी स्थिति के साथ। साथ ही, यह फ़ंक्शन वर्तमान में एक स्ट्रिंग देता है, जिसे बाद में संपादित करने की आवश्यकता हो सकती है। किसी भी गोल्फ सुझाव का स्वागत है।

f=->x,y=?9{x<1?y:(y.next!.reverse!=y)?f[x-1,y]:f[x,y]}

Ungolfed:

def f(x, y="9")
 if x<1
  return y
 else
  y = y.next
  if y.reverse != y
   return f(x-1, y)
  else
   return f(x, y)
  end
 end
end

1

सी ++ (जीसीसी), 148 बाइट्स

यह 1-आधारित है और एल्गोरिथ्म वास्तव में अनुभवहीन है

#import <iostream>
using namespace std;int n,i=1;string s;main(){cin>>n;while(s=to_string(i+1),(n+=equal(begin(s),end(s),s.rbegin()))-i++);cout<<i;}

@ संपादित करें आपके संपादन के बारे में: #importgcc का संकलक विस्तार है। यह पदावनत है, लेकिन यह वास्तव में यहाँ मायने नहीं रखता है
ovs

1

APL NARS 35 वर्ण

r←v a;c
r←c←0
A:r+←1⋄c+←r≠⍎⌽⍕r⋄→A×⍳c<a

यह फ़ंक्शन v है; "⍎⌽⍕" r traslate संख्या r स्ट्रिंग में, उस स्ट्रिंग को उल्टा करें, स्ट्रिंग से संख्या तक traslate। परीक्षण और सहायता कार्य:

  ⍝ return the one string for the basic types ('Char', 'Int', 'Float', 'Complex or Quaternion or Oction')
  ⍝ or one string for composite types ('Tensor 3' 'Tensor 4' etc 'Matrix', 'List', 'String')
  ⍝ follow the example in: /codegolf//a/39745
  type←{v←⍴⍴⍵⋄v>2:'Tensor ',⍕v⋄v=2:'Matrix'⋄(v=1)∧''≡0↑⍵:'String'⋄''≡0↑⍵:'Char'⋄v=1:'List'⋄⍵≢+⍵:'Complex or Quaternion or Oction'⋄⍵=⌈⍵:'Int'⋄'Float'}
  h←{'Int'≢type ⍵:¯1⋄(⍵<1)∨⍵>2e5:¯1⋄v ⍵} 
  h 1
10
  h 1.32
¯1
  h 7878
8057
  h¨3 5 12
13 15 23 
  h 6 7 8
¯1
  h '123'
¯1
  h '1'
¯1
  h 1.0
10
  h 1.0003
¯1
  h ¯2
¯1
  h 0
¯1
  h 200000
201200
  h 200001
¯1



1

सी # 7, 89 बाइट्स

n=>{int i=9;for(;n-->0;)if(Enumerable.SequenceEqual(++i+"",(""+i).Reverse()))i++;return i;}

1 पर क्लिक करें

n=>
  int i = 9;                                  | Start at 9. Iterate exactly n times. Assume n >= 1      
  for(;n-->0;)                                | Iterate n times
  if(EnumerableSequenceEqual(                 | Compare two sequences
  ++i+"",(""+i).Reverse())                    | Generate the forward and backward strings, which behave like char sequences for Linq
  i++                                         | If the sequences are equal, the number is a palindrome. Increment i to skip
  return i;                                   | Return the number after the for loop exits

मुझे नहीं लगता कि यह c # 7 से किसी भी भाषा की विशेषताओं का उपयोग करता है, लेकिन मैंने इसे वहां रखा है क्योंकि मैंने इसके खिलाफ परीक्षण किया था


PPCG में आपका स्वागत है।
जोनाथन फ्रीच


1

जावा 8, 117 95 94 बाइट्स

n->{int r=10;for(;n-->0;)if((++r+"").contains(new StringBuffer(r+"").reverse()))r++;return r;}

0 अनुक्रमित

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{             // Method with integer as both parameter and return-type
  int r=10;      //  Result-integer, starting at 10
  for(;n-->0;)   //  Loop an amount of times equal to the input
    if((++r+"")  //   First raise `r` by 1, and then check if `r`
               .contains(new StringBuffer(r+"").reverse()))
                 //   is the same as `r` reversed (and thus a palindrome)
      r++;       //    And if it is: raise `r` by 1 again
  return r;}     //  Return result-integer

@ceilingcat जो गलत परिणाम देता है .. के new StringBuffer(int)बराबर नहीं है new StringBuffer(String), न ही है .. String.equals(StringBuffer)बल्कि String.equals(String)यह एक पुराना उत्तर है, लेकिन मैं (++r+"").contains(new StringBuffer(r+"").reverse())1 बाइट को बचाने के लिए उपयोग कर सकता हूं ।
केविन क्रूज़सेन

-2

टीसीसी, 11 बाइट्स

?>!~<>;i;'T

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

            | Printing is implicit
?>          | Find n-th number for which the following is "T":
  !~        | If not equal...
    <>;     | reverse. No value specified, so input is assumed.
       i;   | Input, since double semicolons are ignored
         'T | ... print string "T"

1
यह tcc.luaटाइमस्टैम्प 16-07-26 12:46 यूटीसी के साथ फाइल के साथ काम नहीं करता है , जिसमें ?>कमांड नहीं थी । यदि आपके उत्तर के लिए चुनौती का सामना करने वाली भाषा के एक संस्करण की आवश्यकता होती है, तो आपको इसे हेडर में गैर-प्रतिस्पर्धी के रूप में लेबल करना होगा । जब आप करोगे तो मैं अपना पदच्युत निकाल दूंगा।
डेनिस

@ डेनिस मैं इस दो साल पुरानी पोस्ट पर लड़खड़ा गया और यह उल्लेख करना चाहता था कि अब उत्तर को गैर-प्रतिस्पर्धा के रूप में चिह्नित नहीं किया जाना चाहिए, जब उनकी भाषा चुनौती के बाद का समय लेती है ।
जोनाथन फ्रेच
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.