ในห้องของฉันฉันมีนาฬิกาที่น่ากลัวนี้ (คลิกเพื่อดูขนาดเต็ม):

สิ่งเหล่านี้ส่วนใหญ่ไม่ยากที่จะเข้าใจ แต่สำหรับ 4-นาฬิกามีเล่ห์เหลี่ยมโดยเฉพาะ:

โดยปกติเศษส่วนเช่น 1/2 ไม่สมเหตุสมผลในคณิตศาสตร์เลขคณิตเนื่องจากมีเพียงจำนวนเต็มเท่านั้นที่เกี่ยวข้อง วิธีที่ถูกต้องนั้นเป็นที่เห็นนี้เป็นสิ่งที่ตรงกันข้ามของ 2, หรือจะนำมันอีกทางหนึ่งคือตัวเลขที่ที่ วางวิธีนี้คิดอยู่ครู่จะเผยให้เห็นว่าเพราะ

อย่างไรก็ตามเพียงแค่ค้นหาการผกผันทวีคูณจะง่ายเกินไปที่จะท้าทาย งั้นลองชนความยากลำบากในการยกกำลังหรือพูดอีกอย่างคือหาลอการิทึมแบบแยกส่วนหรือลอการิทึมแบบแยกส่วนของ 2 ในกรณีนี้ 3 คือลอการิทึมแบบแยกส่วนของ 2 เทียบกับ 7 สำหรับ 7 ของคุณที่มีทฤษฎีจำนวน / พีชคณิตนามธรรม พื้นหลังซึ่งหมายความว่าการคำนวณคำสั่งคูณของ 2 โมดูโล n

ความท้าทาย

ได้รับในเชิงบวกคี่จำนวนเต็มnมากกว่า 1, เอาท์พุทจำนวนเต็มบวกที่เล็กที่สุดที่x

ตัวอย่าง

n x
3 2 
5 4 
7 3 
9 6 
11 10 
13 12 
15 4 
17 8 
19 18 
21 6 
23 11 
25 20 
27 18 
29 28 
31 5 
33 10 
35 12 
37 36 
39 12 
41 20 
43 14 
45 12 
47 23 
49 21 
51 8 
53 52 
55 20 
57 18 
59 58 
61 60 
63 6 
65 12 
67 66 
69 22 
71 35 
73 9 
75 20 
77 30 
79 39 
81 54 
83 82 
85 8 
87 28 
89 11 
91 12 
93 10 
95 36 
97 48 
99 30 
101 100 
103 51 
105 12 
107 106 
109 36 
111 36 
113 28 
115 44 
117 12 
119 24 
121 110 
123 20 
125 100 
127 7 
129 14 
131 130 
133 18 
135 36 
137 68 
139 138 
141 46 
143 60 
145 28 
147 42 
149 148 
151 15 
153 24 
155 20 
157 52 
159 52 
161 33 
163 162 
165 20 
167 83 
169 156 
171 18 
173 172 
175 60 
177 58 
179 178 
181 180 
183 60 
185 36 
187 40 
189 18 
191 95 
193 96 
195 12 
197 196 
199 99 
201 66 

เยลลี่ 6 ไบต์

R2*%i1

ลองออนไลน์!

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

R2*%i1  Input: n

R       Range; yield [1, ..., n].
 2*     Compute [2**1, ..., 2**n].
   %    Hook; take all powers modulo n.
    i1  Get the index of the first 1.
        Indices are 1-based, so index k corresponds to the natural number k.

Pyth - 9 8 ไบต์

f!t.^2TQ

Test Suite

filters จากค่าเริ่มต้นของ 1 จนกว่าจะพบ x บางอย่างเช่นการยกกำลังแบบแยกส่วนที่มี 2 และอินพุตเท่ากับ 1

Python ขนาด 32 ไบต์

f=lambda n,t=2:t<2or-~f(n,2*t%n)

เริ่มต้นด้วย 2, เพิ่ม modulo n เป็นสองเท่าจนกระทั่งผลลัพธ์คือ 1, เพิ่มขึ้นซ้ำ ๆ ในแต่ละครั้ง, และลงท้ายด้วยจำนวน 1 สำหรับค่าเริ่มต้นที่ 2

Mathematica ขนาด 24 ไบต์

2~MultiplicativeOrder~#&

ฉันเพิ่งใช้ตัวนี้มา

APL, 8 ไบต์

1⍳⍨⊢|2*⍳

นี่คือรถไฟฟังก์ชั่น monadic ที่รับจำนวนเต็มทางด้านขวาและส่งกลับจำนวนเต็ม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

คำอธิบาย (การเรียกอินพุตx):

      2*⍳    ⍝ Compute 2^i for each i from 1 to x
   ⊢|        ⍝ Get each element of the resulting array modulo x
1⍳⍨          ⍝ Find the index of the first 1 in this array

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

Pyth, 14 ไบต์

VQIq%^2hNQ1hNB

คำอธิบาย:

VQIq%^2hNQ1hNB

                # Implicit, Q = input
VQ              # For N in range(0, Q)
  Iq      1     # If equals 1
    %^2hNQ      # 2^(N + 1) % Q
           hN   # Print (N + 1)
             B  # Break

ลองที่นี่

JavaScript (ES6), 28 ไบต์

f=(n,t=2)=>t<2||-~f(n,2*t%n)

ขึ้นอยู่กับวิธีเรียกซ้ำที่ยอดเยี่ยมของ @ xnor

05AB1E , 11 ไบต์

รหัส:

DUG2NmX%iNq

คำอธิบาย:

DUG2NmX%iNq

D            # Duplicates the stack, or input when empty
 U           # Assign X to last item of the stack
  G          # For N in range(1, input)
   2Nm       # Calculates 2 ** N
      X      # Pushes X
       %     # Calculates the modulo of the last two items in the stack
        i    # If equals 1 or true, do { Nq }
         N   # Pushes N on top of the stack
          q  # Terminates the program
             # Implicit, nothing has printed, so we print the last item in the stack

Julia, 25 24 ไบต์

n->endof(1∪2.^(1:n)%n)

มันง่ายมาก - 2.^(1:n)%nค้นหาพลังของ 2 ภายในเซต∪คือunionแต่ทำหน้าที่เป็นuniqueและส่งกลับเฉพาะหนึ่งในพลังที่ไม่ซ้ำกัน (และเนื่องจากเป็นโอเปอเรเตอร์มัดฉันจึงสามารถรวมกับ 1 เพื่อประหยัดไบต์ด้วย∪(2.^(1:n)%n)วิธี) จากนั้นendofนับจำนวนพลังที่ไม่ซ้ำกันเพราะเมื่อมันกระทบกับ 1 มันจะทำซ้ำพลังที่มีอยู่เดิมดังนั้นจะมีค่าที่ไม่ซ้ำกันมากเท่ากับพลังที่สร้าง 1

อย่างจริงจัง 14 ไบต์

1,;╗R`╙╜@%`Míu

ฐานสิบหก:

312c3bbb5260d3bd4025604da175

ลองใช้ออนไลน์

คำอธิบาย:

 ,;╗           Make 2 copies of input, put 1 in reg0
    R          push [0,1,...,n-1]
     `    `M   map the quoted function over the range
      ╙        do 2^n
       ╜@%     modulo the value in reg0
1           íu Find the 1-index of 1 in the list.

Haskell ขนาด 30 ไบต์

n%1=1
n%t=1+n%(2*t`mod`n)
(%2)

อาร์กิวเมนต์ตัวช่วยtเป็นแบบโมดูโลสองเท่าnในแต่ละขั้นตอนจนกว่ามันจะเท่ากับ 1

Japt, 17 ไบต์

1oU f@2pX %U¥1} g

ลองออนไลน์!

นี่จะสั้นลงสามไบต์ถ้า Japt มีฟังก์ชัน "ค้นหารายการแรกที่ตรงกับเงื่อนไขนี้" เริ่มทำงานกับสิ่งใดสิ่งหนึ่ง

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

1oU f@2pX %U¥1} g   // Implicit: U = input number
1oU                 // Generate a range of numbers from 1 to U.
                    // "Uo" is one byte shorter, but the result would always be 0.
    f@        }     // Filter: keep only the items X that satisfy this condition:
      2pX %U¥1      //  2 to the power of X, mod U, is equal to 1.
                g   // Get the first item in the resulting list.
                    // Implicit: output last expression

PARI / GP ขนาด 20 ไบต์

n->znorder(Mod(2,n))

Julia, 33 26 ไบต์

n->findfirst(2.^(1:n)%n,1)

นี่คือฟังก์ชั่นแลมบ์ดาที่รับจำนวนเต็มและคืนค่าจำนวนเต็ม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

เราสร้างอาร์เรย์เป็น 2 ยกกำลังแต่ละจำนวนเต็มจาก 1 ถึงnแล้วเราพบดัชนีของ 1 แรกในอาร์เรย์นี้

บันทึกแล้ว 7 ไบต์ขอบคุณ Glen O!

Perl 5, 29 ไบต์

$n=<>;{2**++$_%$n-1?redo:say}

ปลายหมวก

MATL , 13 ไบต์

it:Hw^w\1=f1)

รันบน Octave ด้วยGitHub ปัจจุบันคอมมิตของคอมไพเลอร์

ใช้งานได้กับอินพุตสูงสุด51(เนื่องจากข้อ จำกัด ของdoubleชนิดข้อมูล)

ตัวอย่าง

>> matl it:Hw^w\1=f1)
> 17
8

คำอธิบาย

i             % input, "N"
t:            % vector from 1 to N
Hw^           % 2 raised to that vector, element-wise
w\            % modulo N
1=            % true if it equals 1, element-wise
f1)           % index of first "true" value

ยูนิคอร์น , 1307 1062 976 ไบต์

( ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 ( 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 2 ) 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨✨✨✨ 2 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ ( 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 2 ✨✨✨✨✨✨✨ 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 ) ) ( 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( ) )

ฉันกำลังพยายามทำให้ยูนิคอร์นเป็นภาษากอล์ฟที่จริงจัง แต่มันก็ค่อนข้างยาก ...

หวังว่าฉันจะหาวิธีที่จะรักษา "ยูนิคอร์นเนส" ของภาษาในขณะที่ไบต์น้อยมาก

ภาพ:

ใช้แบบกำหนดเองเข้ารหัสที่

คำตอบนี้ไม่สามารถแข่งขันได้เนื่องจากใช้รุ่นของ Unicorn ที่สร้างขึ้นหลังจากภาษานี้

𝔼𝕊𝕄𝕚𝕟, 11 ตัวอักษร / 22 ไบต์

↻2ⁿḁ%ï>1)⧺ḁ

Try it here (Firefox only).

ใช้การวนรอบสักครู่ นี่เป็นหนึ่งในไม่กี่ครั้งในขณะที่การวนซ้ำดีกว่าการทำแผนที่ในช่วง

คำอธิบาย

          // implicit: ï = input, ḁ = 1
↻2ⁿḁ%ï>1) // while 2 to the power of ḁ mod input is greater than 1
  ⧺ḁ      // increment ḁ
          // implicit output

CJam, 15 ไบต์

2qi,:)f#_,f%1#)

Peter Taylor บันทึกหนึ่งไบต์ เรียบร้อย!

Prolog, 55 ไบต์

รหัส:

N*X:-powm(2,X,N)=:=1,write(X);Z is X+1,N*Z.
p(N):-N*1.

อธิบาย:

N*X:-powm(2,X,N)=:=1, % IF 2^X mod N == 1
     write(X)         % Print X
     ;Z is X+1,       % ELSE increase exponent X
     N*Z.             % Recurse
p(N):-N*1.            % Start testing with 2^1

ตัวอย่าง:

p(195).
12

ลองออนไลน์ได้ที่นี่