प्रमुख मेंढक 🐸

Question

"प्राइम फ्रॉग" एक अजीब जानवर है जो पूर्णांक के बीच कूदता है, जब तक कि यह 3 या 19 पर नहीं आता ...

---

आपके प्रोग्राम को एक पूर्णांक nको इनपुट के रूप में स्वीकार करना चाहिए और नीचे एल्गोरिदम ( 3या 19) के परिणाम को आउटपुट करना चाहिए ।

किसी पूर्णांक के लिए n >= 2:

1. आज्ञा देना fमेंढक की स्थिति। यह शुरू में निर्धारित हैn
2. यदि f = 3या f = 19: मेंढक कूदना बंद कर देता है - कार्यक्रम और आउटपुट को रोक देता है f।
3. अगर fप्राइम है: मेंढक स्थिति में कूद जाता है 2×f-1। चरण 2 पर वापस जाएं।
4. यदि fसमग्र है: चलो dहो fकी सबसे बड़ी प्रधानमंत्री भाजक। मेंढक स्थिति में कूद जाता है f-d। चरण 2 पर वापस जाएं।

उदाहरण:

इसके साथ एक उदाहरण n = 5:

5 > 9 > 6 > 3 stop

कार्यक्रम को आउटपुट देना चाहिए 3।

इसके साथ एक और उदाहरण n = 23:

23 > 45 > 40 > 35 > 28 > 21 > 14 > 7 > 13 > 25 > 20 > 15 > 10 > 5 > 9 > 6 > 3 stop

फिर से, प्रोग्राम को आउटपुट देना चाहिए 3।

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

10 => 3
74 => 19
94 => 3
417 => 3
991 => 19
9983 => 19

आप मान सकते हैं 1 < n < 1000000(मैंने इन मूल्यों के लिए कार्यक्रम समाप्त होने की जाँच की है)।

Comments

3 लूप [३ ५ ९ ६ ३ ३] और १ ९ लूप है [१ ९ ३ 116 116३ १४५ ११५

— अरनौद

शांत Collatz बदलाव।

— आर्थर

यदि हम यह साबित नहीं कर सकते हैं कि मेंढक हमेशा 3या तो आता है 19, तो हम आइटम 2 को बदल सकते हैं। एल्गोरिथ्म में यह कहने के लिए कि यदि मेंढक किसी भी लूप में प्रवेश कर चुका है (इससे पहले देखी गई स्थिति का सामना किया है), तो यह कूदना बंद कर देता है और सबसे छोटा वापस लौटता है उस पाश का सदस्य।

— जेपी स्टिग नीलसन

@PyRulez यदि यह उस तक पहुँचता है, तो आपको संभवतः ओपी को बताना चाहिए।

— mbomb007

@KeyuGan शायद यह Math.SE पर पोस्ट करने के लिए एक अच्छी बात होगी।

— mbomb007

Answer 1

पायथन 2 , 101 93 92 90 88 87 85 बाइट्स

import sympy
n=input()
while~16&n-3:m=max(sympy.factorint(n));n-=[1-n,m][m<n]
print n

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

Comments

while~16&n!=3एक बाइट बचाता है।

— लिन

ओह, ~16&n-3यहां तक ​​कि काम करता है!

— लिन

Answer 2

सी (जीसीसी),  87  65 बाइट्स

i,k;f(n){for(i=n;i>1;)for(k=i;k%--i;);n=~16&n-3?f(n-k?:n+n-1):n;}

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

स्पष्टीकरण:

i,k;
f(n)
{
    for (i=n; i>1;)              // Loop until `k` is prime (the largest positive
                                 // `i` inequal to `k` that divides `k` is 1).
        for (k=i; k%--i;);       // Find the largest factor `k`

    n =                          // Returning like this is undefined behaviour,
                                 // but happens to work with gcc. This can be
                                 // replaced with `return` at the cost of 4 bytes.

        ~16&n-3                  // If `n` is 3 or 19, this expression equals 0 and
                                 // the algorithm halts. Otherwise the function
                                 // calls itself to perform the next iteration.

        ? f(n-k ?: n+n-1)        // If `n-k` is non-zero, n is not prime.
                                 // In this case call `f` with the value of `n-k`.
                                 // (Omitting the second `n-k` between `?` and `:`
                                 // is a gcc extension)
                                 // Otherwise call `f` with `2*n-1`.

        : n;                     // All done, `n` is returned.
}

पोर्टेबल संस्करण (72 बाइट्स):

i,k;f(n){for(i=n;i>1;)for(k=i;k%--i;);return~16&n-3?f(n-k?n-k:n+n-1):n;}

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

अधिक उपयुक्त चर नामों के साथ:

f,r;o(g){for(f=g;f>1;)for(r=f;r%--f;);g=~16&g-3?o(g-r?:g+g-1):g;}

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

Comments

पूरी तरह से मेंढक और आपके चर शब्द के साथ खेलना पसंद है। +1।

— रायरेंग - मोनिका ऑक्ट

Answer 3

रेटिना , 63 62 बाइट्स

1 बाइट बचाने के लिए नील को धन्यवाद।

{`^(11+)(?<!^\2+(11+))(?=\1+$)

^(?!(11+)\1+$|111$|1{19}$)1
$_

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

इनपुट और आउटपुट एकरी में (परीक्षण सूट सुविधा के लिए दशमलव का उपयोग करता है)। यह समाधान बड़े इनपुट के लिए अविश्वसनीय रूप से धीमा हो जाता है। 9983TIO पर बाहर परीक्षण का मामला बार।

व्याख्या

{दोनों के कारण , प्रोग्राम के दोनों चरण बस एक लूप में चलते हैं जब तक कि वे स्ट्रिंग को प्रभावित नहीं करते हैं। हम एक स्टेज प्रोसेसिंग कंपोजिट और एक स्टेज प्रोसेसिंग प्राइम के बीच बारी-बारी से काम करते हैं। यह हमें एक वास्तविक सशर्त से बचने की सुविधा देता है (जो वास्तव में रेटिना में मौजूद नहीं है)। यदि वर्तमान मान मंच के लिए गलत प्रकार है, तो मंच कुछ भी नहीं करता है।

^(11+)(?<!^\2+(11+))(?=\1+$)

यह कंपोजिट को प्रोसेस करता है। हम एक संभावित विभाजक के साथ मेल खाते हैं (11+), लेकिन फिर हम जांचते हैं कि यह समग्र नहीं है (?<!^\2+(11+)), इसलिए हम केवल प्रमुख कारकों पर विचार करते हैं। के लालच के कारण +, यह सबसे बड़े कारक को प्राथमिकता देता है। फिर हम जाँचते हैं कि यह संभावित भाजक एक वास्तविक भाजक है, जो बाकी स्ट्रिंग को इसके दोहराव के साथ मिलाने की कोशिश कर रहा है (?=\1+$)। इस भाजक को केवल स्ट्रिंग से हटा दिया जाता है, जो कि आप कुछ को यूनेरी में घटाते हैं।

^(?!(11+)\1+$|111$|1{19}$)1
$_

यह अभाज्य संख्या है, सिवाय इसके संसाधित करता है 3 और 19 । नकारात्मक लुकहेड सुनिश्चित करता है कि इनपुट समग्र नहीं है, 3 नहीं और 19 नहीं । फिर हम एक एकल मिलान करते हैं 1और इसे पूरे स्ट्रिंग के साथ बदलते हैं। यह कंप्यूटिंग n - 1 + n का एक एक रूप है , जो निश्चित रूप से 2n-1 है ।

एक बार जब हम 3 या 19 को हिट करते हैं , तो न तो चरण स्ट्रिंग से मेल खा सकता है और न ही इसे बदला जा सकेगा।

Comments

के 1$'रूप में ही नहीं है $_?

— नील

@ नील हां ......

— मार्टिन

Answer 4

भूसी , 15 बाइट्स

Ω€p57§|o←DṠ-o→p

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

व्याख्या

Ω€p57§|o←DṠ-o→p  Implicit input n.
Ω                Do this to n until
 €p57            you get a prime factor of 57 (which are 3 and 19):
            o→p   Take last element of the prime factors of n
          Ṡ-      and subtract it from n,
     §|           or if this gives 0 (so n is prime),
       o←D        double and decrement n.

Answer 5

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

_ÆfṂoḤ’$µÐḶṂ

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

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

_ÆfṂoḤ’$µÐḶṂ  Maink link. Argument: n

        µ     Combine the links to the left into a chain.
         ÐḶ   Repeatedly call the chain monadically until the results are no longer
              unique. Yield the loop, i.e., the first occurrence of the first
              repeated integer, up to and excluding the repetition.
              Let's call the argument of the chain k.
_Æf             Subtract all prime factors of k from k.
   Ṃ            Take the minimum of the differences. This yields 0 iff k is prime.
     Ḥ’$        Compute 2k-1.
    o           Take the logical OR of the results.
              The result is now a rotation of either [3, 5, 9, 6] or
              [19, 37, 73, 145, 116, 87, 58, 29, 57, 38].
          Ṃ   Take the minimum, yielding either 3 or 19.

Answer 6

वोल्फ्राम भाषा (गणितज्ञ) , 6566 68 बाइट्स

#//.i:Except[3|19]:>If[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i]&

• -1 बाइट्स, मिशा लावरोव को धन्यवाद!
• -2 बाइट्स, मार्टिन को धन्यवाद!

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

टिप से प्रेरित । असल में, यह सिर्फ एल्गोरिथ्म को फिर से बनाता है।

//.है RepeatedReplaceऔर /;है Condition। इसलिए, कोड मूल्यांकन करने तक i_(एक एकल मात्रा) को बदल देगा ।If[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i]i!=3&&!=19True

आकलन के लिये केंद्रीय बिंदु:

Comments

मजेदार तथ्य: यह कोड बड़ी संख्या के लिए काम नहीं करेगा 10000000010क्योंकिmaximum number of iterations is 2^16 (= 65536)

— J42161217

3 और 19 की जांच करने का एक छोटा तरीका है#//.i:Except[3|19]:>If[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i]&

— मिशा लावरोव

@ मिशालोवरोव लेकिन परिणाम गलत है?

— कीउ गान

मेरे लिए @KeyuGan, दो कार्य पूर्णांक 1000 के माध्यम से पूर्णांक के लिए एक ही परिणाम देते हैं।

— मीशा लावरोव

संभवतः आप जिस मुद्दे को उठा रहे हैं, वह टिप्पणी से कॉपी और पेस्ट करते समय डाला गया अनुचित अक्षर है, जो कभी-कभी होता है।

— मिशा लावरोव

Answer 7

05AB1E , 19 18 17 बाइट्स

[ÐƵηfså#pi·<ëDfθ-

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

व्याख्या

[      #            # loop until
 Ð   så             # a copy of the current value is contained in
  Ƶηf               # the unique prime factors of 171
        pi          # if the current value is prime
          ·<        # double and decrement
            ë   -   # else subtract
             Dfθ    # the largest prime factor of a copy of the current value

Comments

अपने स्रोत कोड में वास्तविक मेंढक होने के लिए +1<ë

— अरनौद

57991 से अधिक 1 मिनट के लिए

— RosLuP

@RosLuP: आप ऑफ़लाइन परीक्षण के बहुत लंबे समय तक चलने वाले मामलों से बेहतर हैं;)

— एमिग्ना

Answer 8

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

f=n=>57%n?f(n-(g=(k,d=1)=>++d<k?k%d?g(k,d):g(k/d):d<n?d:1-n)(n)):n%38

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

f=n=>57%n?f(n-(g=(k,d=1)=>++d<k?k%d?g(k,d):g(k/d):d<n?d:1-n)(n)):n%38

console.log('10   -> ' + f(10))   // 3
console.log('74   -> ' + f(74))   // 19
console.log('94   -> ' + f(94))   // 3
console.log('417  -> ' + f(417))  // 3
console.log('991  -> ' + f(991))  // 19
console.log('9983 -> ' + f(9983)) // 19

प्रारूपित और टिप्पणी की गई

f = n =>                 // given n
  57 % n ?               // if n is neither 3, 19 or 57 (and assuming that n is > 1):
    f(                   //   do a recursive call to f() with:
      n -                //     n minus
      (g = (k, d = 1) => //     the result of the recursive function g():
        ++d < k ?        //       increment d; if d is less than k:
          k % d ?        //         if d is not a divisor of k:
            g(k, d)      //           recursive call to g() with k and d unchanged
          :              //         else:
            g(k / d)     //           recursive call to g() with k = k / d, d = 1
        :                //       else, d is now the highest prime divisor of n:
          d < n ?        //         if d is less than n:
            d            //           n is composite: return d, which results in f(n - d)
          :              //         else:
            1 - n        //           n is prime: return 1 - n, which results in f(2n - 1)
      )(n)               //     initial call to g()
    )                    //   end of recursive call to f()
  :                      // else:
    n % 38               //   return n % 38 (gives 19 as expected if n = 57)

Comments

स्मार्ट, का उपयोग करते हुए 57%nऔर n%38बजाय n==3|n==19। मेरे जावा उत्तर में 1 बाइट को भी सहेजा , इसलिए धन्यवाद!

— केविन क्रूज़सेन

Ideone 57991 में इनपुट prog.js जनरेट करता है: 2: 26 इंटरनल

— इनररर

इन tio f = n => 57% n? F (n- (g = (k, d = 1) => d d <k? K% d? G (k, d): g (k / d) : d <n? d: 1-n) (n)): n% 38 प्रिंट (f (57991)) स्टॉप प्रोग्राम जनरेट नहीं आउटपुट, यह मुझे लगता है

— RosLuP

@RosLuP यह बिना किसी विशिष्ट बाधा के एक कोड-गोल्फ चुनौती है। वर्तमान सर्वसम्मति यह है कि गति या मेमोरी सीमाएं (जैसे कॉल स्टैक आकार) की अवहेलना की जा सकती है जब तक कि प्रश्न में स्पष्ट रूप से अन्यथा न कहा गया हो। मैं इसे इस बात के लिए लेता हूं कि 1000000 की सीमा सिर्फ सूचनात्मक है क्योंकि इस क्रम से परे परीक्षण नहीं किया गया था। संयोग से, आपका 70-बाइट समाधान पूरी तरह से ठीक है और कोड-गोल्फ चुनौती के लिए 93-बाइट संस्करण की तुलना में संभवतः अधिक प्रासंगिक है।

— अरनौलद

Answer 9

जेली , 23 19 बाइट्स

मील से -4 बाइट्स । हालांकि अब भी 05AB1E से अधिक लंबा है।

Ḥ’$_Æf$ÆP?Ṫµḟ3,19$¿

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

Comments

Ḥ’$_Æf$ÆP?Ṫµḟ3,19$¿इसके बजाय थोड़ी देर लूप का उपयोग करना और कुछ फिर से आदेश देना

— मील

Answer 10

पायथन 2 , 110 105 103 101 बाइट्स

-2 बाइट्स @ लियन को धन्यवाद

f=lambda n,i=2,k=0:i/n and(n*(n&~16==3)or f((2*i-1,k-i)[k>0]))or n%i and f(n,i+1,k)or f(n/i,2,k or n)

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

---

पायथन 2 , 116 112 105 बाइट्स

f=lambda n,i=2:i/n*i or n%i and f(n,i+1)or f(n/i)
n=input()
while~16&n-3:n=[2*n-1,n-f(n)][f(n)<n]
print n

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

Comments

…n*(n&~16==3)or…2 बाइट्स बचाता है।

— लिन

इनपुट के लिए 57991 sys.setrecursionlimit (20000)

— RosLuP

Answer 11

MATL , 22 21 बाइट्स

1 बाइट निकालने के लिए @Giuseppe को धन्यवाद !

`tZp?Eq}tYfX>-]tI19h-

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

`           % Do...while
  t         %   Duplicate. Takes (implicit) input the first time
  Zp        %   Is it prime? 
  ?         %   If so
    Eq      %     Times 2, minus 1
  }         %   Else
    t       %     Duplicate
    YfX>-   %     Prime divisors, maximum, subtract
  ]         %   End
  t         %   Duplicate
  I19h      %   Push array [3 19]
  -         %   Subtract, element-wise. The result is truthy if and only if
            %   it doesn't contain any zero
            % End (implicit). Next iteraton if top of the stack is truthy
            % Display (implicit)

Answer 12

हास्केल - 154 बाइट्स

f 3=3
f 19=19
f n
 |(c==[1])=f$2*n-1
 |True=f$n-head c
 where c=z n;v b=reverse[x|x<-[1..(b-1)],b`rem`x==0];z j=case v j of[1]->[1];s->filter((==[1]).v)$s

संभवतया यहां कुछ गोल्फ ट्रिक्स गायब हैं, हैस्केल गोल्फ में यह मेरा पहला प्रयास है।

Comments

नमस्कार और साइट पर आपका स्वागत है। पैटर्न गार्ड के लिए आपको नए लिंक और स्पेस की आवश्यकता नहीं है। आप ज्यादातर समय के 1>0लिए भी उपयोग कर सकते हैं Trueलेकिन अक्सर उदाहरण के लिए असाइनमेंट का उपयोग करना बेहतर हो सकता है c<-z n।

— गेहूं जादूगर

[x|x<-[b-1,b-2..1],rem b x==0]reverse[x|x<-[1..(b-1)],bरेम से भी छोटा है x==0]।

— गेहूं जादूगर

और एक आखिरी बात, अगर आप हैस्केल गोल्फिंग पर चर्चा करना चाहते हैं तो आप हमें मोनाड्स और मेन में शामिल कर सकते हैं ।

— गेहूं जादूगर

Answer 13

नीम , 17 16 बाइट्स

ͻY𝐏𝕚÷D𝐌Ξᚫ<#D𝐏𝐠𝕊

स्पष्टीकरण:

ͻ                   Start infinite loop
 D                  Duplicate
  Y                 Push 57
   𝐏                Prime factors: [3 19]
     𝕚              If the second-to-top of stack is in the list
      ÷             Break the loop
       D            Duplicate
        𝐌Ξᚫ<       If prime, double and decrement
            #D𝐏𝐠𝕊   Otherwise, subtract the largest prime factor

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

Answer 14

आर + संख्या , 102 99 बाइट्स

function(n){while(!n%in%c(3,19))n="if"(isPrime(n),2*n-1,n-max(primeFactors(n)))
n}
library(numbers)

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

आर शॉर्ट बिल्ट-इन के लिए नहीं जाना जाता है, और यहां तक ​​कि पैकेज सूट का पालन करते हैं!

Answer 15

जावा 8, 140 135 134 94 बाइट्स

n->{for(int f,t,m=0;57%n>0;n=f>n?2*n-1:n-m)for(t=n,f=1;f++<t;)for(;t%f<1;t/=m=f);return n%38;}

-5 बाइट्स लूप के साथ जावा 8 लैम्ब्डा में पुनरावर्ती जावा 7 विधि को परिवर्तित करता है।
-1 बाइट निहित धन्यवाद @Arnauld के जावास्क्रिप्ट जवाब बदलकर n!=3&n!=19और return n;करने के लिए 57%n>0और return n%38;।
मुझे लगता है कि यह संभव है कि किसी तरह दो छोरों को मिलाएं और जांचें कि क्या nयह एक प्रमुख है, और यह एक ही समय में सबसे बड़ा कारक है, लेकिन मैं इसका पता नहीं लगा सकता (अभी तक)। तो यह अभी के लिए प्रारंभिक संस्करण होगा।
-40 पूर्ण बाइट्स @Nevay के लिए धन्यवाद, जो मैं नहीं कर सकता था, उसे करने के लिए: एक ही बार में primes और सबसे बड़े प्रमुख कारक के लिए जाँच करने के लिए छोरों का संयोजन।

स्पष्टीकरण:

इसे यहाँ आज़माएँ ( 9999991 सेकंड के अंदर भी निष्पादित )।

n->{                  // Method with integer as both parameter and return-type
  for(int f,          //  Flag-integer
          t,          //  Temp-integer
          m=1;        //  Max prime factor integer, starting at 0
      57%n>0;         //  Loop (1) as long as `n` is not 3, not 19 and not 57:
      n=f>n?          //    After every iteration: if `f` is larger than `n`:
         2*n-1        //     Change `n` to `2*n-1`
        :             //    Else:
         n-m)         //     Change `n` to `n-m`
    for(t=n,          //   Reset `t` to `n`
        f=1;          //   Reset `f` to 1
        f++<t;)       //   Inner loop (2) from 2 to `t` (inclusive)
      for(;t%f<1;     //    Inner loop (3) as long as `t` is divisible by `f`
        t/=m=f;       //     Set `m` to `f`, and set `t` to `t/f`
      );              //    End of inner loop (3)
                      //   End of inner loop (2) (implicit / single-line body)
                      //  End of loop (1) (implicit / single-line body)
  return n%38;        //  Return `n%38`, which is now either 3 or 19
}                     // End of method

Comments

C # पॉलीग्लॉट होने का 1 वर्ण छोटा :(

— इयान एच।

@IanH। हे, हाँ, यह आमतौर पर मामला है: के n=>बजाय n->। और कभी-कभी लोअरकेस / अपरकेस कॉल करता है। ;)

— केविन क्रूज़सेन

94 बाइट्स:n->{for(int f,t,m=0;57%n>0;n=f>n?2*n-1:n-m)for(t=n,f=1;f++<t;)for(;t%f<1;)t/=m=f;return n%38;}

— नेवय

@ नवीन धन्यवाद! मैं सिर्फ यह जानता था कि लूप्स को संयोजित करना संभव है, लेकिन यह पता नहीं लगा सका। एक 40 से अधिक बाइट्स आप के लिए धन्यवाद बचाया!

— केविन क्रूज़सेन

Answer 16

बैश, 73 बाइट्स

((57%$1))&&$0 $[(x=$1-`factor $1|sed 's/.* //'`)?x:2*$1-1]||echo $[$1%38]

इसे ऑनलाइन आज़माएं! TIO पर काम करने के लिए थोड़ा संशोधित।

पुन: उपयोग करके अपनी स्वयं की स्क्रिप्ट फ़ाइल को कॉल करता है$0 , जो TIO में काम नहीं करता है क्योंकि इसे उसी रूप में चलाया जाना चाहिए./filename.sh । इनपुट को कमांड-लाइन तर्क के रूप में स्वीकार करता है।

@ अरनौलड के जेएस उत्तर के समान मापांक चाल का उपयोग करता है ।

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

$ for t in 5 23 10 74 94 417 991 9983;{ echo -n "$t -> "; ./prime-frog.sh $t; }
5 -> 3
23 -> 3
10 -> 3
74 -> 19
94 -> 3
417 -> 3
991 -> 19
9983 -> 19

Answer 17

पायथन 3 , 97 बाइट्स

f=lambda n:n*(n&-17==3)or f(n-max(k*all(n%k<k%j for j in range(2,k))for k in range(n+1))or 2*n-1)

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

Comments

57991 इनपुट के लिए 1 मिनट पर्याप्त नहीं था

— RosLuP

Answer 18

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

.W!/P57H?P_ZtyZ-ZeP

सभी परीक्षण मामलों की पुष्टि करें!

भूसी जवाब मुझे (2 बाइट्स को बचाने के लिए प्रेरित ,3 19करने के लिए P57)।

यह कैसे काम करता है

.W / / P57H? P_ZtyZ-ZeP - पूर्ण कार्यक्रम।

.W - कार्यात्मक जबकि जबकि A (मान) सत्य है, मान = B (मान)। अंतिम मान लौटाता है।
    पी 57 - 57 ([3, 19]) के प्रमुख कारक।
   / एच - वर्तमान मूल्य की घटनाओं को गिनें।
  ! - तार्किक नहीं। ० -> सत्य, कुछ भी -> मिथ्या।
        ? P_Z - यदि वर्तमान मान प्रधान है, तो:
            tyZ - वर्तमान मूल्य को दोगुना, घटाना।
               -ZeP - एल्स, वर्तमान मूल्य के अधिकतम प्रमुख कारक को खुद से घटाएं।
                     - स्पष्ट रूप से प्रिंट करें।

Answer 19

पॉवरशेल , 150 126 बाइट्स

for($n="$args";57%$n){$a=$n;$d=for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}};if($n-in$d){$n+=$n-1}else{$n-=$d[-1]}}$n%38

इसे ऑनलाइन आज़माएं! (चेतावनी: बड़ी संख्या के लिए धीमा)

Iterative विधि। PowerShell का कोई भी मुख्य कारक नहीं है, जो बनाया गया है, इसलिए यह प्राइम फैक्टर्स दोस्तों के मेरे जवाब से उधार लिया गया कोड है ।

पहले हमारा forपाश है। सेटअप $nइनपुट मान होने के लिए सेट करता है, और सशर्त लूप को तब तक चालू रखता है जब तक कि 57%$nवह शून्य न हो ( उस चाल के लिए अरनौलड के लिए धन्यवाद )। लूप के अंदर हमें सबसे पहले $a(सेट टू $n) के मुख्य कारकों की एक सूची मिलती है । यह प्राइम फैक्टर्स फ्रेंड्स से लिया गया कोड है। यदि इनपुट $aपहले से ही प्रमुख है, तो यह सिर्फ $a(महत्वपूर्ण बाद में) वापस आ जाएगा । वह (संभावित बस $a) में संग्रहीत हो जाता है $d।

अगला एक if/ elseसशर्त है। के लिए ifहिस्सा है, हम जाँच करें कि क्या $nहै -in $d। यदि यह है, तो इसका मतलब है कि $nप्राइम है, इसलिए हम लेते हैं $n=2*$n-1या $n+=$n-1। अन्यथा, यह समग्र है, इसलिए हमें सबसे बड़ा प्रमुख कारक खोजने की आवश्यकता है। मतलब है कि हम पिछले एक लेने की जरूरत [-1]की $dऔर घटाना है कि से $nसाथ $n-=। यह काम करता है क्योंकि हम ऊपर से लूप कर रहे हैं 2और इस तरह का अंतिम तत्व $dपहले से ही सबसे बड़ा होने जा रहा है।

एक बार जब हम लूपिंग कर लेते हैं, तो हम $n%38पाइपलाइन और आउटपुट पर सिर्फ जगह (फिर से, धन्यवाद अरनौल्ड) लगाते हैं।

Answer 20

एपीएल (डायलॉग यूनिकोड) , 113 90 59 बाइट्स

⎕CY 'dfns'
g←{1pco ⍵:f(2×⍵)-1⋄f⍵-⊃⌽3pco ⍵}
f←{⍵∊3 19:⍵⋄g ⍵}

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

TIO ~ 3200 तक के मानों के साथ काम करता है। पिछले परीक्षण मामले के लिए मेरे पीसी पर परीक्षण किया गया। TIO पर परीक्षण करने के लिए, बस f valueकोड के निचले भाग में जोड़ें । अब लागू नहीं होता, @ Adám को इंगित करने के लिए धन्यवाद कि मेरी मौलिकता की जाँच एल्गोरिथ्म वास्तव में खराब था और मुझे प्रतिस्थापन के साथ आपूर्ति कर रहा था; 23 बाइट बचाने के लिए भी।

बाइट गिनती को ठीक करने के लिए संपादित।

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

⎕CY 'dfns'                      # Imports every Defined Function, which is shorter than importing just the function I used (pco).

g←{1pco ⍵:f(2×⍵)-1⋄f⍵-⊃⌽3pco ⍵} 
g←                              # define g as
   1pco ⍵:                      # if the argument ⍵ is prime
          f(2×⍵)-1              # Call f over 2×⍵-1
                  ⋄f            # else, call f over
                    ⊃           # the first element of the
                      3pco ⍵    # list of prime factors of ⍵
                     ⌽          # reversed

f←{⍵∊3 19:⍵⋄g ⍵}
f←                              # Define f as
   ⍵     :                      # if the argument ⍵
    ∊                           # is in
     3 19                       # the list [3, 19]
          ⍵                     # return the argument ⍵
           ⋄                    # else
            g ⍵                 # call g over the argument ⍵

Answer 21

Axiom, 93 बाइट्स

h(n)==(repeat(n=3 or n=19 or n<2=>break;prime? n=>(n:=2*n-1);n:=n-last(factors(n)).factor);n)

परीक्षा:

(4) -> [[i,h(i)] for i in [10,74,94,417,991,9983]]
   (4)  [[10,3],[74,19],[94,3],[417,3],[991,19],[9983,19]]
                                                  Type: List List Integer

वहाँ 68 बाइट्स समारोह होगा

q x==(n<4=>3;n=19=>n;prime? n=>q(2*n-1);q(n-last(factors n).factor))

लेकिन n = 57991 के लिए (अगर मुझे अच्छी तरह याद है) तो यह स्टैक स्पेस आरक्षित हो जाता है।

Answer 22

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

बाहरी कामों के बिना TFeld के जवाब से पोर्ट ।

n=input()
while~16&n-3:
 f=n;i=2
 while i<f:
	if f%i:i+=1
	else:f/=i
 n-=[1-n,f][f<n]
print n

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