No meu quarto, tenho este relógio nerd (clique para ver o tamanho completo):

A maioria delas não é difícil de entender, mas a de quatro horas é particularmente complicada:

Normalmente, uma fração como 1/2 não faz sentido na aritmética modular, pois apenas números inteiros estão envolvidos. A maneira correta, então, é ver isso como o inverso de 2, ou, em outras palavras, é esse número em que . Posto assim, um momento de reflexão revelará isso porque .

No entanto, simplesmente encontrar o inverso multiplicativo seria muito fácil como um desafio. Então, vamos aumentar a dificuldade de exponenciação, ou seja, encontrar o logaritmo modular ou logaritmo discreto de 2. Nesse caso, 3 é o logaritmo modular de 2 em relação a 7. Para aqueles com teoria dos números / álgebra abstrata fundo, isso significa calcular a ordem multiplicativa de 2 módulo n.

O desafio

Dado um número inteiro ímpar positivo nmaior que 1, imprima o menor número inteiro positivo em xque .

Exemplos

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 

Gelatina , 6 bytes

R2*%i1

Experimente online!

Como funciona

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.

Pitão - 9 8 bytes

f!t.^2TQ

Conjunto de Teste .

filters do padrão 1 até encontrar algum x tal que a exponenciação modular com 2 e a entrada seja igual a 1.

Python, 32 bytes

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

Começando com 2, dobra o módulo n até o resultado ser 1, incrementando recursivamente a cada vez e terminando com uma contagem de 1 para o valor inicial de 2.

Mathematica, 24 bytes

2~MultiplicativeOrder~#&

Eu apenas usei um built-in para isso.

APL, 8 bytes

1⍳⍨⊢|2*⍳

Este é um trem de função monádica que aceita um número inteiro à direita e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável.

Explicação (chamando a entrada 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

Observe que o resultado pode estar incorreto para entradas grandes, pois o exponencial é arredondado.

Pitão, 14 bytes

VQIq%^2hNQ1hNB

Explicação:

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

Experimente aqui

JavaScript (ES6), 28 bytes

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

Baseado na brilhante abordagem recursiva do @ xnor.

05AB1E , 11 bytes

Código:

DUG2NmX%iNq

Explicação:

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 bytes

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

Isso é simples - 2.^(1:n)%nencontra os poderes de 2 dentro do conjunto, ∪é union, mas serve como uniquee retorna apenas um de cada poder exclusivo (e por ser um operador de infixo, posso unir-me a 1 para economizar um byte na ∪(2.^(1:n)%n)abordagem). Em seguida, endofconta o número de poderes únicos, porque uma vez que atinge 1, ele apenas repete os poderes existentes, para que haja tantos valores únicos quanto o poder que produz 1.

Sério, 14 bytes

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

Hex Dump:

312c3bbb5260d3bd4025604da175

Experimente Online

Explicação:

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

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

O argumento auxiliar té duplicado no módulo a ncada passo até que seja igual a 1.

Japonês, 17 bytes

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

Experimente online!

Isso seria três bytes mais curto se Japt tivesse uma função "encontre o primeiro item que corresponde a essa condição". Começa a trabalhar em um

Como funciona

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 bytes

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

Julia, 33 26 bytes

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

Esta é uma função lambda que aceita um número inteiro e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável.

Construímos uma matriz como 2 elevada a cada potência inteira de 1 a n, e então encontramos o índice do primeiro 1 nessa matriz.

Economizou 7 bytes graças a Glen O!

Perl 5, 29 bytes

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

Ponta do chapéu.

MATL , 13 bytes

it:Hw^w\1=f1)

Executa no Octave com o commit atual do GitHub do compilador.

Funciona para entrada até 51(devido a limitações do doubletipo de dados).

Exemplo

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

Explicação

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

Unicórnio , 1307 1062 976 bytes

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

Estou tentando fazer do unicórnio uma linguagem séria para o golfe, mas isso é um pouco difícil ...

Espero encontrar uma maneira de reter o "unicórnio-ness" da linguagem e gerar muito menos bytes

Cenário:

Usa um costume codificação .

Esta resposta não é concorrente porque usa uma versão do Unicorn feita após esse idioma

11, 11 caracteres / 22 bytes

↻2ⁿḁ%ï>1)⧺ḁ

Try it here (Firefox only).

Usa um loop while. Essa é uma das poucas vezes em que o loop while é melhor do que o mapeamento em um intervalo.

Explicação

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

CJam, 15 bytes

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

Peter Taylor salvou um byte. Arrumado!

Prolog, 55 bytes

Código:

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

Explicado:

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

Exemplo:

p(195).
12

Experimente online aqui