প্যালিনড্রোম বিপরীত সংযোজন

19

প্যালিনড্রোম বিপরীত সংযোজন

বিপরীত সংযোজন প্রক্রিয়াটি যেখানে সংখ্যাটি তৈরি করা সংখ্যাটি প্যালিনড্রোম না হওয়া পর্যন্ত তার বিপরীতে যুক্ত হয়। উদাহরণস্বরূপ, যদি আমরা 68 দিয়ে শুরু করি তবে প্রক্রিয়াটি হ'ল:

68 + 86 => 154 + 451 => 605 + 506 => 1111

আপনি দেখতে পাচ্ছেন, প্যালিনড্রমিক সংখ্যায় পেতে এটি 3 টি সংযোজন করেছে। আমরা যদি শুরু 89করতে চাই তবে আমাদের 24 টি পদক্ষেপের প্রয়োজন হবে (যা আপনি এখানে ভাঙ্গন দেখতে পারেন )।

প্যালিনড্রোমে পৌঁছানোর আগে নেওয়া সবচেয়ে বেশি পদক্ষেপের বিশ্ব রেকর্ডটি 261, যা সংখ্যার জন্য ঘটে, যা 118 এর1186060307891929990 চেয়ে বেশি সংখ্যক উত্পাদন করে । তবে, বেশ কয়েকটি সংখ্যা রয়েছে যা আমরা প্যালিনড্রোম পেতে সক্ষম হইনি। এগুলিকে বলা হয় ল্যাচরেল সংখ্যা ।

যেহেতু আমরা 10 বেসে কাজ করছি, আমরা সত্যই কেবল তাদের প্রার্থী বলতে পারি, কারণ এই সংখ্যাগুলি কখনই প্যালিনড্রমে পৌঁছায় না তার কোনও প্রমাণ নেই। উদাহরণস্বরূপ, ক্ষুদ্রতম বেস -10 লিচরেল প্রার্থী 196, এবং এক বিলিয়নেরও বেশি পুনরুক্তি করেছেন। যদি প্যালিনড্রোম বিদ্যমান থাকে তবে এটি 10 10 8.77 এর থেকে অনেক বড় । তুলনা হিসাবে, যদি যে অনেক 1 টি পরমাণুতে লিখিত ছিল, আমাদের এটি 2.26772 × 10 588843575 মূল্যবান পরমাণুগুলির এটির জন্য এটি লিখে ধরে রাখতে হবে, এটি অনুমান করে এটি উপস্থিত রয়েছে।

তোমার কাজ

এমন একটি প্রোগ্রাম বা ফাংশন তৈরি করুন যা একটি পূর্ণসংখ্যার ইনপুট নেয় এবং একটি প্যালিনড্রোমে পৌঁছানোর জন্য প্রয়োজনীয় পদক্ষেপগুলির সংখ্যা প্রদান করে বা মুদ্রণ করে। আপনাকে লিচরেল প্রার্থীদের সাথে ডিল করার প্রয়োজন হবে না (যেমন আপনার প্রোগ্রামটি যখন কোনও লিচরেল প্রার্থী দেওয়া হয়, হয় ত্রুটি ছুঁড়ে দেওয়ার জন্য বা চিরকালের জন্য চালানোর অনুমতি দেওয়া হয়)।

পরীক্ষার কেস:

                  f(0) => 0
                 f(11) => 0
                 f(89) => 24
                f(286) => 23
          f(196196871) => 45
         f(1005499526) => 109
f(1186060307891929990) => 261

বিধি

  1. কোনও মানক ফাঁক নেই।

বোনাসেস

  1. যদি আপনি প্রতিটি সংযোজন পদক্ষেপটি ফর্ম্যাট করে মুদ্রণ করেন তবে আপনি n + rev(n) = mআপনার স্কোরকে 0.75 দ্বারা গুণতে পারেন । পদক্ষেপের সংখ্যার আগে অঙ্কগুলি মুদ্রণ করা উচিত।
  2. যদি আপনার কোডটি সনাক্ত করতে পারে যে কোনও নম্বর লিচরেল প্রার্থী হয় তবে আপনি আপনার স্কোরকে 0.85 দিয়ে গুণতে পারেন । এই ক্ষেত্রে 261 এর বেশি পুনরাবৃত্তি লিচরেলের প্রার্থী হ'ল এমনটি ধরে নেওয়া যথেষ্ট। হয় কিছুই ফিরিয়ে দিন না, বা এমন কোনও কিছু যা সঠিক উত্তরের জন্য ভুল হতে পারে এমন কোনও সংখ্যা নয় (ইত্যাদি: কোনও স্ট্রিং বা একটি সংখ্যা 0-261 এর মধ্যে নেই)। কোনও ত্রুটি বৈধ আউটপুট হিসাবে গণনা করে না (উদাহরণস্বরূপ সর্বাধিক পুনরাবৃত্তির গভীরতা অতিক্রম করে) এবং সনাক্তকরণে ব্যবহার করা যায় না।
  3. আপনার দ্বারা উভয় বনাস সম্পূর্ণ করলে, গুণ করা 0.6 ।

এটি কোড-গল্ফ , তাই কমপক্ষে সংখ্যা বাইট জেতে।

এই কোড স্নিপেট পাইথন 3 এ উভয় বোনাস সহ একটি উদাহরণ সমাধান দেখায়।

def do(n,c=0,s=''):
  m = str(n)
  o = m[::-1]
  if c > 261:
    return "Lychrel candidate"
  if m == o:
    print(s)
    return c
  else:
    d = int(m)+int(o)
    s+="%s + %s = %s"%(m,o,str(d))
    return do(d,c+1,s)
code-golf  palindrome 
— Kade
সূত্র
— Sp3000
1
অন্যদের উপরে কি *0.6বোনাস রয়েছে? নাকি ঠিক তা-ই?
— মালটিসেন
পছন্দ করুন
— কেড
যখন আউট মুদ্রণ অঙ্কের তাই আমরা ছাপি উচিত 10 + 01 = 11বা 10 + 1 = 11বা এটা আমাদের আপ হয়?
— মার্টিন ইন্ডার
3
লিচরাল ডিটেক্টরের জন্য, আমি কি প্রিন্ট আউট করতে পারি 262?
— মালটিসেন

উত্তর:

8

পাইথ, 12 বাইট

f_I`~+Qs_`Q0

এটি অনলাইনে ব্যবহার করে দেখুন: বিক্ষোভ বা পরীক্ষার জোতা

এটি বেশ নতুন বৈশিষ্ট্য ব্যবহার করে (কেবল 17 ঘন্টা পুরানো)।

ব্যাখ্যা

               implicit: Q = input number
f          0   repeat the following expression until it 
               evaluates to true and return the number of steps
         `Q       convert Q to string
        _         reverse the digits
       s          convert to int
     +Q           add Q
    ~             assign the result to Q
                  (this returns the old value of Q)
   `              convert the old value of Q to a string
 _I               and check if it's invariant under the operation reverse

সম্পাদনা:

কোডটি কিছুটা বদলেছে। পুরানো সংস্করণ ছিল

fqKs_`Q~+QK0

একই বাইট গণনা, তবে নতুনটি হ'ল ওয়েল কুলার।

— Jakube
সূত্র
১২. এর স্কোর বোনাস! শুভকামনা!
— ডেনিস
@ ডানিস আপনার অধিকার এটি একটি হাস্যকর উদ্দেশ্য ছিল। লিচরাল সনাক্তকরণটি ব্যবহার করে আমার কাছে সবচেয়ে ভাল 13.6।
— জাকুব
14

পাইথন, 51

def f(n):r=int(str(n)[::-1]);return n-r and-~f(n+r)

পাইথন 2 এর জন্য, আক্ষরিক সংযুক্তির str()কারণে ব্যাকটিকগুলি প্রতিস্থাপন করতে পারে না ।Llong

এখানে স্কোর 64 * 0.85 = 54.4 সহ একটি বিকল্প সংস্করণ রয়েছে :

def f(n,c=262):r=int(str(n)[::-1]);return c*(n-r)and-~f(n+r,c-1)

এবং পাইথন 3 এর জন্য একটি বিকল্প সংস্করণ 88 * 0.6 = 52.8 সহ :

def f(n,c=262):r=int(str(n)[::-1]);return c*(n-r)and-~f(n+r,print(n,'+',r,'=',n+r)or~-c)
— মিচ শোয়ার্জ
সূত্র
1
এটি কেবল উন্মাদ .. সুন্দর কাজ!
— কেড
6

সিজেএম, 23 22 20.4 বাইট

ri{__sW%i+}261*]{s_W%=}#

কোডটি 24 বাইট দীর্ঘ এবং লিচরেল পরীক্ষার্থীদের জন্য -1 প্রিন্ট করে ।

এটি অনলাইনে চেষ্টা করুন।

কিভাবে এটা কাজ করে

ri                       e# Read an integer from STDIN.
  {       }261*          e# Do the following 261 times:
   __                    e#   Push two copies of the integer on the stack.
     sW%i                e#   Cast to string, reverse and cast back to integer.
         +               e#   Add the copy and the reversed copy of the integer.
               ]         e# Wrap all 262 results in an array.
                {     }# e# Push the index of the first element such that:
                 s       e#   The string representation equals...
                  _W%=   e#   the reversed string representation.

যদি {}#সফল হয় তবে সূচকটিও পদক্ষেপের সংখ্যা। তাহলে, অপরপক্ষে, অ্যারের একটি যে শব্দ কবিতা প্রভৃতি উলটা করিয়া পড়িলেও একই থাকে ধারণ করে না, {}#ধাক্কা হবে -1 ।

— ডেনিস
সূত্র
5

জাভা, 200 * 0.6 = 120

import java.math.*;int f(BigInteger a){int s=-1;for(String b,c;(b=a+"").equals(c=new StringBuffer(b).reverse()+"")!=s++<999;)System.out.println(b+" + "+c+" = "+(a=a.add(new BigInteger(c))));return s;}

এটি একটি সরল লুপ যা এটি বাক্সে যা বলে ঠিক তেমন করে তবে কিছু গল্ফ যুক্ত হয়। রিটার্নস 1000Lychrel প্রার্থীদের জন্য সনাক্তকরণ বোনাস পাবেন। দেখা যাচ্ছে যে আমি খুব বেশি অক্ষরের জন্য মুদ্রণ করতে সক্ষম হয়েছি (জাভার জন্য কমপক্ষে) এবং সেই সাথে বোনাসটি ছিনিয়ে নিয়েছি । বোনাস কোড ছাড়াই আমি সেরাটি করতে পারি 156, তাই এটির পক্ষে এটি যথেষ্ট মূল্য ছিল।

কিছু লাইন বিরতি সহ:

import java.math.*;
int f(BigInteger a){
    int s=-1;
    for(String b,c;(b=a+"").equals(c=new StringBuffer(b).reverse()+"")!=s++<999;)
        System.out.println(b+" + "+c+" = "+(a=a.add(new BigInteger(c))));
    return s;
}

পুরানো উত্তর: 171 * 0.85 = 145.35 বাইট

import java.math.*;int f(BigInteger a){int s=-1;for(String b,c;(b=a+"").equals(c=new StringBuffer(b).reverse()+"")!=s++<262;)a=a.add(new BigInteger(c));return s>261?-1:s;}
— Geobits
সূত্র
আমি অনুমান করি আপনি এটি স্যান্ডবক্সে থাকাকালীন কাজ করেছিলেন: পি আমি বোনাসের পরিমাণগুলি নিয়ে পুনর্বিবেচনা করছি, যেহেতু আমি পাইথনেও বুঝতে পেরেছি (সি # / জাভার তুলনায় একটি তুলনামূলক সংক্ষিপ্ত ভাষা) বোনাসগুলি সহায়তা করে না। আমার মনে হয় আমি এটিকে প্রোগ্রামের দৈর্ঘ্যের সাথে তুলনামূলক করে তুলব যাতে গল্ফিংয়ের ভাষাগুলি <10 বাইট স্কোর দিয়ে শেষ না হয়।
— কেড
আমি বোনাসের নিয়ম আপডেট করেছি, সুতরাং আপনার নতুন স্কোর 145.35 :)
— কেড
একটি বাইট সংরক্ষণ করুন, সংজ্ঞাটির জন্য সেমিকোলনটি সরিয়ে ফেলুন, এটির প্রয়োজন নেই, তারপরেs++<999
— ক্রিস্টোফার উইট
@ ক্রিস্টোফারওয়ার্ট কোন সংকলন / সংস্করণে? খনি এটি ছাড়া একটি বাক্য গঠন ত্রুটি দেয়।
— জিওবিটস
5

রুবি, (80 + 2) * 0.6 = ~ 49.2

পতাকা সহ -nl, চালান

p (0..261).find{$_[b=$_.reverse]||puts($_+' + '+b+' = '+$_="#{$_.to_i+b.to_i}")}

আউটপুট মত দেখাচ্ছে

 $ ruby -nl lychrel.rb 
89
89 + 98 = 187
187 + 781 = 968
968 + 869 = 1837
1837 + 7381 = 9218
9218 + 8129 = 17347
17347 + 74371 = 91718
91718 + 81719 = 173437
173437 + 734371 = 907808
907808 + 808709 = 1716517
1716517 + 7156171 = 8872688
8872688 + 8862788 = 17735476
17735476 + 67453771 = 85189247
85189247 + 74298158 = 159487405
159487405 + 504784951 = 664272356
664272356 + 653272466 = 1317544822
1317544822 + 2284457131 = 3602001953
3602001953 + 3591002063 = 7193004016
7193004016 + 6104003917 = 13297007933
13297007933 + 33970079231 = 47267087164
47267087164 + 46178076274 = 93445163438
93445163438 + 83436154439 = 176881317877
176881317877 + 778713188671 = 955594506548
955594506548 + 845605495559 = 1801200002107
1801200002107 + 7012000021081 = 8813200023188
24

যদি 196 দেওয়া থাকে তবে এটি প্রথমে 261 টি সংযোজন পদক্ষেপগুলি মুদ্রণ করে nil।

এখানে খুব জটিল কিছু না। আমরা $_যা যা ইনপুট থেকে শুরু করা হয়েছে তার বিপরীত রয়েছে কিনা তা যাচাই করে দেখি, এটি একই আকারের হওয়ায় তারা সমান হলেই সম্ভব। যদি এটি হয় তবে আমরা পদক্ষেপ নম্বরটি প্রিন্ট করব এবং প্রস্থান করব, অন্যথায়, আমরা নতুন পদক্ষেপটি সংরক্ষণ করে সংযোজন পদক্ষেপটি প্রদর্শন করি এবং সম্পাদন $_করি (দুর্ভাগ্যক্রমে আমি evalযে স্ট্রিংটি প্রদর্শন করছি তা করতে পারছি না কারণ এটি একটি বিপরীতমুখী সংখ্যাকে পিছনে 0 দিয়ে ব্যাখ্যা করে অক্টাল আক্ষরিক হিসাবে)। putsএকটি মিথ্যা মান প্রদান করে যাতে লুপটি অবিরত থাকে।

— histocrat
সূত্র
" + #{b} = "একটি বাইট সংরক্ষণ করে।
— মিচ শোয়ার্টজ
এবং এটি নিয়মগুলির মধ্যে মনে হচ্ছে -lযদি আমরা কোনও পেছনের নিউলাইন ছাড়াই কোনও ফাইলটিতে নম্বরটি রাখি এবং এটি পাইপ করি তবে?
— মিচ শোয়ার্জ
4

পাইথ - 19 বাইট

লুপ এবং একটি কাউন্টার করার সময় ব্যবহার করে। এর চেয়ে সম্ভবত আরও ছোট অ্যালগরিদম আছে তবে এটি বেশ ছোট।

Wnz_z=z`+szs_z=hZ;Z

এটি এখানে অনলাইনে চেষ্টা করুন ।

— Maltysen
সূত্র
সত্যিই খুব ছোট! ভাল হয়েছে :)
— কেড
4

কে, 25 বাইট

#1_{~x~|x}{$. x,"+",|x}\$

খুব মার্জিত না। সামগ্রিক ফর্ম ( {monad 1}{monad 2}\x) কে এর জেনারেলের সমতুল্য যখন "লুপ" হয়, যেখানে প্রথম মোনাডটি থামানো অবস্থা এবং দ্বিতীয়টি আর্গুমেন্টে পুনরাবৃত্তভাবে প্রয়োগ ফাংশন x। প্রথম মোনাড ( {~x~|x}) হ'ল ক্লাসিক "ইজ এক্স প্যালিনড্রোম" শব্দগুচ্ছকে অস্বীকার করা। দ্বিতীয় মোনাড একসাথে এক্স স্ট্রাক্সকে এক্স এর বিপরীত উপস্থাপন করে একটি স্ট্রিং যুক্ত করে, এটি মূল্যায়ন করে এবং তারপরে ফলাফলটিকে একটি স্ট্রিংয়ে ফিরিয়ে দেয় $।

অন্তর্বর্তী ফলাফল দেখাচ্ছে একটি নমুনা রান:

  {~x~|x}{$. x,"+",|x}\$68
("68"
 "154"
 "605"
 "1111")

বোনাসের অনুরোধ অনুসারে বিন্যস্ত আউটপুট করা খুব আনাড়ি হবে এবং উল্লেখযোগ্য পরিমাণে কোড যুক্ত হবে।

— JohnE
সূত্র
4

সিজেম, 23 বাইট

Wl{\)\__W%_@#\i@i+s\}g;

এখনও সিজেমে মাত্র কয়েক দিন, সুতরাং আমি কমপক্ষে কিছু পেশাদারের মতো একই পরিসরে থাকতে পেরে মোটামুটি খুশি। :) আমি মার্টিনের স্ট্রিং তুলনা কৌশলটি ব্যবহার করেছি যা তিনি সিজেএম ইঙ্গিতগুলিতে পোস্ট করেছিলেন। স্ট্রিংটি কীভাবে বিপরীত করা যায় তা নির্ধারণ করার জন্য আমি ডেনিসের সমাধানটিও দেখেছিলাম।

ব্যাখ্যা:

W    Initialize counter, will keep this at bottom of stack.
     Start counting at -1 because the counter will be incremented in the
     last pass through the loop, when the palindrome is detected.
l    Get input.
{    Start block of while loop.
\)\  Increment counter. Need to swap before/after because it's one below top of stack.
__   Copy current value twice. Need 3 copies in total:
       * one for reversal
       * one for comparison
       * one for addition with reverse
W%   Reverse value.
_    Copy the reverse value once because we need 2 copies:
       * one for comparison
       * one for addition with original value
@    Rotate one copy of original value to top.
#    Test for non-equality with reverse, using Martin's trick.
\i   Swap reverse value to top, and convert it to int.
@i   Rotate remaining copy of original value to top, and convert it to int.
+s   Add the values, and convert result to string.
\    Swap, so that comparison result is at top of stack for while loop test.
}g   End of while loop.
;    Current value sits at top of stack. Pop it, leaving only counter.

এটি অনলাইনে পরীক্ষা করুন

— রেটো কোরাদি
সূত্র
4

জুলিয়া, 129 120 বাইট * 0.6 = 72

i->(i=big(i);n=0;d=digits;while d(i)!=reverse(d(i))&&n<262 t=BigInt(join(d(i)));println(i," + ",t," = ",i+=t);n+=1end;n)

এটি একটি নামবিহীন ফাংশন তৈরি করে যা কোনও পূর্ণসংখ্যাকে ইনপুট হিসাবে গ্রহণ করে এবং পূর্ণসংখ্যা ফেরত দেয়, ইতিমধ্যে প্রতিটি পদক্ষেপ মুদ্রণ করে। Lychrel প্রার্থীদের 262. একটি ফেরত মান এই আহ্বানে আছে, এটি একটি নাম দিন, যেমন f=i->...।

মনে রাখবেন যে বাদ দেওয়া কোডটি কেবলমাত্র বোনাসের সাথে সম্পর্কিত, এই সমাধানটি 84 বাইট হবে।

অবহেলিত + ব্যাখ্যা:

function f(i)
    # Convert the input to a big integer
    i = big(i)

    # Initialize a step counter to 0
    n = 0

    # While the number is not a palindrome and we haven't exceeded 261 steps...
    while digits(i) != reverse(digits(i)) && n < 262

        # Get the reverse of the integer
        # Note that we aren't using reverse(); this is because digits()
        # returns an array of the digits in reverse order.
        t = BigInt(join(digits(i)))

        # Print the step and increment i
        println(i, " + ", t, " = ", i += t)

        # Count the step
        n += 1
    end

    # Return the number of steps or 262 for Lychrel candidates
    n
end

উদাহরণ:

julia> f(286)
286 + 682 = 968
968 + 869 = 1837
1837 + 7381 = 9218
9218 + 8129 = 17347
17347 + 74371 = 91718
91718 + 81719 = 173437
173437 + 734371 = 907808
907808 + 808709 = 1716517
1716517 + 7156171 = 8872688
8872688 + 8862788 = 17735476
17735476 + 67453771 = 85189247
85189247 + 74298158 = 159487405
159487405 + 504784951 = 664272356
664272356 + 653272466 = 1317544822
1317544822 + 2284457131 = 3602001953
3602001953 + 3591002063 = 7193004016
7193004016 + 6104003917 = 13297007933
13297007933 + 33970079231 = 47267087164
47267087164 + 46178076274 = 93445163438
93445163438 + 83436154439 = 176881317877
176881317877 + 778713188671 = 955594506548
955594506548 + 845605495559 = 1801200002107
1801200002107 + 7012000021081 = 8813200023188
23

julia> f(1186060307891929990)
(steps omitted)
261

julia> f(196)
(steps omitted)
262

julia> f(11)
0

জিওবিটসকে ধন্যবাদ 2 বাইট সংরক্ষণ!

— অ্যালেক্স এ।
সূত্র
4

সিজেম, 24 বাইট

0q{__W%#}{_W%~\~+s\)\}w;

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

0q     e# Push a zero (the counter) and read input.
{      e# While this block leaves something truthy on the stack...
  __   e#   Make two copies of the current number (as a string).
  W%   e#   Reverse the second copy.
  #    e#   Check that they are not equal.
}{     e# ... run this block.
  _W%  e#   Make a copy of the current number and reverse it.
  ~\~  e#   Evaluate both N and its reverse.
  +s   e#   Add them and turn the sum into a string.
  \)\  e#   Pull up the counter, increment it, and push it back down again.
}w
;      e# Discard the palindrome to leave the counter on the stack.

#স্ট্রিং অসমতা পরীক্ষা করতে কেন ব্যবহার করা যেতে পারে সে সম্পর্কে আরও তথ্যের জন্য এই টিপটি দেখুন ।

— মার্টিন ইন্ডার
সূত্র
পোস্ট করার আগে আপনার উত্তরটি দেখেনি। এটি একটি চতুর ব্যবহার #।
— ডেনিস
2

হাস্কেল, 66 53 বাইট

r=reverse.show
f x|show x==r x=0|1<2=1+f(x+read(r x))

ব্যবহারের উদাহরণ:

*Main> map f [0,11,89,286,196196871,1005499526,1186060307891929990]
[0,0,24,23,45,109,261]
— nimi
সূত্র
আমি হাস্কেল এর আগে কখনও ব্যবহার করিনি তবে আপনি কি সক্ষম হবেন r=reverse x? এটি আপনার দ্বিতীয় লাইনে পরিবর্তন করবে f x|x==r=0|1<2=1+f(show$read x+read(r))এবং 2 বাইট সংরক্ষণ করবে।
— কেড
@ ভিওজ-: না, এটি সম্ভব নয়, কারণ xসুযোগের মধ্যে না থাকতো। তবে, f x|x==r=0 .... read(r)) where r=reverse xকাজ করবে, তবে এটি আরও দীর্ঘ
— নিমি
2

Clojure, 94 বাইট

(fn[x](#(let[r(bigint(apply str(reverse(str %1))))] (if(= %1 r)%2(recur(+ %1 r)(inc %2))))x 0))

কোডটি গল্ফ করার এটি আমার প্রথম চেষ্টা, তাই দয়া করে আমাকে বলুন আমি কোনও ভুল করছি কিনা।

কিছু স্পেস সহ:

(fn [x]
(#(let [r (bigint (apply str (reverse (str %1))))]
  (if (= %1 r) %2 (recur (+ %1 r) (inc %2)))) x 0))

অভ্যন্তরীণ ফাংশনটির সাধারণ পুনরাবৃত্তি। এটি দুটি যুক্তি লাগে, পূর্ণসংখ্যা %1এবং একটি সূচক %2। যদি %1প্যালিনড্রোম হয় তবে সূচকটি ফিরে আসবে। অন্যথায়, ফাংশনটি যোগফল এবং বর্ধিত সূচকের সাথে নিজেকে কল করে। বাহ্যিক ফাংশন সূচকটি শূন্যের সাথে সূচনা করে।

একটি নমুনা:

repl=> ((fn[x](#(let[r(bigint(apply str(reverse(str %1))))](if(= %1 r)%2(recur(+ %1 r)(inc %2))))x 0)) 1186060307891929990)
261
— max0r
সূত্র
1

বুস্ট.বাইল্ড, 304 বাইট

আসলেই কোন ভাষা নয়। তবু শীতল।

import sequence ;
import regex ;
rule r ( n ) {
m = "([0-9]?)" ;
return [ sequence.join [ sequence.reverse [ regex.match "$(m)$(m)$(m)$(m)$(m)$(m)$(m)$(m)$(m)" : $(n) ] ] : "" ] ;
}
rule x ( n ) {
i = 0 ;
while $(n) != [ r $(n) ] {
n = [ CALC $(n) + [ r $(n) ] ] ;
i = [ CALC $(i) + 1 ] ;
}
echo $(i) ;
}

খুব সোজা, বিস্তৃত রেইগেক্স-ভিত্তিক হ্যাক বাদে আমি স্ট্রিংটি বিপরীত করতে ব্যবহার করতাম।

— kirbyfan64sos
সূত্র
1

রুবি, 44

f=->n{n==(r=n.to_s.reverse.to_i)?0:f[n+r]+1}

->ল্যাম্বদা সিনট্যাক্সের জন্য রুবিকে 1.9 বা তার বেশি প্রয়োজন ।

— মিচ শোয়ার্জ
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.