22

संख्या N , आउटपुट / रिटर्न X को देखते हुए ताकि N + X एक पैलिंड्रोम हो, जहाँ | X | जितना संभव हो उतना छोटा होना चाहिए।

पैलिंड्रोम: एक संख्या एक पैलिंड्रोम होती है, यदि अंकों का अनुक्रम समान होता है, तो उन्हें बाएं से दाएं पढ़ते समय, जैसा कि दाएं से बाएं पढ़ने पर होता है।
95359और 6548456सममित हैं, 123और 2424नहीं हैं। प्रमुख शून्य के साथ संख्याएँ जैसे कि 020कोई तालमेल नहीं है।

इनपुट एक सकारात्मक पूर्णांक है जो 10 ¹⁵ से छोटा है । स्टड से इसे पढ़ें, विधि-पैरामीटर के रूप में, जो भी हो।

आउटपुट एक पूर्णांक (धनात्मक या ऋणात्मक) होना चाहिए और 0 होना चाहिए यदि इनपुट पहले से ही एक palindrom है। आप अपने आउटपुट को स्टडआउट करने के लिए लिख सकते हैं, इसे एक फ़ंक्शन या जो कुछ भी आप चाहते हैं, से वापस कर सकते हैं। अगर वहाँ 2 संख्या (उदाहरण के लिए कर रहे हैं 2और -2) है कि आवश्यकताओं को पूरा, उत्पादन उनमें से केवल एक।

उदाहरण:

Input             Output
3                 0
234               -2
1299931           -10
126               5 or -5 (only one of them)

code-golf integer palindrome

— CommonGuy
स्रोत

संभवत: यदि कोई संख्या दो निकटतम पल्लिंड्रोम्स के बीच आधी है, या तो एक स्वीकार्य आउटपुट है? जैसे N=10आउटपुट के लिए X=-1या हो सकता है X=1?

— पीटर टेलर

@PeterTaylor हाँ, यह जितना संभव हो उतना छोटा होना चाहिए।

— कॉमनग्यू

9

अजगर , २६ २०

Lnb_bWP`+QZ=Z-g0ZZ)Z

नए नियमों को पूरा करने के लिए अद्यतन किया गया।

कार्यक्रम एक अनंत लूप में चलता है, जो 0, -1, 1, -2, -2, क्रम में हर संभव वेतन वृद्धि का परीक्षण करता है ...

स्पष्टीकरण:

Q=eval(input())     implicit
Z=0                 implicit
Lnb_b               def P(b): return b != rev(b)
WP`+QZ              while P(repr(Q+Z)):
=Z-g0ZZ             Z=(0>=Z)-Z
)                   <end while>
Z                   print(Z)

उदाहरण रन:

python3 pyth.py programs/palin.pyth <<< 965376457643450
-2969881

इसमें 23 सेकंड का समय लगा।

बोनस समाधान, एक ही वर्ण गणना:

Wn`+QZ_`+QZ=Z-g0ZZ)Z

— isaacg
स्रोत

बस आपको यह बताने के लिए, नियम निकटतम पैलिंड्रोम को खोजने के लिए बदल गए (दोनों दिशा में)। लेकिन मुझे लगता है कि जब से आप उस नियम को बदलने से पहले पोस्ट किया है, इसे ठीक करने के लिए आपके लिए कोई दायित्व नहीं है।

— मार्टिन एंडर

यह [0, 1, -1, 2, -2, ...]एक अद्यतन के माध्यम से Z को लूप में सहेज सकता है Z=-Z+(Z<0)?

— xnor

हां - मुझे लगता है कि स्वतंत्र रूप से।

— isaacg

@xnor जोड़ा गया। भराव।

— isaacg

अच्छा ठीक है। क्या आपने भी हालत की उपेक्षा को कुछ समय के लिए ध्यान में रखा है? और शायद P को इनपुट करने के लिए इसे लागू करके एक रीप को बचा सकता है?

— xnor

7

रूबी, 111 84 बाइट्स

i=$*[j=-1].to_i
r=->j{s=(i+j).to_s
abort(j.to_s)if s==s.reverse}
loop{r[j+=1]
r[-j]}

संख्या को इसके एकमात्र कमांड-लाइन तर्क के रूप में लेता है।

— मार्टिन एंडर
स्रोत

इस वेबसाइट के बारे में कैसे ?

— कॉमनग्यू

@Manu धन्यवाद पता नहीं था कि एक! मेरा सबमिशन जहां तक मैं बता सकता हूं, काम करता है।

— मार्टिन एंडर

6

CJam, 34 29 25 बाइट्स

q~:I!{:R1<R-RI+`_W%=!}g;R

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

उदाहरण

$ cjam palfind.cjam <<< 120; echo
1
$ cjam palfind.cjam <<< 121; echo
0
$ cjam palfind.cjam <<< 122; echo
-1

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

q~:I    " Read from STDIN, evaluate and save the result in “I”.                           ";
!       " Compute the logical NOT (0 since the integer is positive).                      ";
{       "                                                                                 ";
  :R    " Save the topmost integer in “R”.                                                ";
  1<R-  " Compute (R < 1) - R. This produces the sequence 0 → 1 → -1 → 2 → -2 → … .       ";
  RI+   " Push I + R.                                                                     ";
  `_    " Cast to string and push a copy.                                                 ";
  W%=!  " Check if the reversed copy matches the original.                                ";
}g      " If it doesn't, repeat the loop.                                                 ";
;R      " Discard the integer on the stack and push “R”.                                  ";

— डेनिस
स्रोत

5

हास्केल - 62

f n=[x-n|x<-[0..]>>= \v->[n+v,n-v],show x==(reverse.show)x]!!0

इसे नाम की फ़ाइल में सहेजें golf.hsऔर फिर ghci के साथ इसका परीक्षण करें:

*Main> :l golf
[1 of 1] Compiling Main             ( golf.hs, interpreted )
Ok, modules loaded: Main.
*Main> map f [1000..1050]
[-1,0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,-37,-38,-39,-40,-41,-42,-43,-44,-45,-46,-47,-48,-49]
*Main>

— रे
स्रोत

लेखन के बारे में कैसे x<-[0..]>>=(\v->[n+v,n-v])? यह छोटा है और इसे

— गर्वित हेकलर

@proudhaskeller धन्यवाद! सूची के साथ बहुत सुंदर चाल मोनाद।

— रे

4

पायथन 2.7, 98 , 81

इनपुट संख्या से एक पैलिंड्रोम बनाता है, फिर उस इनपुट को डेल्टा से खोजने के लिए घटाता है।

def f(n):
    m=map(int,str(n));l=len(m)/2;m[-l:]=m[l-1::-1];return int(`m`[1::3])-n

उपयोग:

print f(3)          # 0
print f(234)        # -2
print f(2342)       # -10
print f(129931)     # -10
print f(100000)     # 1

अपुष्ट और टिप्पणी:

def f(n):                      # take a integer n
    m=map(int,str(n));         # convert n into array of ints
    l=len(m)/2;                # get half the length of the array of ints
    m[-l:]=m[l-1::-1];         # replace the last elements with the first elements reversed
    return int(`m`[1::3])-n    # convert array of ints backinto single int and subtract the original number to find the delta

— Moop
स्रोत

यह सबसे छोटा डेल्टा नहीं देता है। f(19) = -8(palindrome 11), जहां इसे +3बनाना चाहिए 22।

— Geobits

@ जीबिट्स हां, 10-100 मूल्य मुझे इस दृष्टिकोण के साथ एक समस्या देंगे

— Moop

यह सिर्फ उन नहीं है। इसी तरह, 199999 में -8, 3 के बजाय, 9911 -22 के बजाय 88 देता है। बस पहले अंक को उलटने से बहुत सारे मामलों में सबसे छोटा डेल्टा प्राप्त करने का काम नहीं करता है।

— जियोबिट्स

अच्छी तरह से मैं बहुत सारे मामलों को नहीं कहूंगा, मैं 99.9% मामलों के लिए शर्त लगाता हूं जो इसके लिए काम करता है। लेकिन हां, इसे 100% मामलों में काम करने की जरूरत है

— Moop

@Geobits। ज़रूर, इसलिए वहाँ 27% त्रुटि दर। लेकिन जब आप 100000000s पर पहुंचते हैं तो त्रुटि दर काफी कम हो जाती है। वास्तविक त्रुटि दर की गणना करना दिलचस्प होगा।

— 19

4

पर्ल 5, 93 89 88 87 75 63 44

$/=($/<1)-$/while$_+$/-reverse$_+$/;$_=$/+0

Ungolfed:

while($input + $adjustment - reverse($input + $adjustment)) {
    $adjustment = ($adjustment < 1) - $adjustment;   
}
$input = $adjustment + 0;  ## gives 0 if $adj is undefined (when $input is a palindrome)
print $input;  ## implicit

डेनिस के सुझावों के लिए धन्यवाद, इसे 43 + -p = 44 पर नीचे लाया गया

— user0721090601
स्रोत

1

1. -$aसे छोटा है $a*-1। 2. यदि आप उपयोग करते हैं ($a<1), तो इसकी कोई आवश्यकता नहीं है ? :$a++। 3. यदि आप -pस्विच का उपयोग करते हैं , $_=<>और print$_निहित है, तो आप पहले बयान को छोड़ सकते हैं और अंतिम को बदल सकते हैं $_=$a+0।

— डेनिस

@ डेनिस नाइस पाता है। कोड गोल्फ में यह केवल मेरा दूसरा प्रयास है, इसलिए सलाह की सराहना करें!

— user0721090601

यह -pएक अतिरिक्त बाइट के रूप में स्विच को गिनने के लिए प्रथागत है , लेकिन आप ($a<1)-$aइसके बजाय का उपयोग करके इसे वापस प्राप्त कर सकते हैं -$a+($a<1)।

— डेनिस

@ डेनिस हालांकि मैं आपके उत्तर के आधार पर उस पद्धति का उपयोग करने के बारे में हूं, लेकिन लाभ खो जाता है क्योंकि इससे पहले एक स्थान की आवश्यकता होती हैwhile

— user0721090601

यदि आप $/इसके बजाय उपयोग करते हैं $a, तो यह काम करेगा।

— डेनिस

4

05AB1E , 15 14 बाइट्स (-1 Emigna के लिए धन्यवाद)

2äнsgÈi∞ë.∞}s-

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

तरीका:

संख्या का पहला आधा भाग लें।
यदि यह विषम हो, तो गैर-प्रतिच्छादित होने पर भी आईना।
अंतर।

— जादू ऑक्टोपस Urn
स्रोत

मुझे लगता है कि आप 2äнइसके बजाय उपयोग कर सकते हैं g;î£।

— इमिग्ना

3

जावा: 127 109

मूल पुनरावृत्ति, अगले उम्मीदवार के पास जाने से पहले नकारात्मक और सकारात्मक दोनों की जांच करना।

int p(long n){int i=0;for(;!(n+i+"").equals(new StringBuilder(n+i+"").reverse()+"");i=i<1?-i+1:-i);return i;}

इनपुट के लिए 123456789012345, यह -1358024बराबर पैलिंड्रोम में लौटता है 123456787654321।

कतार टूट जाती है:

int p(long n){
    int i=0;
    for(;!(n+i+"").equals(new StringBuilder(n+i+"").reverse()+"");i=i<1?-i+1:-i);
    return i;
}

— Geobits
स्रोत

क्या n+i+""काम करता है और कोष्ठक को बचाता है? मुझे लगता है कि पूर्वता सही होनी चाहिए।

— पीटर टेलर

@PeterTaylor हां, और इससे कुछ और मिला toString()। धन्यवाद :)

— ज्योबिट्स

1

क्या मैं उस मिठाई को चुरा सकता हूँ i=i<1?-i+1:-i? मैं इसे "अभद्रता" कहूंगा।

— जेकब

@ जेकॉब इसके लिए जाओ;)

— भूतकाल

3

क्लोजर, 92

एक आलसी-अनुक्रम से पहला लेता है जो 0 से काम करता है और इसमें केवल वे मूल्य शामिल होते हैं जो पैलिंड्रोम बनाते हैं:

(defn p[x](first(for[i(range)j[1 -1]k[(* i j)]s[(str(+ x k))]:when(=(seq s)(reverse s))]k)))

REPL-LPER सत्र:

golf-flog> (p 3)
0
golf-flog> (p 10)
1
golf-flog> (p 234)
-2
golf-flog> (p 1299931)
-10
golf-flog> (p (bigint 1e15))
1

— YosemiteMark
स्रोत

2

जावास्क्रिप्ट, 175 136 117

सीधा। pसही है अगर किसी दिए गए नंबर में पैलिंड्रोम है, fतो निकटतम को खोजता है।

संपादित करें: मैंने यहां जावा जवाब में गीबिट्स द्वारा मीठी "अनिर्णय" चाल के लिए इसे थोड़ा और अधिक धन्यवाद दिया।

p=function(n){return (s=''+n).split('').reverse().join('')==s}
f=function(n){for(i=0;!p(n+i);i=i<1?-i+1:-i);return i}

उपयोग:

f(3)
f(234)
f(1299931)

— याकूब
स्रोत

ES6 में 104: p=n=>[...s=''+n].reverse().join('')==s f=n=>{r=t=0;while(!(p(n+r++)||p(n+t--)));return p(n+r-1)?r-1:t+1}:)

— विलियम बारबोसा

1

मैं शर्त लगा सकता हूँ कि यह है। functionऔर returnबहुत लंबे समय तक आरक्षित शब्द हैं ...

— याकूब

1

3 साल की देरी के लिए क्षमा करें, लेकिन ES6 में 68 पर गोल्फ s=>{for(i=0;[...s+i+""].reverse().join``!=s+i;i=i<0?-i:~i);r‌eturn i}:। स्टैक-ओवरफ्लो प्रवण 61 f=(s,i=0)=>[...s+i+""].reverse().join``==s+i?i:f(s,i<0?-i:~i‌):;)

— शायरु असाकोटो

2

जे - ४ ९ चार

एक फ़ंक्शन मैपिंग पूर्णांक से पूर्णांक तक।

((0{g#f)>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0)

यहां बताया गया है कि आप इस परिणाम को तीन भागों में कैसे बना सकते हैं। यह जे आरपीएल का प्रदर्शन है: इंडेंटेड लाइनें उपयोगकर्ता इनपुट हैं और बाहर वाले आरईपीएल आउटपुट हैं। और हाँ, J एक अंडरस्कोर के साथ नकारात्मक संकेत को मंत्र देता है _।

   236 (_1 1*]) 4                          NB. -ve and +ve of right arg
_4 4
   236 (f=._1 1*]) 4                       NB. name it f
_4 4
   236 (+f=._1 1*]) 4                      NB. add left to each
232 240
   236 (":@+f=._1 1*]) 4                   NB. conv each to string
232
240
   236 ((-:|.)@":@+f=._1 1*]) 4            NB. palindrome? on each
1 0
   236 (g=.(-:|.)@":@+f=._1 1*]) 4         NB. name it g
1 0
   236 (+:/@g=.(-:|.)@":@+f=._1 1*]) 4     NB. logical NOR (result 1 if both=0)
0
   palin =: (+:/@g=.(-:|.)@":@+f=._1 1*])


   236 (>:@]) 0                            NB. increment right
1
   236 (>:@]^:2) 0                         NB. functional power
2
   236 (>:@]^:(236 palin 3)) 3             NB. power 1 if no palindromes
4
   236 (>:@]^:(236 palin 4)) 4             NB. power 0 if has palindrome
4
   236 (>:@]^:palin) 4                     NB. syntactic sugar
4
   236 (>:@]^:palin^:_) 0                  NB. increment until palindrome, start with 0
4
   (>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0) 236    NB. bind 0
4
   delta =: >:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0


   ((f) delta) 236       NB. f=: -ve and +ve
_4 4
   ((g) delta) 236       NB. g=: which are palindromes
1 0
   ((g#f) delta) 236     NB. select the palindromes
_4
   ((g#f) delta) 126     NB. what if both are equal?
_5 5
   ((0{g#f) delta) 126   NB. take the first element
_5
   ((0{g#f)>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0) 236   NB. it works!
_4

उदाहरण:

   pal =: ((0{g#f)>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0)
   pal 3
0
   pal every 234 1299931 126
_2 _10 _5
   pal 2424
18
   2424 + pal 2424
2442

तुम भी गोल्फ, नकारात्मक से अधिक सकारात्मक समाधान पसंद जब वे बराबर हैं बदलकर कर सकते हैं _1 1करने के लिए 1 _1।

— algorithmshark
स्रोत

2

जावास्क्रिप्ट 86

n=>{s=(n+'').split('');for(i=0,j=s.length-1;i<j;i++,j--)s[j]=s[i];return s.join('')-n}

यह मेरी पहली कोडगोल्फ चुनौती है। आशा है कि यह समाधान स्वीकार्य है।

ungolfed: n => { s = (n + '').split(''); for (i = 0, j = s.length - 1; i < j; i++,j--) s[j] = s[i]; return s.join('') - n } स्पष्टीकरण:
इनपुट n को स्ट्रिंग में विभाजित करें और विभाजित करें।
परिणामी सरणी के दोनों किनारों पर फेरबदल करें और s [i] से s [j] तक <i> j पर कॉपी डिजिट करें। यह हमारे वांछित तालमेल का परिणाम देगा।
एक्स के साथ वापस आएँ और x को प्राप्त करने के लिए n को घटाएँ

— Beldraith
स्रोत

PPCG में आपका स्वागत है! इस उत्तर में सही संरचना है (फ़ंक्शन सबमिशन सामान्यतः जावास्क्रिप्ट में सबसे अच्छा काम करते हैं), और सही उत्तर भी देते प्रतीत होते हैं। यह एल्गोरिथ्म क्यों काम करता है (यह मेरे लिए स्पष्ट नहीं है कि यह क्यों करता है) की व्याख्या के माध्यम से आपकी पोस्ट को बेहतर बनाया जा सकता है, लेकिन यह इस समय ठीक है।

धन्यवाद, ive ने एक छोटी सी व्याख्या और एक असम्बद्ध संस्करण जोड़ा

— बेल्ड्रिथ

आप बदल सकते हैं s=(n+'').split('')करने के लिए s=[...(n+'')]। 5 बाइट्स से दाढ़ी बनाने के लिए

— ब्रायन एच।

मैं भी इसी तरह सोच रहा था, लेकिन 19 को पहला पलटवार लगता है: f(19)=3क्योंकि 22 सबसे करीब है, लेकिन फंक्शन रिटर्न -8 को 19 में परिवर्तित करने के लिए 11. btw [...n+'']एक अतिरिक्त -2 बाइट्स के लिए भी काम करेगा

— शायरु असक्कार

2

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

n=>[...(''+n)].reduce((p,c,i,s,m=s.length-1)=>i<m/2?p+(c-s[m-i])*Math.pow(10,i):p,0)

मेरी पहली गोल्फ चुनौती! मुझे पता है कि छोटा और अधिक सुरुचिपूर्ण समाधान पहले ही @Brian H. द्वारा पोस्ट किया जा चुका है, लेकिन यह एक और तरीका है।

टेस्ट कोड

कोड स्निपेट दिखाएं

const t =
n=>[...(''+n)].reduce((p,c,i,s,m=s.length-1)=>i<m/2?p+(c-s[m-i])*Math.pow(10,i):p,0)
;

console.log('t(3) =', t(3)); // expected: 0
console.log('t(234) =', t(234)); // expected: -2
console.log('t(1299931) =', t(1299931)); // expected: -10
console.log('t(126) =', t(126)); // expected: -5

स्निपेट का विस्तार करें

— yetirs
स्रोत

1

PPCG में आपका स्वागत है!

— स्टेडीबॉक्स

2

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

;.≜+A↔A∧

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

यहाँ लेबल का विधेय ≜महत्वपूर्ण है, क्योंकि कुछ भी होने से पहले आउटपुट पर इसका उपयोग करने से (हालाँकि यह वास्तव में इनपुट और आउटपुट युक्त सूची पर लागू किया जा रहा है), इसका निरपेक्ष मान कम से कम है, क्योंकि इसके बजाय कुछ भी होशियार आधारित हो सकता है कार्यक्रम में बाधाएं 0 से शुरू होने वाले प्रत्येक पूर्णांक का अनुमान लगाती हैं जब तक कि यह एक ऐसा नहीं मिल सकता है जो काम करता है। यदि ≜छोड़ दिया जाता है, तो यह प्रोग्राम पर dawns कि 0 एक बहुत अच्छा palindrome है, और यह हमेशा इनपुट के नकारात्मक को आउटपुट करेगा ।

            The input
;  +        plus
 .          the output
  ≜         which is instantiated immediately
    A       is A
     ↔      which reversed
      A     is still A
       ∧    but isn't necessarily the output.

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

1

ग्रूवी - 131 111 107 चार्ट

golfed:

n=args[0] as long;a=n;b=n;f={if("$it"=="$it".reverse()){println it-n;System.exit 0}};while(1){f a++;f b--}

नमूना चलता है:

bash-2.02$ groovy P.groovy  0
0
bash-2.02$ groovy P.groovy  234
-2
bash-2.02$ groovy P.groovy  1299931
-10
bash-2.02$ groovy P.groovy  123456789012345
-1358024

Ungolfed:

n=args[0] as long
a=n
b=n
f={ if("$it"=="$it".reverse()) {
       println it-n
       System.exit 0
    }
}

while(1) {
    f a++
    f b--
}

— माइकल ईस्टर
स्रोत

1

अजगर 2 - 76

i=input()
print sorted([r-i for r in range(2*i)if`r`==`r`[::-1]],key=abs)[0]

इनपुट नंबर प्राप्त करता है और इनपुट और प्रत्येक संख्या के बीच के अंतरों की एक सूची बनाता है 0और 2*iकेवल तभी जब वह संख्या palindromic हो।

यह तब सूची को निरपेक्ष मान से क्रमबद्ध करता है और पहले तत्व को प्रिंट करता है।

— BeetDemGuise
स्रोत

मुझे नहीं लगता कि रेंज (2 * i) बड़े इनपुट के लिए काम करेगी।

— मूप

आप minसॉर्ट करने के बजाय एक कीवर्ड तर्क के साथ उपयोग कर सकते हैं ।

— xnor

उस लंबी दूरी का उपयोग करने के लिए, आपको अपनी मेमोरी को ओवररनिंग करने से बचने के लिए, xrange पर स्विच करना होगा, जो कि एक जनरेटर और मिन-सर्किट है।

— isaacg

1

सी ++ 289

<algorithm>विधि का उपयोग करते हुए palindromes के लिए फ़ंक्शन पी चेक ।

Ungolfed:

bool P(int32_t i)
{
string a,b;
stringstream ss;
ss<<i;
ss>>a;
b=a;
reverse_copy(b.begin(),b.end(),b.begin());
int k=a.compare(b);
return (k==0);
}
int main()
{
int32_t n; cin>>n;
int32_t x=0,y=n,z=n,ans=x;
while(1)
{
if(P(y)){ans=x; break;}
if(P(z)){ans=-1*x; break;}
x++;
y+=x;
z-=x;
}
cout<<ans<<endl;
return 0;
}

— bacchusbeale
स्रोत

सब कुछ एक लाइन पर रखना कम होगा।

— बिल्ली

1

गणितज्ञ 75५

शायद और अधिक गोल्फ हो सकता है ..

p = (j=0; b=#; While[a=IntegerDigits[b]; b += ++j(-1)^j; a!=Reverse[a]]; #-b+(-1)^j) &

रिक्त स्थान न तो गिना जाता है और न उसकी आवश्यकता होती है।

— freddieknets
स्रोत

1

कॉफ़ीस्क्रिप्ट: 73

(x)->(x+="")[0...(y=x.length/2)]+x[0...-y].split("").reverse().join("")-x

स्पष्टीकरण: यह इस तथ्य का लाभ उठाता है कि अगर हमारे पास विषम लंबाई (जैसे 1234567) है, x.slice(0, y)तो इसमें मध्य अंक / इच्छा शामिल नहीं x.slice(0, -y)होगी। जावास्क्रिप्ट sliceशायद इस तरह से काम नहीं करना चाहिए , लेकिन यह करता है।

मैं उम्मीद कर रहा था कि CoffeeScript / जावास्क्रिप्ट एक स्ट्रिंग को रिवर्स करने का एक बेहतर तरीका है, लेकिन विभाजन / रिवर्स / जॉइन विधि ऐसा लगता है कि सब कुछ है।

— जस्टिन मॉर्गन
स्रोत

1

PHP, 56 बाइट्स

for(;strrev($i+$n=$argv[1])-$n-$i;$i=($i<1)-$i);echo+$i;

कमांड लाइन तर्क से इनपुट लेता है; साथ चलाना -nr।

— टाइटस
स्रोत

1

जावास्क्रिप्ट 68 बाइट्स

(n,s=[...(''+n)],j=s.length)=>s.map((v,i,)=>i>--j?s[j]:v).join('')-n

विशाल एल्गोरिथ्म के लिए @Beldraith के लिए सहारा, मैं एक जवाब के रूप में यह पोस्ट कर रहा हूँ, क्योंकि यह मुझे एक ही बयान में काम करने के लिए इसे पाने के लिए काफी समय लगा।

किसी भी सुझाव का स्वागत है;)

ungolfed

(
    n, // input
    s=[...(''+n)], // input split to array of chars
    j=s.length, // highest available index in s
)=> 
s.map( // this will return a new array, without modifying s
    (
        v, // value of current iteration
        i, // index of current iteration
    )=> i > --j ? s[j] : v
).join('') - n

— ब्रायन एच।
स्रोत

@Beldraith उम्मीद है कि आप मुझे एक भी बयान समारोह के लिए अपना जवाब देने में कोई आपत्ति नहीं करेंगे, मैं एक विस्फोट कर रहा था: D

— ब्रायन एच।

63 में गोल्फ खेलने योग्य: (n,s=[...n+''],j=s.length)=>s.map((v,i)=>i>--j?s[j]:v).join``-nलेकिन एक गैर-स्पष्ट

— प्रतिरूप

ouch, यह सिर्फ 19 नहीं है, यह कोई भी संख्या है जो 9 के साथ समाप्त होती है और एक सकारात्मक परिणाम प्राप्त करना चाहिए

— ब्रायन एच।

0

अजगर, 109

def q(x,z):
 r=lambda s:int(str(s)[::-1])
 if x+z==r(x+z):return z
 if x-z==r(x-z):return -z
 return q(x,z+1)

— RageCage
स्रोत

रनिंग करते समय यह एक त्रुटि देता है (अधिकतम पुनरावृत्ति गहराई अधिक हो गई)

— Moop

यह मेरे कोड में कोई त्रुटि नहीं है। यह एक बड़े पैमाने पर अधिकतम पुनरावृत्ति की गहराई को पार कर जाएगा, लेकिन यह शालीनता से आकार की संख्याओं पर काम करता है। चूंकि चश्मे में कोई अधिकतम परीक्षण मामला नहीं था, इसलिए इसे अभी भी एक वैध समाधान माना जाना चाहिए।

— RageCage

1

123456789प्रश्न में पोस्ट की गई 10 ^ 15 की सीमा के ठीक नीचे यह संख्या विफल हो जाती है।

— Moop

1

आप आसानी से पुनरावृत्ति को एक लूप में बदल सकते हैं और इस मुद्दे से पूरी तरह से बच सकते हैं

— Moop

1

स्टैकलेस पायथन कार्यान्वयन में इसे चलाने से पुनरावृत्ति की गहराई के मुद्दे से बचना चाहिए।

— एक्सनोर

0

QBIC , 38 बाइट्स, एन.सी.

:{[-1,1,2|A=!a+b*c$~A=_fA||_xb*c]c=c+1

स्पष्टीकरण:

कोड एक इनपुट पढ़ता है, और फिर एक संशोधक लागू होता है। इसके बाद यह देखने के लिए परीक्षण किया जाता है कि क्या संख्या + संशोधक एक पैलिंड्रोम है। फिर, यह संशोधक पर आहें भरता है, फिर से लागू होता है और फिर से परीक्षण करता है।

:{        Read the input value, start a DO-loop
[-1,1,2|  FOR (b = -1; b <= 1; b+=2 )
A=!a+b*c$ Get a string from the input number, 
            plus modifier c (which is 0 at the start of QBIC)
            times -1 or 1, depending on b's iteration.
~A=_fA|   if that string is equal to it's own reversed version
|_xb*c]   then Quit, printing the modifier * sign
c=c+1     Increment the modifoer and DO-LOOP again.
          The DO-loop is implicitly closed by QBIC at EOF

— steenbergh
स्रोत

0

बैश, 73 बाइट्स

i=$1;x=$i;while((x-10#$(rev<<<$x)));do ((r=(1>r)-r,x=r+i));done;echo $x

इनपुट 1 कमांड लाइन तर्क पर जाता है:

foo.sh 123456789

— iBug
स्रोत

0

Axiom, 720 594 412 बाइट्स

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)
D(a:NNI):INT==(p(0,a)=1=>0;w:=p(-1,a);s:=p(1,a);a-w<s-a=>w-a;s-a)

बाइट गिनती यह फिर से यह है, लेकिन यह अहंकार यह ओ (लॉग (एन)) होगा क्योंकि यह केवल इसके इनपुट (और log10 (एन) के लंबित अंकों से होगा) एन के दशमलव अंकों की सीमा के पास होगा )। असमतल और परिणाम

-- Ritorna il precedente numero palidrome rispetto ad 'a' NNI, se r<0
--                               ha la particolarita' palpn(-1,0) = 0
-- Ritorna il successivo numero palidrome rispetto ad 'a' NNI, se r>0
-- Se r=0 ritorna 1 se 'a' e' palindrome, 0 se 'a' non e' palindrome
R(x)==>return x
palpn(r,a)==
    n:=#(a::String) -- n la lunghezza in cifre di base 10 di a
    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 -- because here not there is a goto instruction i have to use 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) -- for r==0
    c

-- Ritorna la distanza minima tra l'input 'a' e una palindrome:
--        0 se 'a' e' una palindrome
--        r numero con segno negativo se tale palindrome precede 'a'
--        r numero con segno positivo se tale palindrome e' successiva ad 'a'
palDistance(a:NNI):INT==
    palpn(0,a)=1=>0
    p:=palpn(-1,a);s:=palpn(1,a)
    a-p<s-a=>p-a
    s-a

--------------------------------------

(3) -> [[i,D(i)] for i in [3,10,234,1299931,126]]
   (3)  [[3,0],[10,1],[234,- 2],[1299931,- 10],[126,5]]
                                                  Type: List List Integer
(4) -> D 7978986575546463645758676970789089064235234524548028408198401348930489104890184018410
   (4)  - 199223418598327604580355025458434427119613
                                                            Type: Integer
(5) ->  p(0,7978986575546463645758676970789089064235234524548028408198401348930489104890184018410+%)
   (5)  1
                                                    Type: PositiveInteger
(6) -> 7978986575546463645758676970789089064235234524548028408198401348930489104890184018410+%%(-2)
   (6)
       7978986575546463645758676970789089064235234325324609809870796768575463646455756898797
                                                    Type: PositiveInteger

— RosLuP
स्रोत

लोगों ने फिर से बोला था (या पूर्ण उन्मूलन के लिए) कंप्यूटर भाषाओं के लिए गोटो का उपयोग, मेरे विनम्र शौक प्रोग्रामर के लिए संभावित: सूचना विज्ञान में अक्षम हैं !!!!

— रोजलूपी

0

भूसी , 16 12 9 बाइट्स

ḟoS=↔+⁰İZ

धन्यवाद @ H.Wiz -4 बाइट्स के लिए!

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

व्याख्या

ḟ(S=↔+⁰)İZ  -- input ⁰ a number, for example: 126
        İZ  -- built-in integers: [0,1,-1,2,-2...]
ḟ(     )    -- first element that satisfies the following (eg. 5):
     +⁰     --   add element to input: 131
  S=        --   is it equal to itself..
    ↔       --   ..reversed: 131 == 131

— ბიმო
स्रोत

0

APL NARS 47 चरस

r←s a;b
r←0
A:b←⍕a+r⋄→0×⍳b≡⌽b⋄r←-r⋄→A×⍳r<0⋄r+←1⋄→A

यह ऊपर की खोज है, लेकिन नीचे के जी के रूप में अलगो तेज और सही नहीं हो सकता ...

यह

A:b←⍕a+r⋄→0×⍳b≡⌽b⋄r←-r⋄→A×⍳r<0⋄r+←1⋄→A

केवल एक साधारण लूप निकास है जब यह b onlyb लगता है तो b एक स्ट्रिंग पैलिंड्रोम है

  s¨3,10,234,1299931,126
0 1 ¯2 ¯10 5 

∇r←g w;n;a;y;t;o;h;v
         r←0J1
   →0×⍳0≠⍴⍴w⋄→0×⍳''≡0↑w ⍝ if arg is not scalar int>=0→0J1
   →0×⍳(w<0)∨w≠⌊w
   h←{z←⍕⍺⋄q←⍕⍵⋄⍎(z,⌽q)}⍝ h return as digit ⍺⌽⍵
   n←⍴⍕w⋄r← 0
   →0×⍳n≤1              ⍝ arg one digit return r←0
   a←10*⌊n÷2
B: v←a⋄→C×⍳∼2∣n⋄v←a×10
C: t←⌊w÷v ⋄y←⌊w÷a
   o←y h t⋄r←(y+1)h t+1
   →D×⍳∼(∣r-w)<∣o-w⋄r←r-w⋄→0
D: r←o-w
∇

  g¨3,10,234,1299931,126
0 1 ¯2 ¯10 ¯5

— RosLuP
स्रोत

0

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

l=lambda n,d=0:`n+d`!=`n+d`[::-1]and l(n,~d+(d<0))or d

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

— अरबो
स्रोत

0

जाप , 8 बाइट्स

nÈ¥sw}cU

कोशिश करो

nÈ¥sw}cU     :Implicit input of integer U
      cU     :Get the first number in the sequence [U,U-1,U+1,U-2,U+2,...,U-n,U+n]
 È           :That returns true when passed the the following function
  ¥          :  Test for equality with
   s         :  Convert to string
    w        :  Reverse
     }       :End function
n            :Subtract U from the result

— झबरा
स्रोत

निकटतम palindromic संख्या का पता लगाएं

अजगर , २६ २०

रूबी, 111 84 बाइट्स

CJam, 34 29 25 बाइट्स

उदाहरण

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

हास्केल - 62

पायथन 2.7, 98 , 81

पर्ल 5, 93 89 88 87 75 63 44

05AB1E , 15 14 बाइट्स (-1 Emigna के लिए धन्यवाद)

तरीका:

जावा: 127 109

क्लोजर, 92

जावास्क्रिप्ट, 175 136 117

जे - ४ ९ चार

जावास्क्रिप्ट 86

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

टेस्ट कोड

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

ग्रूवी - 131 111 107 चार्ट

अजगर 2 - 76

सी ++ 289

गणितज्ञ 75५

कॉफ़ीस्क्रिप्ट: 73

PHP, 56 बाइट्स

जावास्क्रिप्ट 68 बाइट्स

ungolfed

QBIC , 38 बाइट्स, एन.सी.

बैश, 73 बाइट्स

Axiom, 720 594 412 बाइट्स

भूसी , 16 12 9 बाइट्स

व्याख्या

APL NARS 47 चरस

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

जाप , 8 बाइट्स