"กบตัวเต็มวัย" เป็นสัตว์ประหลาดที่กระโดดข้ามจำนวนเต็มจนกระทั่งมันมาถึง 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(ฉันได้ตรวจสอบว่าโปรแกรมสิ้นสุดลงสำหรับค่าเหล่านี้)

Python 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

ลองออนไลน์!

C (gcc),  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;}

ลองออนไลน์!

เรติน่า , 63 62 ไบต์

ขอบคุณ Neil สำหรับการบันทึก 1 ไบต์

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

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

ลองออนไลน์!

อินพุทและเอาท์พุทเป็นเอกภาพ (ชุดทดสอบใช้ทศนิยมเพื่อความสะดวก) โซลูชันนี้ทำงานช้ามากสำหรับอินพุตที่ใหญ่ขึ้น 9983กรณีทดสอบครั้งจากบน TIO

คำอธิบาย

เนื่องจาก{ทั้งสองขั้นตอนของโปรแกรมถูกเรียกใช้ในลูปจนกว่าจะไม่มีผลกับสตริงอีกต่อไป เราสลับระหว่างคอมโพสิตการประมวลผลขั้นตอนและช่วงเวลาการประมวลผลขั้นตอน นั่นทำให้เราหลีกเลี่ยงเงื่อนไขที่แท้จริง (ซึ่งไม่มีอยู่จริงใน Retina) หากค่าปัจจุบันเป็นชนิดที่ไม่ถูกต้องสำหรับเวทีเวทีจะไม่ทำอะไรเลย

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

คอมโพสิตกระบวนการนี้ เราจับคู่ตัวหารที่มีศักยภาพด้วย(11+)แต่จากนั้นเราตรวจสอบว่ามันไม่ได้ประกอบเข้าด้วย(?<!^\2+(11+))กันดังนั้นเราจึงพิจารณาเฉพาะปัจจัยสำคัญเท่านั้น เนื่องจากความโลภของ+นี้จัดลำดับความสำคัญของปัจจัยที่ใหญ่ที่สุด จากนั้นเราจะตรวจสอบว่าตัวหารที่มีศักยภาพเป็นจริง(?=\1+$)หารโดยพยายามที่จะตรงกับส่วนที่เหลือของสตริงที่มีการเกิดซ้ำของมัน ตัวหารนี้จะถูกลบออกจากสตริงซึ่งเป็นวิธีที่คุณลบบางอย่างออกจากกัน

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

กระบวนการนี้เฉพาะยกเว้น3และ19 lookahead เชิงลบทำให้แน่ใจว่าการป้อนข้อมูลที่ไม่ได้เป็นคอมโพสิตไม่ได้3และไม่ได้19 จากนั้นเราจับคู่เดี่ยว1และแทนที่ด้วยสตริงทั้งหมด นี้เป็นรูปแบบของการคำนวณเอกn - 1 + nซึ่งแน่นอนเป็น2n-1

เมื่อเรากด3หรือ19สเตจจะไม่สามารถจับคู่สตริงได้และจะไม่มีการเปลี่ยนแปลงอีกต่อไป

Huskขนาด 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.

เยลลี่ 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.

ภาษา Wolfram (Mathematica) , 6566 68 ไบต์

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

• -1 ไบต์ขอบคุณ Misha Lavrov!
• -2 ไบต์ขอบคุณ Martin!

ลองออนไลน์!

แรงบันดาลใจจากปลาย โดยพื้นฐานแล้วมันจะสร้างอัลกอริทึมขึ้นมาใหม่

//.เป็นRepeatedReplaceและเป็น/; Conditionดังนั้นรหัสจะเข้ามาแทนที่i_(ปริมาณเดี่ยว) กับIf[PrimeQ@i,2i-1,i-#&@@Last@FactorInteger@i]จนประเมินi!=3&&!=19True

เกณฑ์มาตรฐาน:

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

JavaScript (ES6), 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)

เยลลี่ , 23 19 ไบต์

-4 ไบต์จากไมล์ แม้ว่าจะยาวกว่า 05AB1E ก็ตาม

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

ลองออนไลน์!

Python 2 , 110 105 103 101 ไบต์

-2 ไบต์ต้องขอบคุณ @Lynn

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)

ลองออนไลน์!

Python 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

ลองออนไลน์!

MATL , 22 21 ไบต์

ขอบคุณ@Giuseppeสำหรับการลบ 1 ไบต์!

`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)

Haskell - 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

อาจพลาดลูกเล่นกอล์ฟที่นี่นี่เป็นความพยายามครั้งแรกของฉันที่สนามกอล์ฟ Haskell

Neim , 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

ลองออนไลน์!

หมายเลขR + , 102 99 ไบต์

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

ลองออนไลน์!

R ไม่เป็นที่รู้จักสำหรับตัวบิวด์อินสั้นและแม้แต่แพ็คเกจตามหลัง!

Java 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 ไบต์แปลงวิธี Java 7 recursive เป็น Java 8 แลมบ์ดาพร้อมลูป
-1 ไบต์ขอบคุณส่อไป@Arnauldคำตอบ JavaScript 'sโดยการเปลี่ยนn!=3&n!=19และreturn n;ไปและ57%n>0 ฉันคิดว่ามันน่าจะเป็นไปได้ที่จะรวมสองลูปเข้าด้วยกันและตรวจสอบว่ามันเป็นนายกหรือไม่และได้รับมันเป็นปัจจัยที่สำคัญที่สุดในเวลาเดียวกัน แต่ฉันก็ยังไม่สามารถหามันได้ ดังนั้นนี่จะเป็นเวอร์ชั่นเริ่มต้นในตอนนี้ -40 มหันต์ไบต์ขอบคุณ @Nevay โดยทำสิ่งที่ฉันทำไม่ได้: การรวมลูปเพื่อตรวจสอบช่วงเวลาและปัจจัยสำคัญที่สุดในคราวเดียวreturn n%38;
n

คำอธิบาย:

ลองที่นี่ (ดำเนินการแม้999999ในเวลาไม่ถึง1 วินาที)

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

Bash, 73 ไบต์

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

ลองออนไลน์! แก้ไขเล็กน้อยเพื่อให้ทำงานกับ TIO

ซ้ำเรียกไฟล์สคริปต์ของตัวเองโดยใช้$0, ซึ่งไม่ทำงานใน TIO ./filename.shเพราะมันจะต้องวิ่งตาม ยอมรับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง

ใช้เคล็ดลับโมดูลัสเช่นเดียวกับ@ Arnauld คำตอบของ

กรณีทดสอบ

$ 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

Python 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)

ลองออนไลน์!

Pyth , 19 ไบต์

.W!/P57H?P_ZtyZ-ZeP

ตรวจสอบกรณีทดสอบทั้งหมด!

คำตอบแกลบแรงบันดาลใจที่จะบันทึก 2 ไบต์ ( ,3 19เพื่อP57)

มันทำงานอย่างไร

.W! / P57H? P_ZtyZ-ZeP - โปรแกรมเต็มรูปแบบ

.W - ใช้งานได้ในขณะที่ ในขณะที่ A (ค่า) คือความจริงค่า = B (ค่า) ส่งคืนค่าสุดท้าย
    P57 - ปัจจัยสำคัญของ 57 ([3, 19])
   / H - นับจำนวนที่เกิดขึ้นของค่าปัจจุบัน
  ! - ตรรกะไม่ 0 -> Truthy อะไรก็ได้ -> Falsy
        ? P_Z - หากค่าปัจจุบันเป็นจำนวนเฉพาะแล้ว:
            tyZ - เพิ่มค่าปัจจุบันเป็นสองเท่า
               -ZeP - อื่นลบค่าตัวประกอบสำคัญสูงสุดของมูลค่าปัจจุบันจากตัวมันเอง
                     - พิมพ์โดยนัย

PowerShell , 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

ลองออนไลน์! (คำเตือน: ช้าสำหรับจำนวนที่มากขึ้น)

วิธีการทำซ้ำ PowerShell ไม่ได้มีตัวประกอบที่สำคัญ ๆ สร้างอินดังนั้นนี้ยืมโค้ดจากคำตอบของฉันบนนายกรัฐมนตรีปัจจัยเพื่อน

อันดับแรกคือการforวนซ้ำของเรา การตั้งค่ากำหนด$nให้เป็นค่าอินพุตและเงื่อนไขทำให้ลูปเป็นไปตราบเท่าที่57%$nไม่เป็นศูนย์ (ขอบคุณArnauldสำหรับเคล็ดลับนั้น) ในวงแรกเราจะได้รับรายการปัจจัยสำคัญของ$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(อีกครั้งขอบคุณ Arnauld) บนไปป์ไลน์และเอาท์พุทก็เป็นนัย

APL (Dyalog Unicode) , 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 ⍵

ความจริง 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 (ถ้าฉันจำได้ดี) มันจะหมดพื้นที่สแต็กที่สงวนไว้

Python 2 , 93 ไบต์

พอร์ตจากคำตอบของ TFeldโดยไม่มี libs ภายนอก

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

ลองออนไลน์!