あなたの仕事は、与えられた2つの整数の最大公約数（GCD）をできるだけ少ないコードバイトで計算することです。

プログラムまたは関数を作成して、入力を受け取り、受け入れられた標準メソッド（STDIN / STDOUT、関数パラメーター/戻り値、コマンドライン引数などを含む）のいずれかを介して出力を返すことができます。

入力は2つの非負整数になります。言語のデフォルトの整数型でサポートされる全範囲、または範囲の[0,255]いずれか大きい方を処理できる必要があります。少なくとも1つの入力がゼロ以外になることが保証されます。

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

これは、ユークリッドのアルゴリズムをまったく使用しません-代わりに、正規表現一致グループを使用して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）

いずれかの入力= 0で破損するamd64の符号なしの場合は10 9B

入力はおよびの32ビットのゼロ以外の符号付き整数です。に出力します。eaxecxeax

## 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バージョンはそれを処理できます。無料で、以下を参照してください。

マイク・シュランタの答えがこれの出発点でした。私のループは彼と同じことをしますが、符号付き整数の場合cdqは1バイト短いためxor edx,edxです。はい、一方または両方の入力が負の場合でも正しく機能します。Mikeのバージョンはより高速に実行され、xchguop キャッシュのスペースが少なくなります（Intel CPUでは3 uopでloop、ほとんどのCPUでは本当に遅い）が、このバージョンはマシンコードサイズで勝ちます。

質問が符号なし 32ビットを必要とすることを最初は気がつきませんでした。のxor edx,edx代わりに戻ると、cdq1バイトかかります。 はと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/loop64ビットモードではコードサイズが保存されないため、同様に保存できますtest/jnz。64ビット整数を操作すると、REXプレフィックスの命令ごとに、loopまたはを除く別の1バイトが追加されます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

32および64bバージョンのGodbolt Compiler Explorerでソースおよびasm出力mainを実行するを含む、完全に実行可能なテストプログラム。32ビット（）、64ビット（）、およびx32 ABI（）でテストおよび動作しています。printf("...", gcd(atoi(argv[1]), atoi(argv[2])) ); -m32-m64-mx32

また含まれています：x86-64モードの場合でも、符号なしで9Bであり、任意のレジスタで入力の1つを取ることができる、繰り返し減算のみを使用するバージョン。ただし、入力時に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で入出力できるスニペットを含める最適な方法のようです。ご覧のとおり、GNU Cインラインasm構文はasmをugくてうるさくします。また、asm を学ぶのは本当に難しい方法です。

.att_syntax noprefix使用されるすべてのinsnがsingle / no operandまたはであるため、実際にモードでコンパイルおよび動作しますxchg。本当に有用な観察ではありません。

六角形、17バイト

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

展開：

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

オンラインでお試しください！

サイドレングス3に合わせるのは簡単でした。最後にこれらの2バイトを削除することはそうではありませんでした...それも最適だとは思いませんが、近いと思います。

説明

別のユークリッドアルゴリズムの実装。

プログラムは3つのメモリエッジを使用します。これらのメモリエッジはA、B、およびCと呼び、メモリポインタ（MP）は次のように始まります。

制御フロー図は次のとおりです。

制御フローは、入力用の短い線形ビットを持つ灰色のパスで開始されます。

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

現在、コード<は左端の端から端まで回り込んでいることに注意してください。これ<はブランチとして機能します。現在のエッジがゼロ（つまり、ユークリッドアルゴリズムが終了）の場合、IPは左に偏向され、赤いパスを取ります。それ以外の場合、ユークリッドアルゴリズムの反復が緑のパスで計算されます。

まず、緑の道を考えます。なお、>及び\全ては、単に命令ポインタを偏向ミラーとして作用します。また、制御フローは、下から上、右隅から下の列、最後に右下から左の隅の順に、エッジを3回ラップして条件を再確認します。また、これ.はノーオペレーションです。

1回の反復で次の線形コードが残ります。

{    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.

今、私たち3つのエッジが（元周期的にその役割を変更したことを、我々は除いて、開始しているバックCは、今の役割取りBと元Bの役割Aを ...）。実質的に、入力AとBwith BおよびA % Bをそれぞれ置き換えました。

一度A % B（エッジ上のC）GCDがエッジ上で見つけることができ、ゼロであるB。繰り返し>ますが、IP は単に偏向するため、赤いパスで実行します。

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

32ビットのリトルエンディアン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、153 169バイト

誰かがゴルフの最悪の言葉に言及しましたか？

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)

入力は、2つの数字の列配列です（;セパレータとして使用）。

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

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バイト

ユークリッドのアルゴリズムを実装するかなり簡単な関数。おそらく、別のアルゴリズムを使用して短くすることができます。

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 27 244
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-doループのようなものに入ります。スタックの最上部にはとが含まれます（暗黙的な無限量のゼロの上にありますが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%aa

最後に、一度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 @ . .
. . . . . . . .
    . .
    . .

ユークリッド法を使用します。

II2つの数値がSTDINから取得され、スタックに配置
/されます
%。残りは、スタックの一番上に左
?右TOS 0はその後、そうでない場合は、上の持ち運び有効にした場合
v、その後ダウンリダイレクトし、0でない場合はuMODに右に二回引き返す
/場合はリフレクタにキューブの周りに0ゴー
;ドロップTOS、O出力TOSと@終了

C＃、24バイト

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

Windowsバッチ、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機能を使用することはできませんので、ZdMATLで）を、私はの最小公倍数という事実に悪用している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バイト

ラケット（スキーム）でのユークリッド実装

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

編集：@Numeriのソリューションは見られませんでした（笑）。どういうわけか、まったく同じコードを個別に取得しました

> <>、32バイト

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

スタックから2つの値を受け入れ、ユークリッドアルゴリズムを適用してGCDを生成します。

ここで試すことができます！

> <>でより良い答えを得るには、Sokの！

ReRegex、23バイト

Retinaの回答と同じように機能します。

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

オンラインでお試しください！

GML、57バイト

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

Delphi 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.

フーン、20バイト

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

-

Hoon＃2、39バイト

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

奇妙なことに、GCD用のHoonのstdlibでの唯一の実装は、RSA暗号化で使用されているものであり、他の値も返します。d出力からのみ取得する関数でラップする必要があります。

もう1つの実装は、デフォルトの再帰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ゼロです。

また、数学モジュールの関数>=2とは異なり、値の量がである限り、このラムダ関数は必要な数の値を取得できgcdます。たとえば、値2,4,6,8,10を受け取り、2の正しいGCDを返すことができます。

ルビー、23バイト

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

ルビブロックはg（...）の代わりにg [...]またはg.call（...）で呼び出されることを覚えておいてください

voidpigeonへの部分的なクレジット

ARMマシンコード、12バイト：

アセンブリ：

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

現在、これをコンパイルすることはできませんが、ARMの各命令は4バイトかかります。おそらく、THUMB-2モードを使用してゴルフダウンできます。

TI-Basic、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なり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バイト。オンラインでお試しください！

ユークリッドアルゴリズムの別の実装。