La tâche est la suivante. Étant donné un entier x(tel que xmodulo 100000000003n'est pas égal à 0) présenté à votre code de la manière qui vous convient, sortez un autre entier y < 100000000003pour que (x * y) mod 100000000003 = 1.

Votre code doit prendre moins de 30 minutes pour s'exécuter sur une machine de bureau standard pour toute entrée de ce xtype |x| < 2^40.

Cas de test

Entrée: 400000001. Sortie: 65991902837

Entrée: 4000000001. Sortie: 68181818185

Entrée: 2. Sortie: 50000000002

Entrée: 50000000002. Sortie: 2.

Entrée: 1000000. Sortie: 33333300001

Restrictions

Vous ne pouvez pas utiliser de bibliothèques ou de fonctions intégrées qui effectuent l'arithmétique modulo (ou cette opération inverse). Cela signifie que vous ne pouvez même pas vous a % bpasser de %votre propre implémentation . Vous pouvez cependant utiliser toutes les autres fonctions intégrées arithmétiques non modulo.

Question similaire

Ceci est similaire à cette question, même si nous l'espérons suffisamment différent pour être toujours intéressant.

Pyth, 24 octets

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

Suite de tests

Ceci utilise le fait qu'un ^ (p-2) mod p = un ^ -1 mod p.

Tout d'abord, je réimplémente manuellement le module, pour le cas spécifique du mod 100000000003. J'utilise la formule a mod b = a - (a/b)*b, où /est la division au sol. Je génère le module avec 10^11 + 3, en utilisant le code +3^T11, puis l'enregistre J, puis utilise ceci et la formule ci-dessus pour calculer b mod 100000000003 avec -b*/bJ+3^T11J. Cette fonction est définie comme yavec L.

Ensuite, je commence par l'entrée, puis je la porte à la dixième puissance et je réduis le mod 100000000003, et je répète cela 11 fois. y^GTest le code exécuté à chaque étape, et l' uy^GT11Qexécute 11 fois en commençant par l'entrée.

Maintenant, j'ai Q^(10^11) mod 10^11 + 3, et je veux Q^(10^11 + 1) mod 10^11 + 3, donc je multiplie par l'entrée avec *, le réduit mod 100000000003 yune dernière fois, et la sortie.

Haskell , 118 113 105 101 octets

Inspiré de cette solution .

-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]

Essayez-le en ligne!

Haskell , 48 octets

Une réécriture de cette solution . Bien que suffisamment rapide pour le vecteur de test, cette solution est trop lente pour les autres entrées.

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

Essayez-le en ligne!

Brachylog , 22 octets

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

Essayez-le en ligne!

Cela a pris environ 10 minutes 1000000avec une version légèrement différente (et plus longue) du code qui était exactement deux fois plus rapide (vérifié uniquement les valeurs positives İau lieu de positives et négatives). Par conséquent, cette opération devrait prendre environ 20 minutes.

Explication

Nous décrivons simplement cela Input × Output - 1 = 100000000003 × an integeret laissons l'arithmétique des contraintes Outputnous trouver .

∧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

Techniquement, nous n'avons pas besoin de l'étiquetage explicite ≜, mais si nous ne l'utilisons pas, ~×nous ne vérifierons pas le cas N = [100000000003,1](car il est souvent inutile), ce qui signifie que cela sera très lent pour la saisie 2par exemple car il devra trouver le deuxième plus petit entier au lieu du premier.

Python, 53 51 49 58 53 49 octets

-2 octets grâce à orlp
-2 octets grâce à officialaimm
-4 octets grâce à Felipe Nardi Batist
-3 octets grâce à isaacg
-1 octet grâce à Ørjan Johansen
-2 octets grâce à Federico Poloni

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

Essayez-le en ligne!

Il m'a fallu environ 30 minutes pour comprendre celui-ci. Ma solution est de commencer par le premier nombre qui passera à 1. Ce nombre est 1. Si son divisible par x, alors y est ce nombre divisé par x. Sinon, ajoutez 10000000003 à ce nombre pour trouver le deuxième nombre dont le mod 1000000003 sera égal à 1 et répétez.

JavaScript (ES6), 153 143 141 octets

Inspiré par cette réponse de math.stackexchange.com .

Une fonction récursive basée sur l'algorithme euclidien.

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)

Modulo est implémenté en calculant:

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

Parce que le quotient est également nécessaire, le faire de cette façon est en fait logique.

Cas de test

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 octets

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

Non golfé, basé sur le théorème d'Euler et l'exponentation binaire.

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 octets

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

PHP, 71 octets

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

Cas de test

Rubis , 58 octets

Utilise l'application isaacg du petit théorème de Fermat pour l'instant pendant que je termine le chronométrage de la solution de force brute.

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

Version actuelle force brute, qui est de 47 octets , mais peut - être est trop lent:

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

Essayez-le en ligne!