35

196-एल्गोरिदम के लिए एक छोटा कार्यक्रम लिखें । एल्गोरिथ्म एक पूर्णांक से शुरू होता है, फिर एक पलिंड्रोम तक पहुंचने तक इसके विपरीत को इसमें जोड़ता है।

जैसे

input = 5280
5280 + 0825 = 6105
6105 + 5016 = 11121
11121 + 12111 = 23232
output = 23232

इनपुट

एक पूर्णांक, जो एक लिकरेल संख्या नहीं है (अर्थात, यह अंत में इस एल्गोरिथ्म के तहत एक पैलिंद्रोम प्राप्त करता है, बजाय असीम रूप से जारी रखने के)

उत्पादन

पालकी पहुंच गई।

code-golf palindrome

— Eelvex
स्रोत

6

क्योंकि आपका सवाल शायद 196 के एल्गोरिथम को शामिल करने वाला ही है। एकल-उपयोग टैग बनाना उपयोगी नहीं है।

— क्रिस जेस्टर-यंग

2

क्या मैं मतलब था, आपके सवाल का केवल एक ही होने की संभावना है कभी भी 2 साल के समय में, इस विषय को शामिल करने की। :-)

— क्रिस जेस्टर-यंग

1

@ क्रिस: ठीक है, 196-एल्गोरिथ्म एक बहुत लोकप्रिय एक है, कई अलग-अलग नामों से जा रहा है। बस यह सुनिश्चित करने के लिए, हालांकि, मैं 2 साल के समय से पहले इसके बारे में एक और सवाल पोस्ट करूंगा;)

— 9

1

@GigaWatt ने भी, मुझे आपके मुट्ठी के सवाल को याद किया था :) बस A023108 के मामले से परेशान न हों।

— बारहवीं

1

@Joel, A023108 के साथ, बस उन्हें अनदेखा करें (जैसे आप उनके बारे में नहीं जानते हैं); हम नहीं जानते कि क्या किसी भी तरह से मौजूद है।

— आठ

10

एपीएल (22 अक्षर)

{a≡⌽a←⍕(⍎⍵)+⍎⌽⍵:a⋄∇a}⍞

यह Dyalog APL में काम करता है। यहां एक स्पष्टीकरण दिया गया है, दाएं से बाएं

{ ... }⍞: चरित्र से उपयोगकर्ता के रूप में इनपुट प्राप्त करें ( ⍞) और इसे हमारे फ़ंक्शन ( { ... }) को खिलाएं ।
प्रत्यक्ष कार्य के भीतर ( ⋄बयानों को अलग करता है, इसलिए हम उन्हें बाएं से दाएं देखते हैं):
- a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: मूल्यांकन ( ⍎) सही तर्क का ( ⍵) रिवर्स ( ⌽), और सही तर्क के मूल्यांकन किए गए संस्करण में जोड़ें। फिर, परिणाम को प्रारूपित करें ( ⍕यानी, इसके चरित्र को प्रतिनिधित्व दें), असाइन करें ( ←) कि चर के लिए a, और अंत में परीक्षण करें कि क्या aरिवर्स रिवर्स के बराबर है a(यानी, aएक पैलिंड्रोम है?)। अगर सच है, लौटाओ a; अन्यथा...
- ∇a: aहमारे समारोह में वापस फ़ीड ( ∇निहित आत्म-संदर्भ है)।

उदाहरण:

      {a≡⌽a←⍕(⍎⍵)+⍎⌽⍵:a⋄∇a}⍞
412371
585585

— डिलन कॉवर
स्रोत

2

यह संख्यात्मक इनपुट का उपयोग करने के लिए कुछ वर्ण बचाता है। {⍵=A←⍎⌽⍕⍵:⍵⋄∇A+⍵}⎕। आप ब्रेसिज़ को बचाते हैं, एक रिवर्स और एक ईवैल।

— मारिनस

10

GolfScript, 29 वर्ण

~]{{.`.-1%.@={;0}{~+1}if}do}%

चयनित टिप्पणी

कार्यक्रम का मांस doलूप है, ज़ाहिर है। तो मैं अभी कवर करूंगा।

.` संख्या की प्रतिलिपि बनाता है और इसे स्ट्रिंग करता है।
.-1% उस स्ट्रिंग संस्करण को कॉपी करता है और उसे उलट देता है।
.@ उल्टे संस्करण की प्रतिलिपि बनाता है, और मूल गैर-उलटा संस्करण सामने लाता है।

तो, कहते हैं, संख्या 5280 है। इस स्तर पर, स्टैक है 5280 "0825" "0825" "5280":। तुलना के लिए चरण निर्धारित है। (तुलना के बाद, स्टैक को 5280 "0825"कोई फर्क नहीं छोड़ा जाएगा कि क्या --- तुलना करने वाली वस्तुओं को पॉपअप किया गया है।)

यदि स्ट्रिंग और रिवर्स समान हैं, तो हम उल्टे स्ट्रिंग के बारे में परवाह नहीं करते हैं, इसलिए बस इसे बंद करें ( ;) और 0 लौटें ( doलूप को समाप्त करने के लिए )।
यदि वे मेल नहीं खाते हैं, तो मूल्यांकन करें ( ~) उलट स्ट्रिंग (इसे एक संख्या बनाने के लिए), +मूल संख्या में जोड़ें ( ) और 1 लौटें ( doलूप जारी रखने के लिए )।

— क्रिस जस्टर-यंग
स्रोत

4

क्या आप वाकई अपने कीबोर्ड पर रैंडम कीज़ नहीं दबाते हैं? ऐसा लग रहा है ...

1

@ M28: गोल्फस्क्रिप्ट पर्ल की तुलना में अधिक शोर की तरह दिखता है, है ना? ;-)

— क्रिस जेस्टर-यंग

मुझे आपके लिए खेद है, यह कोड करने के लिए दर्दनाक होना चाहिए

@ M28: यह लगभग उतना दर्दनाक नहीं था जितना मैंने लुहान एल्गोरिदम के लिए लिखा था । बस उसी के बारे में सोचते हैं। :-P

— क्रिस जस्टर-यंग

आपका परिवार आपके लिए चिंतित है

10

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

JPvdMerwe सुझाव के बाद:

n=input()
while`n`!=`n`[::-1]:n+=int(`n`[::-1])
print n

पायथन 2, 62:

n=raw_input()
while n!=n[::-1]:n=`int(n)+int(n[::-1])`
print n

— एलेक्ज़ेंड्रु
स्रोत

Hehe ..)))))))))

— नाकिलन

2

nएक इंट के रूप में देख कर आप 6 वर्णों को छोटा कर सकते हैं, कोड की जाँच करें: meta.codegolf.stackexchange.com/q/75/62

— JPvdMerwe

लगता है कि मैंने गलती से नई लाइन विम चुपके से मेरी फ़ाइल के अंत में मेरी गिनती में जोड़ा। असली गिनती 55 है

— JPvdMerwe

7

रूबी - 56 वर्ण

x,r=gets
x="#{x.to_i+r.to_i}"until x==r=x.reverse
puts x

— Nakilon
स्रोत

7

सिर्फ मेरे पाइथ स्किल्स का प्रयोग करना, गंभीर दावेदार नहीं।

पायथ, 16 बाइट्स

L?bqb_by`+vbi_bTyz

पायथन 3 के बराबर:

y=lambda b:b if b==b[::-1] else y(str(eval(b)+int(b[::-1],10)))
print y(input())

— swstephe
स्रोत

बस कुछ पुरानी चुनौतियों की कोशिश कर रहा है, पहले से ही जवाब दिया है, इसलिए गंभीर दावेदार नहीं है।

— स्वस्तिक

1

कुछ चुनौती लेखक स्वीकार किए गए उत्तर को अपडेट करेंगे यदि एक छोटा समाधान आता है, तो मुझे लगता है कि ओपी को सूचित करना उचित है, कि यह तकनीकी रूप से एक वैध प्रस्तुत नहीं है। (मुझे गलत मत समझो, मुझे मस्ती के लिए सीजेएम के साथ पुरानी चुनौतियों का जवाब देना पसंद है, - और मैंने अभी कुछ मिनट पहले किया था। मैं बस कह रहा हूं, अगर आप ऐसा करते हैं, तो ध्यान दें, कि भाषा नई है। चुनौती।)

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

वास्तव में "एक गंभीर दावेदार नहीं" होने के कारण एक विलोपन का उत्तर दिया जाता है - लेकिन मुझे कोई कारण नहीं दिखता कि इसे गंभीर दावेदार नहीं माना जाना चाहिए।

— pppery

6

जे २५ २ ^{27 ३१}

f=:(+g)^:(~:g=.|.&.":)^:_
e.g.
f 5280
23232

— Eelvex
स्रोत

6

CJam, 22 21 बाइट्स

इस सवाल के पूछे जाने के बाद CJam को बनाया गया था, इसलिए तकनीकी रूप से यह एक अवैध सबमिशन है। लेकिन मुझे यह सवाल दिलचस्प लगा, इसलिए यहाँ जाता है:

r{__W%:X=0{~X~+s1}?}g

स्पष्टीकरण:

r{                 }g    "Read the input number as string and enter a while-do loop";
  __                     "Make 2 copies of the string number";
    W%:X                 "Reverse the second and store it in X";
        =                "Check if the number is already palindrome";
         0{      }?      "Put 0 on stack if it is palindrome, else, run the code block";
           ~             "Convert the string to int";
            X~           "Put the reverse string on stack and convert it to int too";
              +s         "Add the two numbers and covert back the result to string";

मुख्य तर्क यह है कि प्रत्येक बार-बार पुनरावृत्ति करते समय, आप पहले जांचते हैं कि क्या palindrome हासिल हुआ है या नहीं। यदि नहीं, तो संख्या में रिवर्स जोड़ें। बहुत ज्यादा एल्गोरिथ्म क्या है!

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

5

यह एक वास्तविक दावेदार है, क्योंकि जे दशकों से आसपास है।

जे (16 बाइट्स)

(+^:~:|.&.":)^:_

यह एक क्रिया है, इसलिए इसे J सत्र में एक चर को सौंपा जा सकता है और इसका उपयोग किया जा सकता है:

   f =. (+^:~:|.&.":)^:_
   f 5280
23232

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

(+^:~:|.&.":)^:_
 +^:~:           add if unequal
      |.&.":     reverse under string format
 +^:~:|.&.":     add reverse unless a palindrome
(           )^:_ repeat until unchanged

— टॉम
स्रोत

4

अजगर: 66

n=input()
while 1:
 r=int(`n`[::-1])
 if n==r:break
 n+=r
print n

— marcog
स्रोत

4

पर्ल, 40 वर्ण

$_=<>;$_+=$r while$_!=($r=reverse);print

— ninjalj
स्रोत

मुझे पता है कि यह एक बहुत पुरानी पोस्ट है लेकिन कुछ बदलाव इसे 26 बाइट्स तक कम कर सकते हैं: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

4

स्काला 82

def p(n:Int):Int={val s=n.toString.reverse.toInt
if(n==s)n else p(n+s)}
p(readInt)

— अज्ञात उपयोगकर्ता
स्रोत

4

JAGL अल्फा 1.2 - 19, 21 स्टड के साथ

प्रतिवाद नहीं , बस मेरी भाषा के साथ कुछ अनुभव प्राप्त करना
स्टड से एक संख्या कीअपेक्षा करता है

T~d{DddgCi+dgdC=n}uSP

व्याख्या

T~                       Get a line of input, and eval to an integer
  d                      Duplicate (for first round)
   {Ddd                  Drop last and duplicate twice
       gCi               Convert to string, reverse, and convert back to integer
          +d             Add to original and duplicate
            gdC          Convert to string, duplicate, reverse
               =n}       If it isn't a palindrome, keep going
                  uSP    Run until palindrome reached, then print output number

— globby
स्रोत

संपादित। @Optimizer

— globby

कृपया अपने सभी सबमिशन को एक बार मामूली संपादन (जैसे कि एक संस्करण संख्या) के लिए संपादित न करें, क्योंकि यह अनावश्यक रूप से फ्रंट पेज को बंद कर देता है। यदि आप एक बार में 2 या शायद 3 करते हैं तो यह ठीक है, लेकिन अधिक व्यवस्थित संपादन करने से पहले कुछ घंटे प्रतीक्षा करें।

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

यह भूल गया कि यह मेरे बुरे पेज को आगे बढ़ाएगा। @ MartinBüttner

— globby

4

05AB1E , 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

गैर-प्रतिस्पर्धात्मक , चूंकि भाषा चुनौती का सामना करती है।

कोड:

[DÂQ#Â+

स्पष्टीकरण:

[        # Infinite loop.
 DÂ      # Duplicate and bifurcate (which duplicates it and reverses the duplicate).
   Q#    # If the number and the number reversed are equal, break.
     Â+  # Add the reversed number to the initial number.

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

— अदनान
स्रोत

क्या आप द्विभाजन की प्रक्रिया पर कुछ और बता सकते हैं?

— कॉनर ओ'ब्रायन

1

@ C @O'Bʀɪᴇɴ उदाहरण के लिए, स्टैक पर स्ट्रिंग है hello। द्विभाजन मूल स्ट्रिंग को रखेगा, और स्ट्रिंग को उल्टा धकेलता है। यह डुप्लिकेट और रिवर्स के लिए छोटा है ।

— अदनान

ओह मैं समझा। ठंडा! धन्यवाद

— कॉनर ओ'ब्रायन

4

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

↔?|↔;?+↰

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

कुछ हद तक पहले ब्रेकीलॉग कार्यक्रमों में से एक के समान है जिसे मैंने देखा था और ब्राचीलॉग परिचय वीडियो से अंतर्ज्ञान किया था ।

?↔?.|↔;?+↰.  (initial ? and the .s are implicit)

?↔?          % If the input and its reverse are the same,
   .         %   then the input is the output
    |↔;?+↰   % Or, add the input and its reverse, and call this predicate recursively
          .  % The result of that is the output

— sundar - मोनिका को बहाल करना
स्रोत

3

PHP - ५४ ४ characters अक्षर

<?for($s=`cat`;$s!=$r=strrev($s);$s+=$r);echo$s;

परीक्षा:

$ php 196.php <<< 5280
23232

— अरनौद ले ब्लांक
स्रोत

मैं $str = भविष्य में गोल्फ के लिए बिल्ली की बात को याद रखने जा रहा हूं । उपयोग करने की तुलना में बहुत बेहतर STDINऔर अभी भी की तुलना में बेहतर है $argv[0]।

— श्री लामा

@ गीगावाट: $ s = 'm4' भी काम करना चाहिए।

— नवजाल

3

बैश (64)

X=`rev<<<$1|sed s/^0*//`;[ $1 = $X ]&&echo $1||. $0 $(($1+$X))

इसके साथ कॉल करें: bash <filename> <नंबर>

— मारीनस
स्रोत

के लिए <फ़ाइल नाम> क्या है?

— आठवीं

2

@ बारहवीं स्क्रिप्ट को खुद को कॉल करने की आवश्यकता है ताकि आपको इसे एक फ़ाइल में संग्रहीत करने की आवश्यकता हो।

— मारिनस

3

सी # - 103 99 चार्ट

public int P(int i)
{
    var r = int.Parse(new string(i.ToString().Reverse().ToArray())));
    return r == i ? i : P(i + r);        
}

गोल्फ में सी # कभी भी बहुत अच्छा नहीं करता है। सुरुचिपूर्ण, लेकिन क्रिया।

— Keiths
स्रोत

1

आप आसानी से इसे और अधिक गोल्फ कर सकते हैं। .ToString के बजाय "" + का उपयोग करें और कुछ स्थानों से छुटकारा पाएं।

— याकूब

3

क्यू में (39 अक्षर)

f:{while[x<>g:"I"$reverse -3!x;x+:g];x}

नमूना उपयोग:

q)f 5280
23232

संपादित करें:

34 से नीचे अब, एक ही उपयोग:

{while[x<>g:"I"$(|) -3!x;x+:g];x} 5280

— sinedcm
स्रोत

3

r=input()
while 1:
    r=`r`
    if r==r[::-1]:
      break
    else:
      r=int(r)+int(r[::-1])

print r

— अश्विनी चौधरी
स्रोत

3

जेली , 9 बाइट्स (गैर प्रतिस्पर्धी)

बस और गूढ़ भाषा में कोडिंग की चुनौती के लिए एक बहुत ही सरल जवाब।

ṚḌ+µŒḂ¬$¿

ṚḌ        : take the argument, reverse (and vectorize) it
  +µ      : add both
    ŒḂ¬$¿ : while the result isn't a palindrome

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

क्या यह उत्तर किसी भी स्तर पर अस्पष्ट या गलत होना चाहिए, इसे इंगित करने के लिए स्वतंत्र महसूस करें।

कोड के इस पहले छोटे टुकड़े के साथ मेरी मदद करने के लिए डेनिस का धन्यवाद।

— z3r0
स्रोत

वाह, हर कोई अपनी पहली पोस्ट में जेली का उपयोग नहीं करता है।

— निसा

यह एक गूढ़ भाषा का उपयोग करके PPCG पर एक उत्तर पोस्ट करने के लिए मेरी टू-डू सूची पर था। जेली पहली बार मेरे बारे में सोचा गया :)

— z3r0

2

अजगर। 85 अक्षर:

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n));print n

यदि आप प्रत्येक पुनरावृत्ति पर आउटपुट नहीं चाहते हैं:

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n))
print n

(एक कम चरित्र)

— थॉमस ओ
स्रोत

कार्य विवरण बताता है कि केवल अंतिम पैलिंड्रोम मुद्रित किया जाना चाहिए।

— जॉय

2

विंडोज पॉवरशेल (63)

for($a=+"$input";-join"$a"[99..0]-ne$a){$a+=-join"$a"[99..0]}$a

मैं अभी भी इसे नफरत करता हूं कि एक स्ट्रिंग को रिवर्स करने का कोई आसान तरीका नहीं है।

— एक छोटा सा सिक्का
स्रोत

दो वर्णों को छोटा किया जा सकता है यदि केवल कभी इनपुट के दस अंक हों। इस तरह यह सुरक्षित है और longसाथ ही जो सबसे बड़ा अभिन्न प्रकार है पावरस्ले वैसे भी समर्थन करता है लेकिन फिर भी, मैं दो वर्णों को बर्बाद करता हूं।

— जॉय

2

हास्केल 89 87 वर्ण

r=read.reverse.show
main=getLine>>=print.head.filter(\x->x==r x).iterate(\x->x+r x).read

कुछ पठनीय संस्करण:

myFind p = head . filter p
rev = read . reverse . show
isPalindrome x = x == rev x
next x = x + rev x
sequence196 = iterate next
palindrome196 = myFind isPalindrome . sequence196

main = getLine >>= print . palindrome196 . read

गोल्फ का संस्करण मैनुअल इनलाइनिंग द्वारा बनाया गया था और शेष कार्यों को एकल चरित्र नामों के नाम पर रखा गया था।

— sepp2k
स्रोत

1

आप untilPrelude से अप्रयुक्त फ़ंक्शन का लाभ लेने के साथ-साथ xऔर बाइनरी ऑपरेटर को लागू करने के पैटर्न को निकालकर इसे काफी छोटा कर सकते हैं r x। इसके अलावा, का उपयोग readLnकरने के बजाय getLineऔर read। परिणाम 20 अक्षर बचाता है:f%x=f x$read.reverse.show$x;main=readLn>>=print.until((==)%)((+)%)

— हमार

@ उमर: आप फंक्शन मॉनड का उपयोग कर सकते हैं और इससे भी अधिक बचा सकते हैं: परिभाषित करें r=(=<<read.reverse.show)और उपयोग करें r(==)`until`r(+)। उस बचत के अलावा, यह एक पूर्ण कार्यक्रम होने की आवश्यकता नहीं है, एक वैध सबमिशन केवल पहले से अनाम फ़ंक्शन हो सकता है। यह आपको 41 बाइट्स में लाता है: इसे ऑनलाइन आज़माएं!

— ।

2

befunge, 57 बाइट्स

"KCTS"4(&:0\v
\T\a*+\:0`jv>:a%\a/
0:+_v#-TD2$<^\
  @.<

हालांकि कोड एक 4x19 ग्रिड में जगह है, इसलिए इसे 76 कह सकते हैं।

पहली पंक्ति इनिशियलाइज़ हो रही है, और इनपुट नंबर को पढ़ना है
दूसरी पंक्ति स्टैक में पहली संख्या को उल्टा करती है और दूसरी स्टैक स्थिति में डालती है।
और तीसरी पंक्ति यह जाँचती है कि कोई संख्या पेलिंड्रोम है या नहीं।

— Ali1S232
स्रोत

2

C ++ TMP (256 अक्षर)

#include<cstdio>
#define Y(A,B,C,D)template<int N>struct A<C,D>{enum{v=B};};
#define Z(A)template<int N,int M>struct A{enum{v=
#define n 5194
Z(R)R<N/10,M*10+N%10>::v};};Y(R,N,0,N)Z(S)S<N+M,R<N+M,0>::v>::v};};Y(S,N,N,N)main(){printf("%d",S<n+R<n,0>::v,0>::v);}

इस संस्करण को थोड़ा छोटा किया जा सकता है, लेकिन 256 वर्णों वाला उत्तर पास करना कठिन है। यहाँ एक गैर-गोल्फ संस्करण है:

#include <iostream>

template<size_t N>
class Reverse
{
    template<size_t M, size_t R>
    struct Inner
    {
        enum { value = Inner<M/10, R*10 + M%10>::value };
    };

    template<size_t R>
    struct Inner<0, R>
    {
        enum { value = R };
    };

public:
    enum { value = Inner<N, 0>::value };
};

template<size_t N>
class OneNineSix
{
    template<size_t M, size_t R=Reverse<M>::value>
    struct Inner
    {
        enum { value = OneNineSix<M + R>::value };
    };

    template<size_t M>
    struct Inner<M, M>
    {
        enum { value = M };
    };

public:
    enum { value = Inner<N + Reverse<N>::value>::value };
};

int main()
{
    const size_t N = 4123;

    std::cout << OneNineSix<N>::value << std::endl;
}

— डिलन कॉवर
स्रोत

2

Pyke, 13 बाइट्स (नॉनकमेटिंग)

D`_b]D$XIsr)h

यहाँ कोशिश करो!

 `_b          -     int(reversed(str(num))
D   ]         -    [num, ^]
     D        -   _ = ^
      $       -  delta(^)
       XI     - if ^:
         s    -  num = sum(_)
          r   -  goto_start()
            h - _[0]

— नीला
स्रोत

2

++ , 57 बाइट्स जोड़ें

L,BDbRBv
D,f,@,1]A+
D,g,@,1]A=
D,h,@,{f}A{g}Q{h}
L,{h}2/i

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

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

L,	; Create a function 'lambda 1'
	; Example argument:   [5280]
    BD	; Digits;     STACK = [[5 2 8 0]]
    bR	; Reverse;    STACK = [[0 8 2 5]]
    Bv	; Undigits;   STACK = [825]

D,f,@,	; Define a monadic function 'f'
	; Example argument:         [5280]
    1]	; Call 'lambda 1';  STACK = [825]
    A+	; Add the argument; STACK = [6105]

D,g,@,	; Define a monadic function 'g'
	; Example argument:          [5280]
    1]	; Call 'lambda 1';   STACK = [825]
    A=	; Equal to argument; STACK = [0]

D,h,@,	; Define a monadic function 'h'
	; Example argument:  [5280]
   {f}	; Call 'f';  STACK = [6105]
   A{g}	; If 'g'...
   Q	;   Return
   {h}	; Else call 'h'

L,	; Define a function, 'lambda 2'
	; Example argument: [5280]
   {h}	; Call 'h'; STACK = [46464]
   2/i	; Halve;    STACK = [23232]

— केर्ड सिक्काहिरिंग
स्रोत

2

पॉवरशेल, 63 62 बाइट्स

-1AteBorkBork के लिए धन्यवाद

param($m)for(;$m-$s;$m=-join"$s"[-1..-"$s".Length]){$s+=$m};$s

टेस्ट स्क्रिप्ट:

$f = {
param($m)for(;$m-$s;$m=-join"$s"[-1..-"$s".Length]){$s+=$m};$s
}

&$f 5280

— Mazzy
स्रोत

1

आप की जरूरत नहीं है ;के बीच param($m)और for।

— AdmBorkBork

2

जीएनयू डीसी, 46 बाइट्स

जीएनयू डीसी, न्यूनतम संस्करण 1.4 ( Rकमांड के लिए) की आवश्यकता है।

[O~3RO*+rd0<R]sR[+lfx]sg[ddO~rd0<R+d3R!=g]dsfx

इनपुट और आउटपुट सामान्य रूप से टॉप-ऑफ-स्टैक हैं। यह डीसी में अंकों को उलटने के लिए एक आश्चर्यजनक राशि लेता है (जब तक कि मैं कुछ याद नहीं कर रहा हूं, जो असंभव से दूर है)। यह इस तरह के आदानों के साथ अच्छी तरह से व्यवहार करने के लिए संख्यात्मक सीमा है (जो उदाहरण के लिए 32-बिट अहस्ताक्षरित अतिप्रवाह करेगा):

89 ⇒ 8,813,200,023,188
8997 ⇒ 16,668,488,486,661
10677 ⇒ 4,668,731,596,684,224,866,951,378,664

व्याख्या

# Reverse digits, starting after first digit extracted
[O~3RO*+r d0<R]sR

# Recursion helper - add and recurse
[+ lfx]sg

# Main recursive function
[dd O~r d0<R+ d3R !=g]dsfx

— टोबी स्पाईट
स्रोत

इसे ऑनलाइन आज़माएं! (जावास्क्रिप्ट)

— टॉबी स्पीट

यह निर्दिष्ट करना चाहते हैं कि यह केवल GNU dc 1.4 पर काम करता है और बाद में, क्योंकि यह नया प्रयोग करता है R कमांड । अच्छा समाधान, हालांकि!

— सोफिया लेचनर

मैं पूरी तरह से अलग दृष्टिकोण पर काम कर रहा हूं, लेकिन यकीन नहीं है कि यह छोटा हो जाएगा।

— सोफिया लेचनर

धन्यवाद सोफिया - मुझे यह एहसास नहीं था R था नया था। आपकी विधि को देखने के लिए तत्पर हैं!

— टोबे स्पाइट

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

— सोफिया लेचनर

2

आर , 193 109 105 बाइट्स

Gi84ppe के लिए -84 बाइट्स धन्यवाद! -4 जयस धन्यवाद!

function(x){"-"=utf8ToInt
S=strtoi
"!"=rev
while({z=paste(S(x)+S(intToUtf8(!-x),10));any(-z!=!-z)})x=z
z}

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

— रॉबर्ट एस।
स्रोत

1

आप स्ट्रिंग हेरफेर की तुलना में इसे करने का एक अलग तरीका चुन सकते हैं (और चाहिए), लेकिन यहां आपके द्वारा चुनी गई विधि के लिए कुछ गोल्फ युक्तियाँ हैं: strsplit(x,"")की तुलना में कम है strsplit(x,NULL), और इससे el(L)कम है L[[1]]। as.doubleसे छोटा है as.numericऔर strtoiदोनों से छोटा है; सेटिंग के बजाय tइसे सीधे अपने ifस्टेटमेंट में उपयोग करें । यह भी एक पुनरावर्ती कार्य है अगर मैं गलत नहीं हूं, तो आपको f=अपने जमा करने के हिस्से के रूप में डालने की आवश्यकता है ।

— Giuseppe

@Giuseppe समझ गया। सुझावों के लिए धन्यवाद। मैं इस पर काम करता रहूंगा। मेरे लिए बस कुछ ऐसा काम करना आसान है जो काम करता है और फिर वापस जाकर अनुकूलन करता है।

— रॉबर्ट एस।

1

हेहे, कोई चिंता नहीं। यदि आप स्ट्रिंग्स (या समस्या से मजबूर) का उपयोग करने पर नरक-तुला हैं, तो utf8ToIntअंकों intToUtf8को बदलने और वापस बदलने के लिए विचार करें । यह एक बड़ी बाइट की बचत होगी!

— Giuseppe

1

यहाँ utf8ToInt और whileलूप का उपयोग करते हुए 109 बाइट्स गोल्फ है

— Giuseppe

1

के- स्थान पर उपयोग करके 4 और बाइट्स बचाएंU । मैं भी बदल दिया revसाथ !, लेकिन यह किसी भी बाइट बचाने नहीं करता है ...

— Jayce

196 एल्गोरिथ्म कोड गोल्फ

एपीएल (22 अक्षर)

GolfScript, 29 वर्ण

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

पायथ, 16 बाइट्स

जे २५ २ 27 ३१

CJam, 22 21 बाइट्स

जे (16 बाइट्स)

स्काला 82

JAGL अल्फा 1.2 - 19, 21 स्टड के साथ

05AB1E , 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

PHP - ५४ ४ characters अक्षर

बैश (64)

सी # - 103 99 चार्ट

क्यू में (39 अक्षर)

जेली , 9 बाइट्स (गैर प्रतिस्पर्धी)

विंडोज पॉवरशेल (63)

befunge, 57 बाइट्स

C ++ TMP (256 अक्षर)

Pyke, 13 बाइट्स (नॉनकमेटिंग)

++ , 57 बाइट्स जोड़ें

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

पॉवरशेल, 63 62 बाइट्स

जीएनयू डीसी, 46 बाइट्स

व्याख्या

आर , 193 109 105 बाइट्स

जे २५ २ ^{27 ३१}