ตัวเลขแฟร์มาต์เป็นจำนวนเต็มบวกที่สามารถแสดงเป็น 2 ^{2 x} +1 ด้วยจำนวนเต็ม x

ให้เรากำหนดคุณลักษณะของจำนวนที่เรียกว่า "แฟร์มาต์เนส":

• แฟร์มาต์ของจำนวนนั้นน้อยกว่าความยาวของห่วงโซ่แห่งพลังทั้งสองเริ่มต้นจากฐานด้วยพลังของทั้งสองขยายตัวเพื่อเพิ่มความสมบูรณ์ของแฟร์มาต์
• หมายเลขที่ไม่ใช่หมายเลขแฟร์มาต์มีจำนวนแฟร์มาต์เป็นศูนย์

ดังนั้น 17 (= 2 ^{2 2 2 0} +1) มีแฟร์มาต์สามคน

ท้าทาย

รับจำนวนเต็มบวกที่ไม่ใช่ศูนย์เป็นอินพุตส่งออกแฟร์มาต์ของจำนวน

กฎระเบียบ

• คุณสามารถรับอินพุตเป็นเลขฐานสองทศนิยมฐานสิบหกเป็นค่าขยายหรือรูปแบบใดก็ตามที่ช่วยให้คุณตีกอล์ฟได้ดีที่สุด
• โซลูชันของคุณจะต้องสามารถประมวลผลหมายเลขที่มีความยาวบิตมากกว่า 64 ไม่ว่าคุณจะใช้วิธีใด
• จำนวนเต็มไม่ใช่ค่าลบเท่านั้น
• แน่นอนช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดจึงชนะ

กรณีทดสอบ

input->outputเหล่านี้อยู่ในรูปแบบ อินพุตอยู่ในเลขฐานสิบหกเพื่อประหยัดพื้นที่

10000000000000000000000000000000000000000000000000000000000000001 -> 2
1000000000000BC00000000000000000000000000000000001000000000000001 ->0
1234567890ABCDEF -> 0
100000000000000000000000000000001 -> 1
5 -> 2
11 -> 3
10001 -> 4
101 -> 1

ทศนิยมเหมือนกัน:

115792089237316195423570985008687907853269984665640564039457584007913129639937 -> 2
115792089237316497527923305698859709742143344804209838213621568094470773145601 -> 0
1311768467294899695 -> 0
340282366920938463463374607431768211457 -> 1
5 ->2
17 -> 3
65537 -> 4
257 -> 1

ขอบคุณgeokavelสำหรับการป้อนข้อมูลที่ทรงคุณค่าในกล่องทราย

เยลลี่ , 15 14 ไบต์

1 ไบต์ขอบคุณ Jonathan Allan

’µBḊ⁸LṀ?µÐĿḊḊL

ลองออนไลน์!

Python 2 , 103 81 ไบต์

n=input()-1
i=l=0
while 2**2**i<=n:
 if n==2**2**i:n=2**i;i=-1;l+=1
 i+=1
print l

ลองออนไลน์!

ฉันรู้ว่าการไม่งี่เง่าจะช่วยลดจำนวนไบต์ลงดังนั้นฉันจึงทำเช่นนั้น นอกจากนี้ยังมีการยกกำลังเมื่อเทียบกับลอการิทึม

RProgN 2 , 75 ไบต์

«\`n=1\]{1-\n*\]}:[»`^=«1-`n=001{]2\^2\^ne{2\^`n=1+0}{1+}?]2\^2\^n>¬}:[»`¤=

ลองออนไลน์!

มีเพียง 70 ไบต์เท่านั้นหากคุณไม่เพิ่มตัวเลือก«»'¤=ที่กำหนดการคำนวณแบบเฟนเนสให้กับ¤ตัวละคร หากคุณทำเช่นนั้นคุณจะต้องใส่หมายเลขในส่วนหัวของ TIO แทนในท้ายกระดาษเหมือนตอนนี้

วิธีนี้ใช้ตรรกะเดียวกันกับคำตอบของ Python ของฉันอย่างมีประสิทธิภาพดังนั้นหากคุณไม่สนใจว่า RProgN 2 ทำงานอย่างไรให้ดูที่คำอธิบายสิ่งที่เกิดขึ้น มิฉะนั้น

การวิเคราะห์รหัส:

«\`n=1\]{1-\n*\]}:[»`^=
«                  »`^=`                            # Create a local function and assign it to the ^ character (x y ^ is x to the power of y)
 \`n=                                               # Swap the top two values of the stack and assign the new top to the variable n
     1\]                                            # Push a 1 (our starting point for x to the y), swap with the y value, then duplicate y
        {       }:                                  # Start a while loop that pops the top stack value and loops if it is truthy
         1-                                         # Subtract 1 from y to keep a tally of how many multiplications we've done
           \n*                                      # Swap the counter with our current value and multiply it by n
              \]                                    # Swap this new value with the current value of y, and duplicate it to be used as the truthy value for the loop

«1-`n=001{]2\^2\^ne{2\^`n=1+0}{1+}?]2\^2\^n>¬}:[»`¤=# The main Fermatness function (x ¤ to get the Fermatness of x)
«                                               »`¤=# Create another local function for this calculation
 1-`n=                                              # Decrement the input by 1 and assign it to n
      001                                           # Push a counter for Fermatness, a counter for calculating 2^2^i, and an initial truthy value
         {                                   }:     # Start a while loop for calculating the Fermatness
          ]2\^2\^ne                                 # Duplicate i, calculate 2^2^i, and compare it to n
                   {         }{  }?                 # Start an if statement based on the equality of 2^2^i and n
                    2\^`n=                          # n==2^2^i, so set n to 2^i (same as saying n=log_2(n))
                          1+0                       # Increment the Fermatness counter and reset i
                               1+                   # n!=2^2^i, so just increment i
                                   ]2\^2\^n>¬       # Duplicate the counter and check if 2^2^i<=n, if true the loop continues, else it exits
                                               [    # Pop i from the stack, leaving us with just the Fermatness counter

น่าเสียดายที่ฟังก์ชันบันทึกŠและฟังก์ชันการยกกำลังตามปกติ^ขาดความแม่นยำในการทำสิ่งนี้ดังนั้นฉันต้องกำหนดวิธีการยกกำลังอีกครั้งเนื่องจากการคูณมีความแม่นยำมากขึ้น หากไม่มีการกำหนดใหม่คำตอบนี้จะสั้นกว่า 23 ไบต์

Perl 6 , 62 ไบต์

{my@a=first :kv,*>=0,(^∞).map(2**2** *+1-$_);++@a[0]*!@a[1]}

ลองออนไลน์!