কারখানা এবং কখনও শেষ চক্র!


33

আপনি এটা হয়তো জানেন যে একটি ধনাত্মক পূর্ণসংখ্যা গৌণিক nসব ধনাত্মক পূর্ণসংখ্যা যা সমান বা ছোট হয় পণ্য n

এই ক্ষেত্রে :

6! = 6*5*4*3*2*1 = 720
0! = 1

আমরা এখন একটি অপ্রাসঙ্গিক নাম সহ একটি বিশেষ ক্রিয়াকলাপ সংজ্ঞায়িত করব sumFac:

ধনাত্মক পূর্ণসংখ্যা দেওয়া n, sumFac(n)এটি হ'ল অঙ্কগুলির ফ্যাক্টরিয়ালগুলির যোগফল।

এই ক্ষেত্রে :

sumFac(132) = 1! + 3! + 2! = 9

কার্য

আপনার মিশনটি আপনি গ্রহণ করতে বা বেছে নেবেন না তা হ'ল sumFacইনপুটটিতে প্রদত্ত পূর্ণসংখ্যার অ্যাপ্লিকেশনগুলির ক্রম (সম্ভাব্য অসীম) ফেরত দেওয়া।

উদাহরণ: 132 -> 132, 9, 362880, 81369, 403927, ...

কিন্তু এখানেই শেষ নয়! আসলে, এর প্রয়োগগুলি sumFacশেষ পর্যন্ত একটি চক্র তৈরি করবে create আপনারও অবশ্যই এই চক্রটি ফিরিয়ে দিতে হবে!

যদি আপনার ভাষার কোনও অন্তর্নির্মিত ফ্যাক্টরিয়াল থাকে তবে আপনি এটি ব্যবহার করতে পারেন। আমি রিটার্নের ধরণের বিষয়ে পছন্দসই নই, আপনাকে কেবলমাত্র SumFac অ্যাপ্লিকেশনগুলির ক্রম এবং একটি চক্রটি কোনও মানুষের দ্বারা বোঝা যায় এমন বিন্যাসে ফিরে আসতে হবে।

সম্পাদনা: আউটপুটটি কেমন দেখতে হবে তা আরও ভালভাবে দেখতে আপনাকে সহায়তা করার জন্য আমি নীচে লেকি নুনকে অনুলিপি করেছি:

[132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920, 368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720, 5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]

যখন চক্রটি দ্বিতীয়বারের মতো শুরু হতে চলেছে তখন আপনাকে কেবল ক্রমটি থামাতে হবে!

তবে এটি কোড-গল্ফ তাই বাইটের সংক্ষিপ্ত উত্তরটি জয়!

লিডারবোর্ড

নিয়মিত লিডারবোর্ড এবং ভাষার দ্বারা বিজয়ীদের একটি সংক্ষিপ্ত বিবরণ উভয়ই তৈরি করতে এখানে একটি স্ট্যাক স্নিপেট।



পিপিসিজিতে আপনাকে স্বাগতম! এটি দেখতে সুন্দর চ্যালেঞ্জের মতো, বিটিডাব্লু।
ক্লিমেমিক

@ কিওয়ার্প-ডের্প আপনাকে অনেক ধন্যবাদ! আমি সৃজনশীল হওয়ার চেষ্টা করেছি

@ জাগারব ওয়েল এটি ঠিক ফুটো নুনের আউটপুট এর মতো। অ্যাপ্লিকেশনগুলির ক্রম এবং তারপরে এটি দ্বিতীয় চক্র শুরু হওয়ার ঠিক আগে শেষ হবে। আমি তার আউটপুটটি প্রশ্নটিতে অনুলিপি করব যাতে প্রত্যেকেরই পরিষ্কার ধারণা থাকতে পারে। এটি নির্দেশ করার জন্য ধন্যবাদ :)

1
@ 2501 হার্ডকোডিং মানটি প্রতারণা করছে তবে আউটপুট ফর্ম্যাট করার বিষয়ে আপনি যে কোনও বিভাজক ব্যবহার করতে পারেন

উত্তর:


19

জেলি , 6 বাইট

D!SµÐĿ
    ÐĿ  Repeat until the results are no longer unique. Collects all intermediate results.
D           Convert from integer to decimal (list of digits)
 !          Factorial (each digit)
  S         Sum

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

আমি যেমনটি বলেছি তা করা ছাড়া এটি আরও খাটো করার অন্য কোনও উপায় দেখতে পাচ্ছি না।

চশমা

  • ইনপুট: 132(কমান্ড-লাইন আর্গুমেন্ট হিসাবে)
  • আউটপুট: [132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920, 368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720, 5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]

আমি সংক্ষিপ্ত উত্তর আছে আশা করি না। চমৎকার :)

4
@ এন্টাইন এটি জেলি: ডি এটি হবেন বলে আমার তুলনায় সর্বদা সংক্ষিপ্ত;)
হাইপার নিউট্রিনো

8
@ হাইপার নিউট্রিনো কোনওভাবে ডেনিস তার আরও ছোট উত্তর নিয়ে আসবে
লিকি নুন

একরকম, হ্যাঁ কারণ ডেনিস। : পি
হাইপারনিউট্রিনো

সুতরাং ... আপনি character 6 টি চরিত্রের জন্য 6 টি বাইট ব্যবহার করতে কোন অক্ষর এনকোডিং ব্যবহার করেন? জেলি কি ইউটিএফ -8 এনকোড হওয়ার কথা নয়, যার অর্থ এই প্রোগ্রামটি আসলে 9 বাইট?
লর্ডঅফ দ্য পিপস


9

05 এ বি 1 ই , 12 বাইট

[DˆS!O©¯så#®

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

ব্যাখ্যা

[               # infinite loop
 Dˆ             # add a copy of current value to the global list (initialized as input)
   S            # split current number to digits
    !O          # calculate factorial of each and sum
      ©         # save a copy in register
       ¯så#     # if the current number is in the global list, exit loop
           ®    # retrieve the value from the register for the next iteration
                # implicitly output the global list

সংক্ষিপ্ত এবং সঠিক, ভাল খেলেছে!

ভেবেছিলাম আমি এর থেকে মুক্তি পেতে পারি s, ভুল ছিল, দুর্দান্ত উত্তর।
ম্যাজিক অক্টোপাস উরন

8

ব্র্যাচল্যাগ , 17 বাইট

g:I{tẹḟᵐ+}ᵃ⁾L¬≠Lk

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

ব্যাখ্যা

g:I{     }ᵃ⁾         Accumulate I (a variable) times, with [Input] as initial input:
    t                  Take the last integer
     ẹḟᵐ+              Compute the sum of the factorial of its digits
            L        The result of the accumulation is L
            L­      Not all elements of L are different
               Lk    Output is L minus the last one (which is the start of the loop)

কী Iমানে?
লিকি নুন

1
@ লিক্যনুন এটির প্যারামিটার ᵃ⁾ᵃ³অর্থ "3 বার জমে"। ᵃ⁾এর অর্থ "ইনপুটটির শেষ উপাদান হিসাবে যতবার জমা হয়", যা সেই ক্ষেত্রে I। যেহেতু Iএকটি সম্পূর্ণ বিনামূল্যে পরিবর্তনশীল, এটা থেকে এটা মান চেষ্টা করবে 0করার +inf
এপ্রিলকে মারাত্মক রূপ দিন

8

ওল্ফ্রাম ভাষা, 62 60 56 বাইট

Most@NestWhileList[Tr[IntegerDigits@#!]&,#,UnsameQ,All]&

এটা সত্যিই খুব খারাপ যে ওল্ফ্রাম ভাষার এইরকম ঘৃণ্য দীর্ঘ ফাংশন নাম রয়েছে names *দীর্ঘশ্বাস*

ব্যাখ্যা:

Most[NestWhileList[Tr[IntegerDigits[#]!]&,#,UnsameQ,All]]&
                      IntegerDigits[#]                     (*Split input into list of digits*)
                                      !                    (*Factorial each element in the list*)
                   Tr[                 ]&                  (*Sum the list together*)
     NestWhileList[                      ,#,UnsameQ,All]   (*Iterate the function over itself, pushing each to a list, until a repeat is detected*)
Most[                                                   ]& (*Remove the last element in the list*)

চমৎকার উত্তর. আমি মনে করি না এটির উন্নতি হতে পারে।
কেলি লোডার

1
@ কেলিলাউডার ধন্যবাদ! আমি তালিকায় ফ্যাকটোরিয়ালটি ম্যাপিং করে আরও দুটি বাইট সংরক্ষণ করতে সক্ষম হয়েছি, তারপরে সংক্ষেপ করে Tr
স্কট মিলনার

1
ভাল ব্যবহার NestWhileList[...,All]!
গ্রেগ মার্টিন

6

জাভাস্ক্রিপ্ট (ES6), 91 89 বাইট

F 2nɛtk ধন্যবাদ 2 বাইট সংরক্ষণ করা

এটি অন্য জেএস উত্তরের সাথে বেশ মিল বলে প্রমাণিত হয়েছে ।

f=(n,x=!(a=[n]))=>n?f(n/10|0,x+(F=n=>n?n--*F(n):1)(n%10)):~a.indexOf(x)?a:f(x,!a.push(x))


আপনার ফ্যাক্টরিয়াল ফাংশনে আপনি কি> 0! = 1 এর কারণে এন> 1 এর পরিবর্তে এন ব্যবহার করতে পারবেন না?
fəˈnɛtɪk

@ fəˈnɛtɪk আমি জানি না আমি এখানে কী ভাবছিলাম। ধন্যবাদ!
আর্নৌল্ড

5

ClojureScript, 146 109 বাইট

#(loop[n[%]](let[f(apply +(for[a(str(last n))](apply *(range 1(int a))))](if(some #{f}n)n(recur(conj n f)))))

হ্যাঁ, এটি একটি বিদ্বান। কেউ দয়া করে আমাকে এই গল্ফ সাহায্য করুন ...

@cliffrootএকটি বৃহত 37 বাইট শেভ করার জন্য ধন্যবাদ !

এটি একটি বেনাম ফাংশন, ফাংশনটি চালাতে, আপনাকে এটি করতে হবে:

(#(...) {arguments})

টিআইওর কাছে ক্লোজিউরস্ক্রিপ্ট নেই, সুতরাং ক্লোজারস্ক্রিপ্ট আরপিএল- এর লিঙ্কটি এখানে

এখানে ক্লোজার প্রোগ্রামের একটি লিঙ্ক রয়েছে যা 0 থেকে 1000 পর্যন্ত তালিকার শেষ উপাদানটি মুদ্রণ করে।

এখানে ফলাফল 9999:

[9999 1451520 269 363602 1455 265 842 40346 775 10200 6 720 5043 151 122 5 120 4 24 26 722 5044 169 363601 1454]

আমার দৃ strong় সন্দেহ আছে যে সমস্ত সংখ্যার অবশেষে স্থির হওয়া উচিত 1বা লুপে [169 363601 1454]

অবরুদ্ধ কোড:

(defn fact-cycle [n]
  (loop [nums [n]]
    (let [fact-num
          (let [str-n (str (last nums))]
            (apply +
              (for [a (range (count str-n))]
                (apply *
                  (range 1
                    (inc (int (nth str-n a))))))))]
      (if (some #{fact-num} nums) nums
        (recur
          (conj nums fact-num))))))

ব্যাখ্যা শীঘ্রই আসছে!


বেশ দীর্ঘ তবে সঠিক;) আমি আপনাকে দুঃখিত এই গল্ফ করতে সত্যিই সাহায্য করতে পারি না

অভ্যন্তর forহতে পারে (for[a s](apply *(range 1(-(int a)47)))), তাই না?
ক্লিফ্রুট

এবং এটি অন্যটি থেকে মুক্তি পেতে অনুমতি দেবেlet #(loop[n[%]](let[f(apply +(for[a(str(last n))](apply *(range 1(-(int a)47)))))](if(some #{f}n)n(recur(conj n f)))))
ক্লিফ্রুট

ওহ, মনে হয় আপনার (- ... 47)ক্লোজার স্ক্রিপ্টেও দরকার নেই, কেবল intযথেষ্ট হবে
ক্লিফ্রুট

ভাল, (inc(int a))ক্লোজার স্ক্রিপ্ট এবং ক্লোজারের জন্য করা উচিত (-(int a)47)
ক্লিফ্রুট

5

পার্ল 6 , 64 বাইট

{my@a;$_,{[+] .comb.map:{[*] 2..$_}}...^{$_@a||!@a.push: $_}}

চেষ্টা করে দেখুন

সম্প্রসারিত:

{

  my @a;             # array of values already seen

  $_,                # seed sequence with the input

  {
    [+]              # reduce using &infix:<+>
      .comb          # the digits of $_ (implicit method call)
      .map:          # do the following for each
      {
        [*] 2..$_    # get the factorial of
      }
  }


  ...^               # keep generating values until
                     # (「^」 means throw away the last value when done)

  {
      $_  @a        # is it an elem of @a? (「∈」 is shorter than 「(cont)」)

    ||               # if it's not

      !              # boolean invert so this returns False
        @a.push: $_  # add the tested value to @a
  }
}

উপরের প্রতিটি লাইন {একটি অন্তর্নিহিত প্যারামিটার সহ একটি নতুন বেয়ার ব্ল্যাক ল্যাম্বদা শুরু করেছে $_

আমি খালি মাইক্রো অপ্টিমাইজেশন হিসাবে [*] 2..$_পরিবর্তে ব্যবহার করেছি [*] 1..$_


4

জাভাস্ক্রিপ্ট, 92 বাইট

অন্তর্ভুক্ত সহ একটি বাইট বন্ধ করে গল্ফ করার জন্য @ শেগি ধন্যবাদ
গল্ফ করার জন্য @ শেগি ধন্যবাদ জানায় দুটি বাইট বন্ধ করে গল্ফ করার জন্য ধন্যবাদ @ নীল

কোড পৃথক ফাংশন 92 বাইটে বিভক্ত

f=(x,a=[])=>a.includes(x)?a:f(k(x),a,a.push(x))
p=y=>y?y*p(y-1):1
k=n=>n?p(n%10)+k(n/10|0):0

এক লাইনে কোড 92 বাইট

f=(x,a=[])=>a.includes(x)?a:f((k=n=>n?(p=y=>y?y*p(y-1):1)(n%10)+k(n/10|0):0)(x),a,a.push(x))

ব্যাখ্যা

প্রাথমিকভাবে কেবলমাত্র একটি যুক্তি দিয়ে ফাংশনটি কল করুন, সুতরাং a = []।

অ্যারেতে যদি x উপস্থিত থাকে তবে a a.includes(x)?a:...

অন্যথায়, x এর সাথে একটি যুক্ত করুন এবং ফাংশনরেটিরি অঙ্কের যোগফল এবং একটিটি পাস করুন (a.push(x),f(k(x),a))

p=y=>y?y*p(y-1):1
k=n=>n?p(n%10)+k(n/10|0):0

ফ্যাক্টরিয়াল ডিজিটের সমষ্টিটি সঞ্চালিত হয়েছে যাতে এটি সর্বাধিক পুনরাবৃত্তির সীমা ছাড়িয়ে যায় না।

সমস্ত সম্ভাব্য শেষের তালিকা: 1, 2, 145, 169, 871, 872, 1454, 40585, 45361, 45362, 363601

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


1
গাহ, আমি এত কাছে ছিলাম! এর সাথে বাইট সংরক্ষণ করুনf=(x,a=[])=>a.includes(x)?a:(a.push(x),f(k(x),a))
শেগি

আপনি কি লিখতে পারবেন না f(k(x),a,a.push(x))? এছাড়াও, আমি মনে করি আপনি k=n=>n&&অন্য একটি বাইট সংরক্ষণ করতে লিখতে পারেন ।
নীল

4

হাস্কেল , 80 67 বাইট

g#n|elem n g=g|h<-g++[n]=h#sum[product[1..read[d]]|d<-show n]
([]#)

এটি অনলাইন চেষ্টা করুন! ব্যবহার:([]#) 132

সম্পাদনা করুন: আরজান জোহানসেনের টাইপ সহ 13 বাইট সংরক্ষণ করা হয়েছে!


(1) টেস্ট এবং সংযোজন nপরিবর্তে s(ওভসের পাইথন উত্তরের মতো), তারপরে f=([]#)। (২) শাখাগুলি স্যুইচ করুন, ইনলাইন করুন sএবং ব্যবহার করুন elem
janrjan জোহানসেন

আপনার ++জন্য স্যুইচ আউট :

1
@ ক্যানিয়ন এটির জন্য এটি ভুল অর্ডার, এটি চূড়ান্ত ফলাফলটিকে বিপরীত করে দেবে। কোনও অতিরিক্ত প্রস্তাব রেখে এবং এতে পরিবর্তন করে আপনি এটি প্রায় শেষ করে ফেলতে পারেন তবে এটি কেবল একটি টাই বলে মনে হচ্ছে। n:=g=[]
janrjan জোহানসেন

4

পাইথ, 9 বাইট

.us.!MjNT
.us.!MjNTQ  implicit Q

.u          explained below
       N      current value
      j T     convert to decimal (list of digits)
   .!M        factorial of each digit
  s           sum

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

এই উত্তরটি ব্যবহার করে .u("সংশ্লেষিত স্থির-পয়েন্ট before এর আগে যে ফলাফলটি দেখা গিয়েছে ততক্ষণ পর্যন্ত প্রয়োগ করুন all সকল মধ্যবর্তী ফলাফল ফিরিয়ে দিন" ")




2

আর, 120 বাইট

o=scan()
repeat {
q=sum(factorial(as.double(el(strsplit(as.character(o[length(o)]), "")))))
if(q%in%o)break
o=c(o,q)
}
o

আপনি এটি করতে পারেন o=scan(), el()পরিবর্তে ব্যবহার করতে পারেন [[1]]এবং gamma(n+1)=factorial(n)আমি বিশ্বাস করি যা একটি বাইট সংরক্ষণ করে এবং আমি মনে করি পূর্ণসংখ্যা as.numericহিসাবে একই as.double, যা একটি বাইট সংরক্ষণ করে এবং আপনি এর toStringপরিবর্তে ব্যবহার করতে পারেন as.character
জিউসেপে

@ জিউজ্পে আপডেট হয়েছে ইনপুটটির জন্য ধন্যবাদ।
নীল

2

জাভা 9 জেএসহেল, 213 বাইট

n->{Set<Integer>s=new HashSet<>();
return IntStream.iterate(n,i->(""+i).chars()
.map(x->x<50?1:IntStream.rangeClosed(2,x-48)
.reduce(1,(a,b)->a*b)).sum()).boxed()
.takeWhile(x->s.add(x)).collect(Collectors.toList());}

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

দ্রষ্টব্য: এই দ্রবণটি 48-57 সীমাতে কোড পয়েন্ট থাকা সংখ্যার স্ট্রিং উপস্থাপনার উপর নির্ভর করে। ASCII, UTF-8, ল্যাটিন -1, সমস্ত আইএসও -8859- * অক্ষর সেট, সর্বাধিক কোড পৃষ্ঠাগুলির জন্য কাজ করে। EBCDIC এর পক্ষে কাজ করে না। আমি মনে করি না যে কেউ এর জন্য পয়েন্টগুলি কেটে দেবে। :)

Ungolfed:

Function<Integer, List<Integer>> f =        // function from Integer to List of Integer
n -> {
    Set<Integer> s = new HashSet<>();       // memo of values we've seen
    return IntStream.iterate(n,             // iterate over n, f(n), f(f(n)), etc.
    i -> (""+i).chars()                     // the sumFac function; for all chars
        .map(x -> x < 50? 1 :               // give 1 for 0! or 1!
        IntStream.rangeClosed(2, x-48)      // else produce range 2..d 
        .reduce(1,(a,b)->a*b))              // reduction to get the factorial
        .sum())                             // and sum up the factorii!

                                            // now we have a stream of ints
                                            // from applying sumFac repeatedly
        .boxed()                            // box them into Integers (thanks, Java)
        .takeWhile(x->s.add(x))             // and take them while not in the memo
        .collect(Collectors.toList());      // collect them into a list
}

নোট:

  • সেট :: অ্যাডের রিটার্ন মান এখানে খুব সহায়ক helpful আইটেমটি সেটে না থাকলে যদি সত্য ফিরে আসে
  • যখন আমি "থ্যাঙ্কস, জাভা" বলেছিলাম তখন আমি ব্যঙ্গাত্মক হয়ে উঠছিলাম
  • ফ্যাক্টরিই আসলে কোনও শব্দ নয়; আমি সবেমাত্র তৈরি করেছি

1
আমি স্বীকার করি এটি আসল! চমৎকার কাজ :)

@ অ্যান্টাইন আমি স্বীকার করেছি, জাভা গল্ফ দেওয়ার পক্ষে সেরা ভাষা নয় তবে আমি ইদানীং খুব কৃপণ কাজ করেছি। :) কোডগল্ফ.স্ট্যাকেক্সেঞ্জিং.com
ডেভিড কনরাড

2

পাইথ, 22 11 বাইট

.usm.!sd+Nk

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

লিকি নুনের উত্তরে প্রচুর credit , যা আমাকে পরিচয় করিয়ে দিয়েছিল .uএবং এই প্রোগ্রামের 11 টি বাইট সংরক্ষণ করতে সহায়তা করেছিল।

ব্যাখ্যা:

.usm.!sd+NkQ | ending Q is implicitly added
             | Implicit: Q = eval(input())
.u         Q | Repeat the function with initial value Q until a previous value is found. Return all intermediate values
  s          | Summation
   m.!sd     | For each character 'd' in the string, convert to integer and take the factorial
        +Nk  | Convert function argument to string

এক চিত্রের চেয়ে পাইথের আরও কার্যকর কার্যকারিতা রয়েছে। আমার উত্তরটি রেফারেন্স হিসাবে দেখুন ।
লিকি নুন

@ লিক্যনুন আমি আমার উত্তরটি নতুন করে লিখেছি .u। আমার ধারণা আমি অন্য কোনও দরকারী কার্যকারিতা আছে কিনা তা দেখার জন্য আমাকে আবার চরিত্রের রেফারেন্সটি দেখে নেওয়া দরকার।
কে জাং

আপনি `Nপরিবর্তে স্ট্রিং রূপান্তর করতে ব্যবহার করতে পারেন +Nk
ফাঁস নুন

@ ল্যাকইনুন যেখানে Nতখন অপ্রচলিত হবে, এবং একটি 9-বাইট সমাধান আসে ...
এরিক দ্য আউটগোল্ফার

1

অ্যাক্সিয়াম, 231 বাইট

l(a:NNI):List NNI==(r:List NNI:=[];repeat(r:=cons(a rem 10,r);a:=a quo 10;a=0=>break);r)
g(a:NNI):NNI==reduce(+,[factorial(x) for x in l(a)])
h(a:NNI):List NNI==(r:=[a];repeat(a:=g(a);member?(a,r)=>break;r:=cons(a,r));reverse(r))

গল্ফড ফাংশন এবং কিছু পরীক্ষা নয়

-- convert one NNI in its list of digits
listify(a:NNI):List NNI==
    r:List NNI:=[]
    repeat
        r:=cons(a rem 10,r)
        a:=     a quo 10
        a=0=>break
    r

-- g(1234)=1!+2!+3!+4!
SumfactorialDigits(a:NNI):NNI==reduce(+,[factorial(x) for x in listify(a)])

ListGenerateFromSumFactorialDigits(a:NNI):List NNI==
    r:=[a]
    repeat
       a:=SumfactorialDigits(a)
       member?(a,r)=>break
       r:=cons(a,r)
    reverse(r)

(9) -> h 132
   (9)
   [132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920,
    368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720,
    5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]

1

জাভা 7, 220 বাইট

String c(int n){String r=n+",",c;for(;!r.matches("^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");r+=c);return r;}int d(int n){int s=0;for(String i:(n+"").split(""))s+=f(new Long(i));return s;}long f(long x){return x<2?1:x*f(x-1);}

ব্যাখ্যা:

String c(int n){                            // Method with integer parameter and String return-type
  String r=n+",",                           //  Result-String (which starts with the input integer + a comma
         c;                                 //  Temp String
  for(;!r.matches(                          //  Loop as long as the result-String doesn't match the following regex:
    "^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");  //    "^i,.*|.*,i,.*" where `i` is the current integer
                                            //   `n=d(n)` calculates the next integer in line
                                            //   `c=(n=d(n))+","` sets the temp String to this integer + a comma
    r+=c                                    //   And append the result-String with this temp String
  );                                        //  End of loop
  return r;                                 //  Return the result-String
}                                           // End of method

int d(int n){                               // Separate method (1) with integer parameter and integer return-type
  int s=0;                                  //  Sum
  for(String i:(n+"").split(""))            //  Loop over the digits of `n`
    s+=f(new Long(i));                      //   And add the factorial of these digits to the sum
                                            //  End of loop (implicit / single-line body)
  return s;                                 //  Return the sum
}                                           // End of separate method (1)

long f(long x){                             // Separate method (2) with long parameter and long return-type (calculates the factorial)
                                            // (NOTE: 2x `long` and the `new Long(i)` is shorter than 2x `int` and `new Integer(i)`, hence long instead of int)
  return x<2?                               //  If `x` is 1:
      1                                     //   return 1
    :                                       //  Else:
      x*f(x-1);                             //   return `x` multiplied by the recursive-call of `x-1`
}                                           // End of method (2)

পরীক্ষার কোড:

এখানে চেষ্টা করুন।

class M{
  String c(int n){String r=n+",",c;for(;!r.matches("^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");r+=c);return r;}int d(int n){int s=0;for(String i:(n+"").split(""))s+=f(new Long(i));return s;}long f(long x){return x<2?1:x*f(x-1);}

  public static void main(String[] a){
    System.out.println(new M().c(132));
  }
}

আউটপুট:

132,9,362880,81369,403927,367953,368772,51128,40444,97,367920,368649,404670,5810,40442,75,5160,842,40346,775,10200,6,720,5043,151,122,5,120,4,24,26,722,5044,169,363601,1454,



1

টিআই-বেসিক, 85 79 64 60 বাইট

:Prompt L₁                             //Get input as 1 length list, 4 bytes
:Lbl C                                //create marker for looping, see below, 3 bytes
:int(10fPart(Xseq(10^(~A-1),A,0,log(X //split input into list of digits, 20 bytes
:sum(Ans!→X                           //factorial and sum the list, write to new input, 6 bytes
:If prod(L₁-X                         //Test to see if new element is repeated, see below, 7 bytes
:Then                                 //Part of If statement, 2 bytes
:augment(L₁,{X→L₁                     //Push new input to List 1, 10 bytes
:Goto C                               //Loop back to beginning, 3 bytes
:Else                                 //Part of If statement, 2 bytes
:L₁                                   //Print Answer, 2 bytes

যেহেতু এটি কোনও গ্রাফিকিং ক্যালকুলেটরে চলছে তাই সীমাবদ্ধ র‌্যাম রয়েছে। যে সংখ্যাগুলি দ্রুত লুপ করে তা দিয়ে এটি পরীক্ষা করে দেখুন 169

আরও ব্যাখ্যা:

:int(10fPart(Xseq(10^(~A-1),A,0,log(X
              seq(10^(~A-1),A,0,log(X //Get a list of powers of 10 for each digit (i.e. 1, 0.1, 0.01, etc.)
             X                        //Multiply by input
       fPart(                         //Remove everything but the decimal
     10                               //Multiply by 10 (move one digit in front of the decimal
:int(                                 //Truncate to an integer

If prod(L₁-Xপুরানো তালিকা থেকে নতুন উপাদানকে বিয়োগ করে কাজ করে, তারপরে তালিকার সমস্ত উপাদানকে এক সাথে গুণ করে। উপাদানটি ইতিমধ্যে তালিকায় থাকলে, পণ্যটি হবে 0, একটি মিথ্যা মান। অন্যথায়, পণ্যটি ইতিবাচক পূর্ণসংখ্যার, একটি সত্যবাদী মান হবে।



1

জে , 40 31 বাইট

সম্পাদনা করুন: ফ্রাউনফ্রোগ দ্বারা উন্নত ব্যবহার করে 9 বাইট সংরক্ষণ করা হয়েছে। ধন্যবাদ!

f=.$:@,~`]@.e.~[:+/@:!10#.inv{:

আসল কোড:

চ = [ '($: @,) @।। ([: -। ই ~।) [+ / @ (0 & ": @ {:)!"। "

এই ক্ষেত্রে আমি ক্রিয়া সংজ্ঞাটির জন্য বাইটগুলি গণনা করার সিদ্ধান্ত নিয়েছি, অন্যথায় এটি দোভাষীর কাজ করে না।

ব্যাখ্যা:

                         ({:) - অ্যারের শেষ উপাদানটি নেয়
                               ": @ - এটিকে স্ট্রিতে রূপান্তরিত করে
                          "।" 0 & - প্রতিটি অক্ষরকে পূর্বে পূর্ণসংখ্যায় রূপান্তর করে
                       ! @ - ফ্যাক্টরিয়ালগুলি সন্ধান করে
                     + / - তাদের যোগফল
                   [: - ক্যাপ (উপরে দুটি উত্পন্ন ক্রিয়া আছে, একটি কাঁটাচামচ জন্য আমাদের 3 টি প্রয়োজন)
          (e। ~) - ফলাফল তালিকায় উপস্থিত কিনা তা পরীক্ষা করে দেখুন    
             -। - উপরের চেক অবহেলা
           [: - টুপি
        @। - এজেন্ডা সংমিশ্রণ, পুনরাবৃত্তি জন্য প্রয়োজন
  ($: @,) - ফলাফল যদি তালিকায় না থাকে তবে এটি তালিকায় যুক্ত করুন এবং পুনরাবৃত্তি করুন
[`- ফলাফল তালিকায় থাকলে এটি প্রদর্শন করুন এবং থামান    

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


1
([:-.e.~)->(1-e.~)
ফ্রাউনফ্রগ


@ ফ্রাউনফ্র্যাগ ধন্যবাদ, আপনার কোডটি আরও ভাল! আমি পরীক্ষার সময় 10 # .inv শুরুর দিকে চেষ্টা করেছিলাম, কিন্তু তারপরে আমি এটিকে 10 & # লিখেছিলাম এবং এটি দীর্ঘ ছিল, তাই আমি এটিকে প্রত্যাখ্যান করেছি। আপনার সমস্ত পরামর্শের জন্য ধন্যবাদ! আমার অনেক কিছু শেখার আছে :)
গ্যালেন ইভানোভ

@ ফ্রভনিফ্রোগ এজেন্ডার ক্ষেত্রে মামলাগুলি বদলে দেওয়া খুব ভাল, আমি আফসোস করে দেখলাম না :)
গ্যালেন ইভানভ

[:+/!@"."0@":@{:একই দৈর্ঘ্য, তাই কোন উন্নতি আছে 10#.inv। খালি ফেলে দিতে হয়েছিল ()
ফ্রাউনফ্রগ

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