Votre tâche consiste à donner deux nombres entiers aet à bcalculer l'inverse multiplicatif modulaire d'un modulo b, s'il existe.

L'inverse modulaire de amodulo best un nombre ctel que ac ≡ 1 (mod b). Ce numéro est un modulo unique bpour toute paire de aet b. Il n'existe que si le plus grand diviseur commun de aet best 1.

La page Wikipedia pour l'inverse multiplicatif modulaire peut être consultée si vous avez besoin de plus d'informations sur le sujet.

Entrée et sortie

L'entrée est donnée sous la forme de deux entiers ou d'une liste de deux entiers. Votre programme doit produire soit un nombre unique, l'inverse multiplicatif modulaire qui se trouve dans l'intervalle 0 < c < b, soit une valeur indiquant qu'il n'y a pas d'inverse. La valeur peut être n'importe quoi, sauf un nombre dans la plage (0,b), et peut également être une exception. La valeur doit cependant être la même pour les cas où il n'y a pas d'inverse.

0 < a < b peut être supposé

Règles

• Le programme devrait se terminer à un moment donné et devrait résoudre chaque cas de test en moins de 60 secondes
• Des échappatoires standard s'appliquent

Cas de test

Les cas de test ci-dessous sont donnés dans le format, a, b -> output

1, 2 -> 1
3, 6 -> Does not exist
7, 87 -> 25
25, 87 -> 7
2, 91 -> 46
13, 91 -> Does not exist
19, 1212393831 -> 701912218
31, 73714876143 -> 45180085378
3, 73714876143 -> Does not exist

Notation

C'est le golf de code, donc le code le plus court pour chaque langue gagne.

Ceci et ceci sont des questions similaires, mais les deux demandent des situations spécifiques.

Mathematica, 14 octets

Mathematica obligatoire intégré :

ModularInverse

C'est une fonction qui prend deux arguments ( aet b), et retourne l'inverse d'un mod b s'il existe. Sinon, il renvoie l'erreur ModularInverse: a is not invertible modulo b..

JavaScript (ES6), 79 73 62 61 octets

Renvoie falsesi l'inverse n'existe pas.

Il utilise l'algorithme euclidien étendu et résout tous les cas de test presque instantanément.

f=(a,b,c=!(n=b),d=1)=>a?f(b%a,a,d,c-(b-b%a)/a*d):b<2&&(c+n)%n

Cas de test

f=(a,b,c=!(n=b),d=1)=>a?f(b%a,a,d,c-(b-b%a)/a*d):b<2&&(c+n)%n

console.log(f(1, 2)) // -> 1
console.log(f(3, 6)) // -> Does not exist
console.log(f(7, 87)) // -> 25
console.log(f(25, 87)) // -> 7
console.log(f(2, 91)) // -> 46
console.log(f(13, 91)) // -> Does not exist
console.log(f(19, 1212393831)) // -> 701912218
console.log(f(31, 73714876143)) // -> 45180085378
console.log(f(3, 73714876143)) // -> Does not exist

Gelée , 2 octets

æi

Essayez-le en ligne!

Cela utilise une fonction intégrée pour l'inverse modulaire et renvoie 0 pour aucune inverse modulaire.

Gelée , 7 octets

R×%⁸’¬T

Essayez-le en ligne!

Produit un ensemble vide (représenté comme une chaîne vide) sur aucun inverse modulaire. Manque de mémoire sur TIO pour les plus grands cas de test, mais devrait fonctionner avec suffisamment de mémoire.

Comment ça marche

R×%⁸’¬T  
R        Generate range of b
 ×       Multiply each by a
  %⁸     Mod each by b
    ’    Decrement (Map 1 to 0 and all else to truthy)
     ¬   Logical NOT
      T  Get the index of the truthy element.

Si vous souhaitez travailler pour des cas de test plus importants, essayez cette version (relativement non gérée), qui nécessite beaucoup de temps plutôt que de mémoire:

Gelée, 9 octets

×⁴%³’¬ø1#

Essayez-le en ligne!

Comment ça marche

×⁴%³’¬ø1#
        #   Get the first
      ø1      one integer
            which meets:
×⁴            When multiplied by a
  %³          And modulo-d by b
    ’         Decrement
     ¬        Is falsy

Python 2 , 34 octets

f=lambda a,b:a==1or-~b*f(-b%a,a)/a

Essayez-le en ligne!

Fonction récursive qui donne Truepourprint f(1,2) , que je pense être acceptable, et des erreurs pour les entrées invalides.

Nous essayons de trouver $x$ dans $a\cdot x\equiv 1\pmod{b}$ .

Cela peut être écrit comme $a\cdot x-1=k\cdot b$ où $k$ est un entier.

Prise $\mod{a}$ de ceci donne$-1\equiv k\cdot b\pmod{a}$ . Déplacer le moins donne$-k\cdot b\equiv1\pmod{a}$ , où nous devons résoudre pour$k$ .

Voyant comment il ressemble au scénario initial, permettez-nous de recurse pour résoudre pour $k$ en appelant la fonction avec $f(-b\%a,a)$ (fonctionne parce que Python donne des valeurs positives pour modulo avec un argument négatif).

Le programme se répète jusqu'à ce $a$ devienne 1, ce qui ne se produit que si l'original $a$ et $b$ sont premiers entre eux (c'est-à-dire qu'il existe un inverse multiplicatif), ou se termine par une erreur causée par la division par 0.

Cette valeur de $k$ peut être substituée dans l'équation $a\cdot x-1=k\cdot b$ pour donner $x$ comme $\frac{k\cdot b+1}{a}$ .

Numéros R + , 15 octets

numbers::modinv

renvoie NApour ceux asans inverses mod b.

R-Fiddle pour l'essayer!

R , 33 octets (non concurrent)

Cela échouera sur de très gros volumes bcar il crée en fait un vecteur de 32*bbits de taille .

function(a,b)which((1:b*a)%%b==1)

Essayez-le en ligne!

Renvoie integer(0)(une liste vide) pour ceux asans inverses mod b.

Mathematica, 18 octets

PowerMod[#,-1,#2]&

contribution

[31, 73714876143]

Python 2 , 51 49 54 53 51 49 octets

^{-1 octet grâce à officialaimm
-1 octet grâce à Shaggy}

a,b=input()
i=a<2
while(a*i%b-1)*b%a:i+=1
print+i

Essayez-le en ligne!

Imprime 0lorsqu'il n'y a pas de solution.

Japt , 9 8 octets

Prend les entrées dans l'ordre inverse. Sorties -1pour aucune correspondance. Craps lorsque le plus grand entier devient plus grand.

Ç*V%UÃb1

Essaye-le

• 1 octet sauvé grâce à ETH signalant un espace errant et très évident.

Python 3 + gmpy , 23 octets

Je ne pense pas que cela puisse devenir plus court en Python.

gmpy.invert
import gmpy

Essayez-le en ligne! (ne fonctionnera pas si vous n'avez pas installé gmpy)

Python 3 , 49 octets

lambda a,b:[c for c in range(b)if-~c*a%b==1][0]+1

Essayez-le en ligne!

Python 3 , 50 octets

lambda a,b:[c for c in range(1,b+1)if c*a%b==1][0]

Essayez-le en ligne!

Cela jette IndexError: list index out of rangedans le cas où il n'y a pas d'inverse multiplicatif modulaire, comme cela est autorisé par les règles.

8e , 6 octets

Code

invmod

Explication

invmodest un 8ème mot qui calcule la valeur de l'inverse de a, modulo b. Il revient nullen cas de débordement ou d'autres erreurs.

Cas d'utilisation et de test

ok> 1 2 invmod .
1
ok> 3 6 invmod .
null
ok> 7 87 invmod .
25
ok> 25 87 invmod .
7
ok> 2 91 invmod .
46
ok> 13 91 invmod .
null
ok> 19 1212393831 invmod .
701912218
ok> 31 73714876143 invmod .
45180085378
ok> 3 73714876143 invmod .
null

Pari / GP , 22 octets

a->b->lift(1/Mod(a,b))

Lance une erreur lorsqu'il n'y a pas d'inverse.

Essayez-le en ligne!

J , 28 octets

4 :'(1=x+.y)*x y&|@^<:5 p:y'

Essayez-le en ligne!

Utilise le théorème d'Euler . Renvoie 0 si l'inverse n'existe pas.

Explication

4 :'(1=x+.y)*x y&|@^<:5 p:y'  Input: a (LHS), b (RHS)
4 :'                       '  Define an explicit dyad - this is to use the special
                              form `m&|@^` to perform modular exponentiation
                          y   Get b
                      5 p:    Euler totient
                    <:        Decrement
             x                Get a
                   ^          Exponentiate
               y&|@             Modulo b
       x+.y                   GCD of a and b
     1=                       Equals 1
            *                 Multiply

Pyth , 10 octets

3 octets enregistrés grâce à @Jakube .

xm%*szdQQ1

Essayez-le ici!

Résultats -1 pour aucun inverse multiplicatif.

Répartition du code

xm%*szdQQ1      Let Q be the first input.
 m      Q       This maps over [0 ... Q) with a variable d.
   *szd         Now d is multiplied by the evaluated second input.
  %    Q        Now the remained modulo Q is retrieved.
x        1      Then, the first index of 1 is retrieved from that mapping.

Pyth , 15 13 octets

KEhfq1%*QTKSK

Lève une exception dans le cas où aucun inverse multiplicatif n'existe.

Essayez-le ici!

Pyth , 15 octets

Iq1iQKEfq1%*QTK

Cela ajoute beaucoup d'octets pour gérer le cas où un tel nombre n'existe pas. Le programme peut être considérablement raccourci si ce cas n'a pas besoin d'être traité:

fq1%*QTK

Essayez-le ici!

C (gcc) , 115 octets

#define L long long
L g(L a,L b,L c,L d){return a?g(b%a,a,d-b/a*c,c):b-1?0:d;}L f(L a,L b){return(g(a,b,1,0)+b)%b;}

Essayez-le en ligne!

Algorithme euclidien étendu, version récursive

C (gcc) , 119 octets

long long f(a,b,c,d,t,n)long long a,b,c,d,t,n;{for(c=1,d=0,n=b;a;a=t)t=d-b/a*c,d=c,c=t,t=b%a,b=a;return b-1?0:(d+n)%n;}

Essayez-le en ligne!

Algorithme euclidien étendu, version itérative

C (gcc) , 48 110 104 octets

#define f(a,b)g(a,b,!b,1,b)
long g(a,b,c,d,n)long a,b,c,d,n;{a=a?g(b%a,a,d,c-(b-b%a)/a*d):!--b*(c+n)%n;}

Essayez-le en ligne!

Cela devrait fonctionner avec toutes les entrées (qui tiennent dans une longue) dans les 60 secondes.

Modifier. J'abuse déjà de la nvariable, donc je pourrais aussi bien supposer que gcc place la première affectation %rax.

Python 2 + sympy, 74 octets

from sympy import*
def f(a,m):i,_,g=numbers.igcdex(a,m);return g==1and i%m

Essayez-le en ligne!

Tiré du code source de Jelly.

Axiome, 45 octets

f(x:PI,y:PI):NNI==(gcd(x,y)=1=>invmod(x,y);0)

0 pour erreur sinon retourner z avec x * z Mod y = 1

Python 2 , 52 octets

-3 octets grâce à M. Xcoder.

f=lambda a,b,i=1:i*a%b==1and i or i<b and f(a,b,i+1)

Essayez-le en ligne!

Sorties Falsesur aucune solution et erreurs surb volume augmente.

TIO intégré

Je teste simplement les iframes dans les extraits de pile et ils fonctionnent absolument fantastique.

html,body{height:100%;}iframe{height:100%;width:100%;border:none;}

<iframe src="https://tio.run/##PY3BCsIwEETv/Yq5CEndy6ZotbhfIh4SanBB09Lm4tdHU8HTvIHhzfzOjym5UqI8/SuMHp4CqfCgrd8FEfZphGJaoJeAWqLZJnu2Jd/XvEJwNUxwlmA6wrFmTzj1FdzhT4QzV@DuR7emidULTdhMA@ZFU/4@tGrLBw"></iframe>

JavaScript (ES6), 42 41 39 38 octets

Sorties falsepour aucune correspondance. Lance une erreur de débordement lorsque le deuxième nombre devient trop grand.

x=>y=>(g=z=>x*z%y==1?z:z<y&&g(++z))(1)

Gelée , 27 octets

²%³
⁴Ç⁹Сx⁸
ÆṪ’BṚçL$P%³×gỊ¥

Essayez-le en ligne!

Utilise le théorème d'Euler avec une exponentiation modulaire. Étant donné que Jelly n'a pas de fonction intégrée pour effectuer l'exponentiation modulaire, il a dû être implémenté et a pris la plupart des octets.

Axiome, 99 octets

w(a,b,x,u)==(a=0=>(b*b=1=>b*x;0);w(b rem a,a,u,x-u*(b quo a)));h(a,b)==(b=0=>0;(b+w(a,b,0,1))rem b)

il utilise la fonction h (); h (a, b) retourne 0 si erreur [n'existe pas inverse] sinon il retourne le z tel que a * z mod b = 1 Ce serait ok même si les arguments sont négatifs ...

ce serait la fonction générale egcd () qui retournera une liste d'int (donc ils peuvent aussi être négatifs)

egcd(aa:INT,bb:INT):List INT==
   x:=u:=-1   -- because the type is INT
   (a,b,x,u):=(aa,bb,0,1)
   repeat
      a=0=>break
      (q,r):=(b quo a, b rem a)
      (b,a,x,u):=(a,r,u,x-u*q)
   [b,x, (b-x*aa)quo bb]

voici comment l'utiliser

(7) -> h(31,73714876143)
   (7)  45180085378
                                                    Type: PositiveInteger

je trouve l'algo de base dans Internet à partir de https://pastebin.com/A13ybryc