您的任务是在尽可能少的代码字节中计算两个给定整数的最大公约数（GCD）。

您可以编写程序或函数，通过我们接受的任何标准方法（包括STDIN / STDOUT，函数参数/返回值，命令行参数等）获取输入并返回输出。

输入将是两个非负整数。您应该能够处理语言的默认整数类型支持的完整范围，也可以处理range [0,255]，以较大者为准。您可以确保至少有一个输入为非零。

不允许使用用于计算GCD或LCM（最小公倍数）的内置函数。

适用标准代码高尔夫球规则。

测试用例

0 2     => 2
6 0     => 6
30 42   => 6
15 14   => 1
7 7     => 7
69 25   => 1
21 12   => 3
169 123 => 1
20 142  => 2
101 202 => 101

视网膜 16

^(.+)\1* \1+$
$1

这根本不使用Euclid的算法-而是使用正则表达式匹配组找到GCD。

在线尝试。-此示例计算GCD（8,12）。

输入为2个以空格分隔的整数。请注意，I / O是一元的。如果那是不可接受的，那么我们可以这样做：

视网膜30

\d+
$*
^(.+)\1* \1+$
$1
1+
$.&

在线尝试。

正如@MartinBüttner指出的那样，对于大量数字来说这是分崩离析的（通常一元的情况就是这样）。至少，输入INT_MAX将需要分配2GB字符串。

i386（x86-32）机器代码，8个字节（9B为无符号）

如果我们需要处理b = 0输入，则+ 1B 。

amd64（x86-64）机器码，9个字节（无符号为10B，有符号或无符号的64b整数为14B 13B）

amd64上的无符号的10 9B随任一输入= 0中断

输入是32位非零签署的整数eax和ecx。在中输出eax。

## 32bit code, signed integers:  eax, ecx
08048420 <gcd0>:
 8048420:       99                      cdq               ; shorter than xor edx,edx
 8048421:       f7 f9                   idiv   ecx
 8048423:       92                      xchg   edx,eax    ; there's a one-byte encoding for xchg eax,r32.  So this is shorter but slower than a mov
 8048424:       91                      xchg   ecx,eax    ; eax = divisor(from ecx), ecx = remainder(from edx), edx = quotient(from eax) which we discard
    ; loop entry point if we need to handle ecx = 0
 8048425:       41                      inc    ecx        ; saves 1B vs. test/jnz in 32bit mode
 8048426:       e2 f8                   loop   8048420 <gcd0>
08048428 <gcd0_end>:
 ; 8B total
 ; result in eax: gcd(a,0) = a

此循环结构使测试用例where失败ecx = 0。（div导致#DE硬件执行除以零的操作。（在Linux上，内核提供了SIGFPE（浮点异常）。）如果循环入口位于之前inc，则可以避免该问题。x86-64版本可以处理该问题。免费，请参见下文。

Mike Shlanta的回答是此出发点。我的循环与他的循环执行相同的操作，但是对于有符号整数，因为cdq比短一字节xor edx,edx。是的，在一个或两个输入为负的情况下，它确实可以正常工作。Mike的版本运行速度更快，并且在uop缓存中占用的空间更少（xchg在Intel CPU上为3 uops，loop在大多数CPU上确实很慢），但是此版本以机器代码的大小为准。

起初我没有注意到该问题需要未签名的 32位。返回xor edx,edx而不是cdq将花费一个字节。 div与大小相同idiv，其他所有内容都可以保持不变（xchg用于数据移动并inc/loop仍然可以使用。）

有趣的是，对于64位操作数大小（rax和rcx），有符号和无符号版本的大小相同。签名版本需要cqo（2B）的REX前缀，但未签名版本仍可以使用2B xor edx,edx。

在64位代码中inc ecx为2B：单字节inc r32和dec r32操作码被重新用作REX前缀。 inc/loop不会在64位模式下保存任何代码大小，因此您也可以这样做test/jnz。对64位整数进行操作会在REX前缀中为每条指令再加上一个字节（loop或除外）jnz。其余的全零可能在低32b中（例如gcd((2^32), (2^32 + 1))），因此我们需要测试整个rcx，并且不能使用保存字节test ecx,ecx。但是，较慢的jrcxzinsn仅为2B，我们可以将其放在循环的顶部以ecx=0在输入时进行处理：

## 64bit code, unsigned 64 integers:  rax, rcx
0000000000400630 <gcd_u64>:
  400630:       e3 0b                   jrcxz  40063d <gcd_u64_end>   ; handles rcx=0 on input, and smaller than test rcx,rcx/jnz
  400632:       31 d2                   xor    edx,edx                ; same length as cqo
  400634:       48 f7 f1                div    rcx                      ; REX prefixes needed on three insns
  400637:       48 92                   xchg   rdx,rax
  400639:       48 91                   xchg   rcx,rax
  40063b:       eb f3                   jmp    400630 <gcd_u64>
000000000040063d <gcd_u64_end>:
## 0xD = 13 bytes of code
## result in rax: gcd(a,0) = a

完整的可运行测试程序，包括一个可在Godbolt Compiler Explorer上main运行32和64b版本的printf("...", gcd(atoi(argv[1]), atoi(argv[2])) ); 源代码和asm输出的程序。经过测试，可以在32位（-m32），64位（-m64）和x32 ABI（-mx32）上使用。

还包括：仅使用重复减法的版本，对于无符号，甚至对于x86-64模式，其值为9B，并且可以将其输入之一输入任意寄存器中。但是，它不能处理任何一个输入都为0的条目（它检测何时sub生成零，而x-0则永远不会）。

适用于32位版本的GNU C内联asm源（使用编译gcc -m32 -masm=intel）

int gcd(int a, int b) {
    asm (// ".intel_syntax noprefix\n"
        // "jmp  .Lentry%=\n" // Uncomment to handle div-by-zero, by entering the loop in the middle.  Better: `jecxz / jmp` loop structure like the 64b version
        ".p2align 4\n"                  // align to make size-counting easier
         "gcd0:   cdq\n\t"              // sign extend eax into edx:eax.  One byte shorter than xor edx,edx
         "        idiv    ecx\n"
         "        xchg    eax, edx\n"   // there's a one-byte encoding for xchg eax,r32.  So this is shorter but slower than a mov
         "        xchg    eax, ecx\n"   // eax = divisor(ecx), ecx = remainder(edx), edx = garbage that we will clear later
         ".Lentry%=:\n"
         "        inc     ecx\n"        // saves 1B vs. test/jnz in 32bit mode, none in 64b mode
         "        loop    gcd0\n"
        "gcd0_end:\n"
         : /* outputs */  "+a" (a), "+c"(b)
         : /* inputs */   // given as read-write outputs
         : /* clobbers */ "edx"
        );
    return a;
}

通常，我会在asm中编写一个完整的函数，但是GNU C内联asm似乎是包括一个片段的最佳方法，该片段可以在我们选择的任何reg中具有in / outputs。如您所见，GNU C内联asm语法使汇编变得丑陋且嘈杂。这也是学习 asm的一种非常困难的方法。

实际上，它将编译并在.att_syntax noprefix模式下工作，因为使用的所有insn均为单/无操作数或xchg。并不是真正有用的观察。

六边形，17字节

?'?>}!@<\=%)>{\.(

展开：

  ? ' ?
 > } ! @
< \ = % )
 > { \ .
  ( . .

在线尝试！

将其安装到侧面长度3上很容易。在末尾删除这两个字节并不是……我也不相信它是最佳的，但是我敢肯定我认为它已经接近了。

说明

另一个欧几里得算法实现。

该程序使用三个内存边缘，分别称为A，B和C，其内存指针（MP）如下所示：

这是控制流程图：

控制流从灰色路径开始，带有短的线性输入位：

?    Read first integer into memory edge A.
'    Move MP backwards onto edge B.
?    Read second integer into B.

请注意，现在代码将边缘环绕到<左角的。这<充当分支。如果当前边为零（即，欧几里得算法终止），则IP向左偏转并采用红色路径。否则，在绿色路径上计算欧几里得算法的迭代。

我们首先考虑绿色道路。请注意，>和\都充当简单地偏转指令指针的镜像。还要注意，控制流围绕边缘缠绕了三遍，一次是从底部到顶部，一次是从右角到底部，最后是从右下角到左侧，以重新检查条件。另请注意，这.是禁止操作。

剩下的线性代码可以进行一次迭代：

{    Move MP forward onto edge C.
'}   Move to A and back to C. Taken together this is a no-op.
=    Reverse the direction of the MP so that it now points at A and B. 
%    Compute A % B and store it in C.
)(   Increment, decrement. Taken together this is a no-op, but it's
     necessary to ensure that IP wraps to the bottom row instead of
     the top row.

现在我们回到我们开始的地方，除了三条边都循环地改变自己的角色（原ç现在采取的作用，乙和原乙的角色一个 ......）。实际上，我们分别将输入A和B与B和关联A % B。

一旦A % B（在边C上）为零，就可以在边B上找到GCD 。同样，>Just偏向IP，因此在红色路径上执行：

}    Move MP to edge B.
!    Print its value as an integer.
@    Terminate the program.

32位Little-endian x86机器码，14字节

使用产生 nasm -f bin

d231 f3f7 d889 d389 db85 f475

    gcd0:   xor     edx,edx
            div     ebx
            mov     eax,ebx
            mov     ebx,edx
            test    ebx,ebx
            jnz     gcd0

T-SQL，153169字节

有人提到打高尔夫球最糟糕的语言吗？

CREATE FUNCTION G(@ INT,@B INT)RETURNS TABLE RETURN WITH R AS(SELECT 1D,0R UNION ALL SELECT D+1,@%(D+1)+@B%(D+1)FROM R WHERE D<@ and D<@b)SELECT MAX(D)D FROM R WHERE 0=R

创建一个表值函数，该函数使用递归查询来计算公共除数。然后返回最大值。现在使用欧几里德算法来确定从我的回答得到的GCD 这里。

用法示例

SELECT * 
FROM (VALUES
        (15,45),
        (45,15),
        (99,7),
        (4,38)
    ) TestSet(A, B)
    CROSS APPLY (SELECT * FROM G(A,B))GCD

A           B           D
----------- ----------- -----------
15          45          15
45          15          15
99          7           1
4           38          2

(4 row(s) affected)

果冻，7个字节

ṛß%ðḷṛ?

欧几里得算法的递归实现。在线尝试！

如果不禁止使用g内置（1字节，内置GCD），则得分会更高。

这个怎么运作

ṛß%ðḷṛ?  Main link. Arguments: a, b

   ð     Convert the chain to the left into a link; start a new, dyadic chain.
 ß       Recursively call the main link...
ṛ %        with b and a % b as arguments.
     ṛ?  If the right argument (b) is non-zero, execute the link.
    ḷ    Else, yield the left argument (a).

Haskell，19个字节

a#0=a
a#b=b#rem a b

用法示例：45 # 35-> 5。

再次，欧几里得。

PS：当然也有内置的gcd。

Python 3、31

Sp3000节省了3个字节。

g=lambda a,b:b and g(b,a%b)or a

MATL，11 9字节

到目前为止，似乎没有人使用过蛮力，所以就在这里。

ts:\a~f0)

输入是具有两个数字的列数组（;用作分隔符）。

在线尝试！或验证所有测试用例。

说明

t     % Take input [a;b] implicitly. Duplicate
s     % Sum. Gives a+b
:     % Array [1,2,...,a+b]
\     % Modulo operation with broadcast. Gives a 2×(a+b) array
a~    % 1×(a+b) array that contains true if the two modulo operations gave 0
f0)   % Index of last true value. Implicitly display

C，38个字节

g(x,y){while(x^=y^=x^=y%=x);return y;}

C，28个字节

一个非常简单的函数，用于实现Euclid算法。使用另一种算法，可能会变得更短。

g(a,b){return b?g(b,a%b):a;}

如果有人写一点主包装

int main(int argc, char **argv)
{
  printf("gcd(%d, %d) = %d\n", atoi(argv[1]), atoi(argv[2]), g(atoi(argv[1]), atoi(argv[2])));
}

然后可以测试一些值：

$ ./gcd 6 21
gcd（6，21）= 3
$ ./gcd 21 6
gcd（21，6）= 3
$ ./gcd 6 8
gcd（6，8）= 2
$ ./gcd 1 1
gcd（1，1）= 1
$ ./gcd 6 16
gcd（6，16）= 2
$ ./gcd 27244
gcd（27，244）= 1

迷宫，18字节

?}
:
)"%{!
( =
}:{

因错误终止，但错误消息发至STDERR。

在线尝试！

感觉还不是很理想，但是我现在还没有一种将循环压缩到3x3以下的方法。

说明

这使用欧几里得算法。

首先，有一个线性位可以读取输入并进入主循环。指令指针（IP）从左上角开始向东。

?    Read first integer from STDIN and push onto main stack.
}    Move the integer over to the auxiliary stack.
     The IP now hits a dead end so it turns around.
?    Read the second integer.
     The IP hits a corner and follows the bend, so it goes south.
:    Duplicate the second integer.
)    Increment.
     The IP is now at a junction. The top of the stack is guaranteed to be
     positive, so the IP turns left, to go east.
"    No-op.
%    Modulo. Since `n % (n+1) == n`, we end up with the second input on the stack.

现在我们进入一种while循环，该循环计算欧几里得算法。堆栈的顶部包含a和b（在隐式无限数量的零之上，但我们不需要这些）。我们将以并排的方式来表示堆栈，它们彼此相距越来越近：

    Main     Auxiliary
[ ... 0 a  |  b 0 ... ]

循环终止a为零。循环迭代的工作方式如下：

=    Swap a and b.           [ ... 0 b  |  a 0 ... ]
{    Pull a from aux.        [ ... 0 b a  |  0 ... ]
:    Duplicate.              [ ... 0 b a a  |  0 ... ]
}    Move a to aux.          [ ... 0 b a  |  a 0 ... ]
()   Increment, decrement, together a no-op.
%    Modulo.                 [ ... 0 (b%a)  |  a 0 ... ]

你可以看到，我们把它换成a和b与b%a和a分别。

最后，一旦b%a为零，则IP继续向东移动并执行：

{    Pull the non-zero value, i.e. the GCD, over from aux.
!    Print it.
     The IP hits a dead end and turns around.
{    Pull a zero from aux.
%    Attempt modulo. This fails due to division by 0 and the program terminates.

朱莉娅21 15字节

a\b=a>0?b%a\a:b

欧几里得算法的递归实现。在线尝试！

如果不禁止使用内置文件，则gcd（3字节，内置GCD）将获得更好的分数。

这个怎么运作

a\b=             Redefine the binary operator \ as follows:
    a>0?     :       If a > 0:
        b%a\a        Resursively apply \ to b%a and a. Return the result.
              b      Else, return b.

Cubix，10 12字节

?v%uII/;O@

在这里尝试

这将包装到多维数据集，如下所示：

    ? v
    % u
I I / ; O @ . .
. . . . . . . .
    . .
    . .

使用欧几里得方法。

II两个数字是从标准输入抓起，把堆栈
/流量向上反射
%堆栈的国防部顶部。保留在堆栈顶部的顶部
?如果TOS为0，则继续操作；否则，向右旋转；
v如果不为0，则向下重定向，u然后向右转两次，回到mod上。
/如果0，则围绕立方体到反射器
;下落TOS，O输出TOS并@结束

C＃，24个字节

x=(a,b)=>b<1?a:x(b,a%b);

Windows Batch，76个字节

递归函数。像GCD a b文件名一样调用它gcd。

:g
if %2 equ 0 (set f=%1
goto d)
set/a r=%1 %% %2
call :g %2 %r%
:d
echo %f%

MATL，7个字节

pG1$Zm/

在线尝试！

说明

既然我们不能明确地使用内置GCD功能（Zd在MATL），我已经利用这一事实的最小公倍数a和b时间的最大公约数a和b相等的产品a和b。

p       % Grab the input implicitly and multiply the two elements
G       % Grab the input again, explicitly this time
1$Zm    % Compute the least-common multiple
/       % Divide the two to get the greatest common denominator

球拍（方案），44字节

在球拍中执行Euclid（方案）

(define(g a b)(if(= 0 b)a(g b(modulo a b))))

编辑：没有看到@Numeri的解决方案。不知何故，我们独立地获得了完全相同的代码

> <>，32字节

::{::}@(?\=?v{:}-
.!09}}${{/;n/>

从堆栈中接受两个值，并应用欧几里得算法生成其GCD。

您可以在这里尝试！

有关> <>中更好的答案，请查看Sok的！

ReRegex，23个字节

与视网膜答案相同。

^(_*)\1* \1*$/$1/#input

在线尝试！

GML，57个字节

a=argument0
b=argument1
while b{t=b;b=a mod b;a=t}return a

德尔斐7，148

好吧，我想我已经找到了新的最差的高尔夫语言。

unit a;interface function g(a,b:integer):integer;implementation function g(a,b:integer):integer;begin if b=0then g:=a else g:=g(b,a mod b);end;end.

Hoon，20个字节

|=
{@ @}
d:(egcd +<)

-

Hoon＃2，39个字节

|=
{a/@ b/@}
?~
b
a
$(a b, b (mod a b))

奇怪的是，Hoon的stdlib中唯一用于GCD的实现是其RSA加密使用的实现，它还返回了一些其他值。我必须将其包装在仅从d输出中获取的函数中。

另一个实现只是默认的递归GCD定义。

蟒3.5，70个 82 73字节：

lambda*a:max([i for i in range(1,max(*a)+1)if not sum(g%i for g in[*a])])

该not在这种情况下，将确保总和所有的数字*args模数i是零。

而且，现在该lambda函数可以接受任意数量的值>=2，只要值的数量为，就不像gcdmath模块的函数那样。例如，它可以接受值2,4,6,8,10并返回正确的GCD 2。

Ruby，23个字节

g=->a,b{b>0?a:g[b,a%b]}

请记住，使用g [...]或g.call（...）而不是g（...）调用ruby块

部分成绩归功于voidpigeon

ARM机器码，12个字节：

部件：

gcd: cmp r0, r1
     sublt r0, r0, r1
     bne gcd

当前无法编译它，但是ARM中的每个指令占用4个字节。可能可以使用THUMB-2模式打高尔夫球。

TI基本（10字节）

Prompt A,B:gcd(A,B

由于禁止GCD内置的新规则而导致无法竞争

没有gcd(内置的17字节解决方案

Prompt A,B:abs(AB)/lcm(A,B

由于新规则禁止lcm内置而导致无法竞争

没有gcd(或lcm(内置的27字节解决方案：

Prompt A,B:While B:B→T:BfPart(A/B→B:T→A:End:A

没有gcd(或lcm(内置的35字节递归解决方案（要求2.53 MP操作系统或更高版本，必须命名为 prgmG）：

If Ans(2:Then:{Ans(2),remainder(Ans(1),Ans(2:prgmG:Else:Disp Ans(1:End

您可以将参数传递给递归变量{A,B}，例如{1071, 462}:prgmG，yield 21。

05AB1E，10个字节

码：

EàF¹N%O>iN

在线尝试！

内置：

¿

说明：

¿   # Implicit input, computes the greatest common divisor.
    # Input can be in the form a \n b, which computes gcd(a, b)
    # Input can also be a list in the form [a, b, c, ...], which computes the gcd of
      multiple numbers.

在线尝试！或尝试使用多个数字。

的Oracle SQL 11.2 104个 118字节

SELECT MAX(:1+:2-LEVEL+1)FROM DUAL WHERE(MOD(:1,:1+:2-LEVEL+1)+MOD(:2,:1+:2-LEVEL+1))*:1*:2=0 CONNECT BY LEVEL<=:1+:2;

固定为0输入

> <>，12 + 3 = 15个字节

:?!\:}%
;n~/

期望输入数字出现在堆栈上，因此该-v标志为+3个字节。在线尝试！

欧几里得算法的另一种实现。