您面临的挑战是制作一个程序或函数，以一种语言输出其输入的GCD并以另一种语言输出其输入的LCM。允许但不鼓励使用GCD或LCM（我在看着您，Mathematica）的内建函数。将有2个输入，这些输入将始终为正整数，且不得大于1000。

测试用例

每行是一个测试用例，格式为x y => GCD(x,y) LCM(x,y)：

1 1 => 1 1
1 2 => 1 2
4 1 => 1 4
3 4 => 1 12
7 5 => 1 35
18 15 => 3 90
23 23 => 23 23
999 1000 => 1 999000
1000 999 => 1 999000
1000 1000 => 1000 1000

有关所有可能的输入，请参见此pastebin0 < x, y < 31。请注意，相同语言的不同版本计为不同语言。

果冻 / 实际上，2个字节

00000000: 1e 67                                            .g

这是已提交程序的十六进制转储（xxd）。由于TIO不支持CP437编码，因此无法在线测试。@Mego非常友好，可以验证它是否可以在Cygwin上正常工作，该Cygwin实现了实际上用于CP437的功能。

果冻：GCD

Jelly使用Jelly代码页，因此会看到以下字符。

œg

在线尝试！

怎么运行的

œ是不完整的令牌，因此被忽略。g是内置的GCD。

实际上：LCM

实际上使用CP 437，因此它看到以下字符。

▲g

在线尝试！

怎么运行的

▲是LCM输入。由于g（GCD）需要两个整数输入，因此不会执行。

C / C ++，79 78 73字节

感谢@ETHproductions节省了一个字节！

int f(int a,int b){int c,d=a*b;for(;a;b=c)c=a,a=b%a;auto e=.5;c=e?d/b:b;}

C计算GCD：在线尝试！

C ++计算LCM：在线尝试！

在C中，auto e=.5使用自动存储类（默认值）声明一个整数变量，然后将其初始化为0，而在C ++ 11中，它声明一个double值（初始化为0.5）。因此，变量的值在C ++中为true，在C中为false。

该函数使用Euclid算法计算GCD，并通过将a和b的乘积除以GCD来计算LCM。

省略return语句至少在GCC上有效。下面的78字节解决方案应与任何编译器一起使用：

int f(int a,int b){int c,d=a*b;for(;a;b=c)c=a,a=b%a;auto e=.5;return e?d/b:b;}

实际上 / 果冻，3个字节

00000000: 11 1c 67                                         ..g

这是已提交程序的十六进制转储（xxd）。

在线尝试！^1个

实际上：GCD

实际上使用CP 437，因此它看到以下字符。

◄∟g

在线尝试！

怎么运行的

     (implicit) Read a and b from STDIN and push them on the stack.
◄    Unassigned. Does nothing.
 ∟   Unassigned. Does nothing.
  g  Pop a and b and push gcd(a,b).
     (implicit) Write the result to STDOUT.

果冻：LCM

Jelly使用Jelly代码页，因此会看到以下字符。

×÷g    

在线尝试！

怎么运行的

×÷g  Main link. Left argument: a. Right argument: b

×      Multiply; yield ab.
  g    GCD; yield gcd(a,b).
 ÷     Division; yield ab/gcd(a,b) = lcm(a,b).

注意：公式gcd（a，b）lcm（a，b）= ab成立，因为a和b为正。

^1个 _{TIO实际上使用UTF-8作为。由于未分配ASCII字符和CP437字符0x11和0x1c，因此该程序仍然可以运行。}

爱丽丝和果冻，9个字节

爱丽丝计算LCM：

//L
oi@g

在线尝试！

看起来像一个空间的确0x7F是DEL控制字符。

果冻计算GCD。由于Jelly使用其自己的代码页，该代码页仅与可打印ASCII兼容，因此换行符和DEL字符½分别变成和换行符：

//L½oi@
g

在线尝试！

说明

Jelly很琐碎：第一行定义了一个荒谬的帮助程序链接，第二行是实际程序，它仅包含内置的GCD。

爱丽丝有点棘手，但它也使用内置功能：

/   Reflect to SE. Switch to Ordinal.
    While in Ordinal mode, the IP bounces diagonally up and down through the grid.
i   Read all input as a single string.
L   Compute the shortest common superstring of an empty string and the input. That
    is simply the input itself, so this does nothing.
    After two more bounces, the IP hits the top right corner and turns
    around, continuing to bounce up and down while moving west.
L   Still does nothing.
i   Try to read more input, but this simply pushes an empty string.
/   Reflect to W. Switch to Cardinal.
    The IP wraps to the last column.
L   Implicitly discard the empty string and convert the input to two integers.
    Compute their LCM.
/   Reflect to NW. Switch to Ordinal.
    The IP immediately reflects off the top boundary to move SW instead.
o   Implicitly convert the LCM to a string and print it.
    Reflect off the bottom left corner and move back NE.
/   Reflect to S. Switch to Cardinal.
i   Try to read a byte, but we're at EOF, so this pushes -1 instead. Irrelevant.
    The IP wraps back to the first line.
/   Reflect to NE. Switch to Ordinal.
    The IP immediately reflects off the top boundary to move SE instead.
@   Terminate the program.

八度/ MATLAB，66 61字节

@(x,y)gcd(x,y)^(1-2*any(version==82))*(x*y)^any(version==82))

由于Foon节省了5个字节。(x*y)^any()当然比短1+(x*y-1)*any()。

好吧，至少它不使用内置的 lcm。

说明：

这使用内置函数gcd来计算最大公约数。

在Octave中，将其提升为的幂1-2*any(version==82)。any(version==82)是0在八度，所以这是根本gcd(x,y)^1。它乘以(x*y)^any(version==82)或(x*y)^0 = 1。

对于MATLAB，gcd提高到的功效1-2*any(version==82)。any(version==82)是1在MATLAB，所以这是gcd(x,y)^-1。它乘以(x*y)^any(version==82)或(x*y)^1 = x*y。这给了最小公倍数，因为lcm(x,y) == x*y/gcd(x,y)对于正数。

果冻和MATL，6个 5字节

ZmD
g

这是两种语言之一的完整程序。它计算Jelly中的GCD（在线尝试！）和MATL中的LCM（在线尝试！）。生成正确的输出后，MATL程序退出并出现错误（默认情况下允许）。

仅使用ASCII字符，因此它们对应于两种语言中相同的编码字节。

果冻中的GCD说明

ZmD    Unused link
g      Main link (gets called automatically). Builtin GCD function (g)

MATL中的LCM解释

ZmD    Compute LCM (builtin function Zm) and display immediately (D)
g      Tries to implicitly take input to do something with it (depending
       on the type of the input). Since there is no input, it errors out

朱莉娅0.4 /朱莉娅0.5，18个字节

log.(1)==0?lcm:gcd

gcd在Julia 0.4中评估（在线尝试！），lcm在Julia 0.5中评估（在线尝试！）。

怎么运行的

在Julia 0.4中，log.(1)是的简写getfield(log,1)，它返回log内置对象的存储位置，例如，指针Ptr{Void} @0x00007f2846cb6660。因此结果为非零，比较结果为false，表达式的计算结果为gcd。

在Julia 0.5中，引入了新的函数向量化语法。log.(1)现在是的简写broadcast(log,1)，因为1它不可迭代，所以仅求值log(1)。因此结果为零，比较为真，表达式的计算结果为lcm。

八度/ MATLAB，44 42 41字节

eval(['@' 'lcm'-[5 0 9]*all(version-82)])

这为GCD定义了一个匿名函数（@gcd Octave中的）和@lcmMATLAB中的LCM（）。

Octave中的示例（或在线尝试！）：

>> eval(['@' 'lcm'-[5 0 9]*all(version-82)])
warning: implicit conversion from numeric to char
ans = @gcd
>> ans(12,16)
ans =  4

MATLAB中的示例：

>> eval(['@' 'lcm'-[5 0 9]*all(version-82)])
ans =
    @lcm
>> ans(12,16)
ans =
    48

JS（ES6），CGL（CGL高尔夫语言），31字节（非竞争）

在此挑战之后，添加了CGL的LCM功能。

 g=(a,b)=>b?g(b,a%b):a
//-LⓍ

看起来像一个空间实际上是一个不间断的空间，这是CGL的评论。JS计算GCD：

g=(a,b)=>b?g(b,a%b):a

CGL计算LCM：

//  does nothing
- decrements the current stack number, resulting in it pointing to input
L computes the LCM of the first and second stack items and pushes it to the stack
Ⓧ prints out the last stack item

试试看：

Snippetify( g=(a,b)=>b?g(b,a%b):a
//-LⓍ
);

<script src="https://programmer5000.com/snippetify.min.js"></script>
<input type = "number">
<input type = "number">