В моей комнате у меня есть эти вызывающие часы (нажмите для увеличения):

Большинство из них не сложно понять, но тот, что для 4-х часов, особенно сложен:

Как правило, дробь наподобие 1/2 не имеет смысла в модульной арифметике, поскольку участвуют только целые числа. Правильный способ, таким образом, состоит в том, чтобы рассматривать это как обратное к 2 или, иначе говоря, это то число где . Проще говоря, минутная мысль покажет это, потому что .

Тем не менее, просто найти мультипликативное обратное было бы слишком просто в качестве проблемы. Итак, давайте поднимем сложность до возведения в степень, или, другими словами, найдем модульный логарифм или дискретный логарифм числа 2. В этом случае 3 - это модульный логарифм числа 2 относительно 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

Тестовый пакет .

fизменяет значение по умолчанию, равное 1, до тех пор, пока не найдет некоторый x такой, что модульное возведение в степень с 2 и входное значение равно 1.

Python, 32 байта

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

Начиная с 2, удваивается по модулю n до результата 1, рекурсивно увеличивается каждый раз и заканчивается счетом 1 для начального значения 2.

Mathematica, 24 байта

2~MultiplicativeOrder~#&

Я просто использовал встроенный для этого.

APL, 8 байт

1⍳⍨⊢|2*⍳

Это последовательность монадических функций, которая принимает целое число справа и возвращает целое число. Чтобы вызвать его, назначьте его переменной.

Пояснение (вызов ввода 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

Юлия, 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))

Юлия, 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).

Использует цикл while. Это один из немногих случаев, когда цикл while лучше, чем отображение диапазона.

объяснение

          // 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#)

Питер Тейлор сохранил байт. Ухоженная!

Пролог, 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

Попробуйте онлайн здесь