# Greatest Common Divisor

Your task is to compute the greatest common divisor (GCD) of two given integers in as few bytes of code as possible.

You may write a program or function, taking input and returning output via any of our accepted standard methods (including STDIN/STDOUT, function parameters/return values, command-line arguments, etc.).

Input will be two non-negative integers. You should be able to handle either the full range supported by your language's default integer type, or the range [0,255], whichever is greater. You are guaranteed that at least one of the inputs will be non-zero.

You are not allowed to use built-ins that compute either the GCD or the LCM (least common multiple).

Standard rules apply.

### Test Cases

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

• If we're allowing asm to have inputs in whatever registers are convenient, and the result in whatever reg is convenient, we should definitely be allowing functions, or even code fragments (i.e. just a function body). Making my answer a complete function would add about 4B with a register calling convention like MS's 32bit vectorcall (one xchg eax, one mov, and a ret), or more with a stack calling convention. – Peter Cordes Apr 8 '16 at 23:05
• @PeterCordes Sorry, I should have been more specific. You can totally just write the bear necessary code but if you would be so kind as to include a way to run said code it would be nice. – Mike Shlanta Apr 9 '16 at 18:59
• So count just the gcd code, but provide the surrounding code so people can verify / experiment / improve? BTW, your test-cases with zero as one of the two inputs break our x86 machine code answers. div by zero raises a hardware exception. On Linux, your process gets a SIGFPE. – Peter Cordes Apr 9 '16 at 19:30
• @CodesInChaos Memory and time limitations are usually ignored as long as the algorithm itself can in principle handle all inputs. The rule is just meant to avoid people hardcoding arbitrary limits for loops that artificially limits the algorithm to a smaller range of inputs. I don't quite see how immutability comes into this? – Martin Ender Apr 10 '16 at 14:10
• gcd(0,n) is error not n – RosLuP Mar 18 '19 at 12:33

# APL(NARS), 13 chars, 26 bytes

{⍵<1:⍺⋄⍵∇⍵∣⍺}


test:

  g←{⍵<1:⍺⋄⍵∇⍵∣⍺}
30 g 42
6
42 g 30
6
15 g 14
1
7 g 7
7
69 g 25
1
0 g 2
2
6 g 0
6


# Smalltalk, 29 bytes

[(a:=b\\(b:=a))>0]whileTrue.b


## Explanation

a, b                  two integers given as input
b\\(b:=a)             compute (b mod a) and then assign a to b
a:=b\\(b:=a)          assign the remainder just computed to a
[(...)>0]whileTrue    repeat while the reminder a is > 0 (stop otherwise)
b                     return b (the gcd) - dot is a sentence separator

• Feel free to expand your answer by including an explanation and a link to an online interpreter. Not everyone here knows Smalltalk. When your answers are short and just code, they show in the "Low Quality Posts" queue and users have to review them. Take a look at answers by other users to see some examples. – mbomb007 Mar 19 '19 at 15:11
• @mbomb007 Done. Thanks for the suggestion. – Leandro Caniglia Mar 19 '19 at 15:39

# AWK, 39 bytes

{for(x=$1>$2?$1:$2;$1%x||$2%x;)--x}$0=x  Try it online! Does require that 1 of the inputs be positive. Nothing fancy, but I don't see another AWK solution. ## Perl 6, 28 bytes my&f={$^b??f($b,$^a%$b)!!$a}


# Forth (gforth), 52 bytes

: f begin 2dup max -rot min tuck mod ?dup 0= until ;


Try it online!

Uses Euclidean Algorithm [repeatedly call larger % smaller until result is 0]

### Code Explanation

: f               \ start a new word definition
begin           \ start and indefinite loop
2dup          \ duplicate arguments
max -rot min  \ reorder arguments so the smaller is on top
tuck          \ make a copy of the smaller argument and move it behind the larger
mod ?dup 0=   \ get the modulo of the two arguments, then duplicate and check if it is 0
until           \ end the loop if it is
;                 \ end the word definition