您的任务是给定两个整数，a并b计算模b的模乘法乘法逆（如果存在）。

模的a模逆b是一个c这样的数字ac ≡ 1 (mod b)。b对于任何一对a和，此数字都是唯一的模b。它的存在只有的最大公约数a和b是1。

在维基百科页面的模反元素可以，如果你需要关于主题的更多信息，进行咨询。

输入输出

输入以两个整数或两个整数的列表形式给出。您的程序应输出一个数字，即间隔中的模乘逆0 < c < b，或者一个指示没有逆的值。该值可以是任何值，除了range中的数字之外(0,b)，也可以是一个例外。但是，对于没有倒数的情况，该值应该相同。

0 < a < b 可以假设

规则

• 该程序应在某个时候完成，并应在不到60秒的时间内解决每个测试用例
• 适用标准漏洞

测试用例

以下测试用例以以下格式提供： 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

计分

这是代码高尔夫，因此每种语言的最短代码胜出。

这和这是类似的问题，但是都要求特定的情况。

Mathematica，14个字节

内置 Mathematica必填项：

ModularInverse

这个函数接受两个参数（a和b），如果存在则返回mod b的倒数。如果不是，则返回error ModularInverse: a is not invertible modulo b.。

JavaScript（ES6），79 73 62 61字节

false如果反函数不存在，则返回。

它使用扩展的欧几里得算法，几乎可以立即解决所有测试用例。

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

测试用例

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

果冻，2个字节

æi

在线尝试！

这对模块化逆使用内置函数，对于没有模块化逆则返回0。

果冻，7个字节

R×%⁸’¬T

在线尝试！

在没有模逆的情况下输出空集（表示为空字符串）。对于最大的测试用例，TIO上的内存不足，但是在足够的内存下应该可以工作。

怎么运行的

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.

如果您想使用较大的测试用例，请尝试以下（相对宽松的）版本，该版本需要大量时间而不是内存：

果冻，9个字节

×⁴%³’¬ø1#

在线尝试！

怎么运行的

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

Python 2，34个字节

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

在线尝试！

递归函数，提供Truefor print f(1,2)（我认为可以接受）和无效输入错误。

我们正在努力寻找$x$在$a\cdot x\equiv 1\pmod{b}$。

这可以写成$a\cdot x-1=k\cdot b$其中$k$是整数。

服用 $\mod{a}$的这给出$-1\equiv k\cdot b\pmod{a}$。移动减去给$-k\cdot b\equiv1\pmod{a}$，我们必须求解$k$。

看看它与初始场景的相似之处，让我们通过用f （− b ％a ，a ）调用函数来递归求解$k$。$f(-b\%a,a)$（之所以有效，是因为Python使用负参数为模数提供了正值）。

程序递归直到$a$变为1，这仅在原始$a$和$b$互为质数（即存在一个乘法逆）或以0除以错误而结束时，。

的这个值$k$可以在方程被取代$a\cdot x-1=k\cdot b$，得到$x$为$\frac{k\cdot b+1}{a}$。

R + 数字，15字节

numbers::modinv

返回NA那些a没有逆mod的人b。

R-Fiddle尝试一下！

R，33个字节（非竞争）

这b实际上将失败，因为它实际上会创建一个大小为32*b位的向量。

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

在线尝试！

integer(0)对于a没有逆mod的那些返回（空列表）b。

Mathematica，18个字节

PowerMod[#,-1,#2]&

输入

[31，73714876143]

Python 2中，51个 49 54 53 51 49字节

^{-1字节归功于Officialaimm
-1字节归功于Shaggy}

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

在线尝试！

0没有解决方案时打印。

贾普特（9） 8字节

以相反的顺序输入。输出-1不匹配。随着较大的整数变大而逐渐缩小。

Ç*V%UÃb1

测试一下

• 由于ETH指出了一个错误且非常明显的空间，节省了1个字节。

Python 3 + gmpy，23字节

我认为在Python中它不会变得更短。

gmpy.invert
import gmpy

在线尝试！（如果未安装gmpy，将无法使用）

Python 3，49个字节

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

在线尝试！

Python 3，50个字节

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

在线尝试！

IndexError: list index out of range如果没有规则允许的模数乘法逆，则会抛出此错误。

8th，6字节

码

invmod

说明

invmod是第八个单词，用于计算a模的逆值b。发生null溢出或其他错误时返回。

用法和测试用例

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字节

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

没有逆时抛出错误。

在线尝试！

J，28个字节

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

在线尝试！

使用欧拉定理。如果倒数不存在，则返回0。

说明

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个字节

@Jakube节省了3个字节。

xm%*szdQQ1

在这里尝试！

返回-1无乘法逆。

代码分解

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字节

KEhfq1%*QTKSK

如果不存在乘法逆，则抛出异常。

在这里尝试！

Pyth，15个字节

Iq1iQKEfq1%*QTK

这增加了很多字节来处理不存在此类数字的情况。如果不需要处理该程序，则可以大大缩短该程序：

fq1%*QTK

在这里尝试！

C（gcc），115个字节

#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;}

在线尝试！

扩展的欧几里得算法，递归版本

C（gcc），119字节

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;}

在线尝试！

扩展的欧几里得算法，迭代版

C (gcc), 48 110 104 bytes

#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;}

Try it online!

This should work with all inputs (that fit within a long) within 60 seconds.

Edit. I'm already abusing the n variable so I might as well assume that gcc puts the first assignment in %rax.

Python 2 + sympy, 74 bytes

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

Try it online!

Taken from Jelly source code.

Axiom, 45 bytes

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

0 for error else return z with x*z Mod y =1

Python 2, 52 bytes

-3 bytes thanks to Mr. Xcoder.

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

Try it online!

Outputs False on no solution and errors out as b gets larger.

Embedded TIO

I'm just testing out iframes in Stack Snippets and they work absolutely fantastic.

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 bytes

Outputs false for no match. Will throw a overflow error as the second number gets to be too large.

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

Jelly, 27 bytes

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

Try it online!

Uses Euler's theorem with modular exponentiation. Since Jelly doesn't have a builtin to perform modular exponentiation, it had to be implemented, and it took most of the bytes.

Axiom, 99 bytes

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)

it use the function h(); h(a,b) return 0 if error [not exist inverse] otherwise it return the z such that a*z mod b = 1 This would be ok even if arguments are negative...

this would be the general egcd() function that retunr a list of int (so they can be negative too)

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]

this is how use it

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

i find the base algo in internet from https://pastebin.com/A13ybryc