Trong phòng của tôi, tôi có chiếc đồng hồ táo bạo này (bấm vào để xem kích thước đầy đủ):

Hầu hết trong số này không khó để tìm ra, nhưng một trong những đồng hồ 4 giờ đặc biệt khó khăn:

Thông thường, một phân số như 1/2 không có ý nghĩa trong số học mô-đun vì chỉ có các số nguyên được tham gia. Sau đó, cách chính xác là xem đây là nghịch đảo của 2, hoặc đặt nó theo một cách khác, đó là số đó . Đặt theo cách này, một khoảnh khắc suy nghĩ sẽ tiết lộ rằng bởi vì .

Tuy nhiên, chỉ đơn giản là tìm ra phép nghịch đảo nhân sẽ quá dễ dàng như một thách thức. Vì vậy, hãy khắc phục khó khăn cho phép lũy thừa, hay nói cách khác là tìm logarit mô đun hoặc logarit rời rạc của 2. Trong trường hợp này, 3 là logarit mô đun của 2 đối với 7. Đối với những bạn có lý thuyết số / đại số trừu tượng nền, điều này có nghĩa là tính toán thứ tự nhân của 2 modulo n.

Các thách thức

Cho một số nguyên lẻ dương nlớn hơn 1, xuất ra số nguyên dương nhỏ nhất xtrong đó .

Ví dụ

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 

Thạch , 6 byte

R2*%i1

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

f!t.^2TQ

Phòng thử nghiệm .

filters từ mặc định là 1 cho đến khi tìm thấy một số x sao cho lũy thừa mô đun với 2 và đầu vào bằng 1.

Python, 32 byte

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

Bắt đầu bằng 2, nhân đôi modulo n cho đến khi kết quả là 1, tăng dần theo từng lần và kết thúc bằng số 1 cho giá trị ban đầu là 2.

Toán học, 24 byte

2~MultiplicativeOrder~#&

Tôi chỉ sử dụng một tích hợp cho việc này.

APL, 8 byte

1⍳⍨⊢|2*⍳

Đây là một hàm hàm đơn nguyên chấp nhận một số nguyên ở bên phải và trả về một số nguyên. Để gọi nó, gán nó cho một biến.

Giải thích (gọi đầu vào 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

Lưu ý rằng kết quả có thể không chính xác cho các đầu vào lớn vì số mũ được làm tròn.

Bình thường, 14 byte

VQIq%^2hNQ1hNB

Giải trình:

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

Hãy thử nó ở đây

JavaScript (ES6), 28 byte

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

Dựa trên phương pháp đệ quy xuất sắc của @ xnor.

05AB1E , 11 byte

Mã số:

DUG2NmX%iNq

Giải trình:

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 byte

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

Đây là đơn giản - 2.^(1:n)%ntìm lũy thừa của 2 trong tập, ∪là union, nhưng đóng vai trò uniquevà chỉ trả lại một trong mỗi sức mạnh duy nhất (và bởi vì nó là một nhà điều hành ghi, tôi có thể kết hợp với 1 đến tiết kiệm một byte so với ∪(2.^(1:n)%n)cách tiếp cận). Sau đó endofđếm số lượng sức mạnh duy nhất, bởi vì một khi nó đạt 1, nó sẽ chỉ lặp lại các sức mạnh hiện có, do đó sẽ có nhiều giá trị duy nhất như sức mạnh tạo ra 1.

Nghiêm túc, 14 byte

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

Bãi rác Hex:

312c3bbb5260d3bd4025604da175

Dùng thử trực tuyến

Giải trình:

 ,;╗           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 byte

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

Đối số trợ giúp tđược nhân đôi modulo nmỗi bước cho đến khi nó bằng 1.

Japt, 17 byte

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

Hãy thử trực tuyến!

Điều này sẽ ngắn hơn ba byte nếu Japt có chức năng "tìm mục đầu tiên phù hợp với điều kiện này". Bắt đầu làm việc trên một

Làm thế nào nó hoạt động

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 byte

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

Julia, 33 26 byte

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

Đây là hàm lambda chấp nhận một số nguyên và trả về một số nguyên. Để gọi nó, gán nó cho một biến.

Chúng ta xây dựng một mảng khi 2 được tăng lên cho mỗi số nguyên từ 1 đến n, sau đó chúng ta tìm thấy chỉ số của 1 đầu tiên trong mảng này.

Đã lưu 7 byte nhờ Glen O!

Perl 5, 29 byte

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

Đầu mũ.

MATL , 13 byte

it:Hw^w\1=f1)

Chạy trên Octave với cam kết GitHub hiện tại của trình biên dịch.

Hoạt động cho đầu vào tối đa 51(do giới hạn của doubleloại dữ liệu).

Thí dụ

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

Giải trình

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

Kỳ lân , 1307 1062 976 byte

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

Tôi đang cố gắng biến kỳ lân thành một ngôn ngữ chơi golf nghiêm túc nhưng điều đó hơi khó ...

Hy vọng rằng tôi sẽ tìm được cách giữ lại "tính kỳ lân" của ngôn ngữ trong khi tạo ra ít byte hơn nhiều

Hình ảnh:

Sử dụng một mã hóa tùy chỉnh .

Câu trả lời này không cạnh tranh vì nó sử dụng phiên bản Unicorn được tạo ra sau ngôn ngữ này

, 11 ký tự / 22 byte

↻2ⁿḁ%ï>1)⧺ḁ

Try it here (Firefox only).

Sử dụng một vòng lặp while. Đây là một trong số ít lần vòng lặp while tốt hơn so với ánh xạ trên một phạm vi.

Giải trình

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

CJam, 15 byte

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

Peter Taylor đã lưu một byte. Khéo léo!

Prolog, 55 byte

Mã số:

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

Giải thích:

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

Thí dụ:

p(195).
12

Dùng thử trực tuyến tại đây