A tarefa é a seguinte. Dado um número inteiro x(de modo que o xmódulo 100000000003não seja igual a 0) apresentado ao seu código da maneira que achar conveniente, imprima outro número inteiro y < 100000000003para que (x * y) mod 100000000003 = 1.

Seu código deve levar menos de 30 minutos para ser executado em uma máquina desktop padrão para qualquer entrada xcomo essa |x| < 2^40.

Casos de teste

Entrada: 400000001. Saída: 65991902837

Entrada: 4000000001. Saída: 68181818185

Entrada: 2. Saída: 50000000002

Entrada: 50000000002. Saída: 2.

Entrada: 1000000. Saída: 33333300001

Restrições

Você não pode usar nenhuma biblioteca ou função interna que execute módulo aritmético (ou esta operação inversa). Isso significa que você não pode nem ficar a % bsem %se implementar . No entanto, você pode usar todas as outras funções internas aritméticas não modulares.

Pergunta semelhante

Isso é semelhante a essa pergunta, embora seja esperançosamente diferente o suficiente para ainda ser interessante.

Pitão, 24 bytes

L-b*/bJ+3^T11Jy*uy^GT11Q

Suíte de teste

Isso usa o fato de que um ^ (p-2) mod p = a ^ -1 mod p.

Primeiro, reimplemento manualmente o módulo, para o caso específico do mod 100000000003. Uso a fórmula a mod b = a - (a/b)*b, onde /é a divisão com piso. Gero o módulo com 10^11 + 3, usando o código +3^T11, em seguida salve-o e J, em seguida, use esta e a fórmula acima para calcular b mod 100000000003 com -b*/bJ+3^T11J. Esta função é definida como ycom L.

Em seguida, começo com a entrada, depois a levo para a décima potência e reduzo o mod 100000000003 e repito isso 11 vezes. y^GTé o código executado em cada etapa e o uy^GT11Qexecuta 11 vezes, iniciando com a entrada.

Agora eu tenho Q^(10^11) mod 10^11 + 3, e quero Q^(10^11 + 1) mod 10^11 + 3, então multiplico pela entrada com *, reduzo-o mod 100000000003 com yuma última vez e com saída.

Haskell , 118 113 105 101 bytes

Inspirado nesta solução .

-12 de Ørjan Johansen

p=10^11+3
k b=((p-2)?b)b 1
r x=x-div x p*p
(e?b)s a|e==0=a|1<2=(div e 2?b$r$s*s)$last$a:[r$a*s|odd e]

Experimente online!

Haskell , 48 bytes

Uma reescrita desta solução . Embora rápida o suficiente para o vetor de teste, esta solução é muito lenta para outras entradas.

s x=until(\t->t-t`div`x*x==0)(+(10^11+3))1`div`x

Experimente online!

Braquilog , 22 bytes

∧10^₁₁+₃;İ≜N&;.×-₁~×N∧

Experimente online!

Isso levou cerca de 10 minutos para 1000000uma versão ligeiramente diferente (e mais longa) do código, que era exatamente duas vezes mais rápida (verificou apenas valores positivos em İvez de positivos e negativos). Portanto, isso deve levar cerca de 20 minutos para concluir essa entrada.

Explicação

Simplesmente descrevemos isso Input × Output - 1 = 100000000003 × an integere deixamos que a aritmética da restrição encontre Outputpor nós.

∧10^₁₁+₃                   100000000003
        ;İ≜N               N = [100000000003, an integer (0, then 1, then -1, then 2, etc.)]
            &;.×           Input × Output…
                -₁         … - 1…
                  ~×N∧     … = the product of the elements of N

Tecnicamente, não precisamos da rotulagem explícita ≜; no entanto, se não a usarmos, ~×não verificaremos o caso N = [100000000003,1](porque geralmente é inútil), o que significa que isso será muito lento para a entrada, 2por exemplo, porque será necessário encontrar o segundo menor inteiro em vez do primeiro.

Python, 53 51 49 58 53 49 bytes

-2 bytes graças a orlp
-2 bytes graças a officialaimm
-4 bytes graças a Felipe Nardi Batist
-3 bytes graças a isaacg
-1 byte graças a Ørjan Johansen
-2 bytes graças a Federico Poloni

x=input()
t=1
while t-t/x*x:t+=3+10**11
print t/x

Experimente Online!

Levei ~ 30 minutos para descobrir isso. Minha solução é começar com o primeiro número que será modificado para 1. Esse número é 1. Se é divisível por x, então y é esse número dividido por x. Caso contrário, adicione 10000000003 a este número para encontrar o segundo número que mod 1000000003 será igual a 1 e repita.

JavaScript (ES6), 153 143 141 bytes

Inspirado por esta resposta de math.stackexchange.com .

Uma função recursiva baseada no algoritmo euclidiano.

f=(n,d=(F=Math.floor,m=1e11+3,a=1,c=n,b=F(m/n),k=m-b*n,n>1))=>k>1&d?(e=F(c/k),a+=e*b,c-=e*k,f(n,c>1&&(e=F(k/c),k-=e*c,b+=e*a,1))):a+d*(m-a-b)

O módulo é implementado pela computação:

quotient = Math.floor(a / b);
remainder = a - b * quotient;

Como o quociente também é necessário, fazê-lo dessa maneira realmente faz algum sentido.

Casos de teste

let f =

f=(n,d=(F=Math.floor,m=1e11+3,a=1,c=n,b=F(m/n),k=m-b*n,n>1))=>k>1&d?(e=F(c/k),a+=e*b,c-=e*k,f(n,c>1&&(e=F(k/c),k-=e*c,b+=e*a,1))):a+d*(m-a-b)

console.log(f(2))
console.log(f(50000000002))
console.log(f(1000000))

C ++ 11 (GCC / Clang, Linux), 104 102 bytes

using T=__int128_t;T m=1e11+3;T f(T a,T r=1,T n=m-2){return n?f(a*a-a*a/m*m,n&1?r*a-r*a/m*m:r,n/2):r;}

https://ideone.com/gp41rW

Ungolfed, baseado no teorema de Euler e na exponenciação binária.

using T=__int128_t;
T m=1e11+3;
T f(T a,T r=1,T n=m-2){
    if(n){
        if(n & 1){
            return f(a * a - a * a / m * m, r * a - r * a / m * m, n / 2);
        }
        return f(a * a - a * a / m * m, r, n / 2);
    }
    return r;
}

Mathematica, 49 bytes

x/.FindInstance[x#==k(10^11+3)+1,{x,k},Integers]&

PHP, 71 bytes

for(;($r=bcdiv(bcadd(bcmul(++$i,1e11+3),1),$argn,9))!=$o=$r^0;);echo$o;

Casos de teste

Ruby , 58 bytes

Utiliza a aplicação de isaacg do pequeno teorema de Fermat por enquanto, enquanto termino de cronometrar a solução de força bruta.

->n,x=10**11+3{i=n;11.times{i**=10;i-=i/x*x};i*=n;i-i/x*x}

Versão atual força bruta, que é de 47 bytes, mas pode ser é muito lento:

->n,x=10**11+3{(1..x).find{|i|i*=n;i-i/x*x==1}}

Experimente online!