问题A3来自 2008年Putnam竞赛的说：

开始一个有限序列$a_1, a_2, \dots, a_n$正整数。如果可能的话，选择两个指数$j < k$使得$a_j$不划分$a_k$，并更换$a_j$和$a_k$通过$\gcd(a_j, a_k)$和$\text{lcm}(a_j, a_k)$， 分别。证明如果重复此过程，则它最终必须停止并且最终顺序不取决于所做的选择。

您在此挑战中的目标是将有限整数的正整数作为输入，并输出重复此过程直到无法进一步进行的结果。（也就是说，直到结果序列中的每个数字都除以其后的所有数字。）您无需解决Putnam问题。

这是代码高尔夫：每种编程语言中最短的解决方案胜出。

测试用例

[1, 2, 4, 8, 16, 32] => [1, 2, 4, 8, 16, 32]
[120, 24, 6, 2, 1, 1] => [1, 1, 2, 6, 24, 120]
[97, 41, 48, 12, 98, 68] => [1, 1, 2, 4, 12, 159016368]
[225, 36, 30, 1125, 36, 18, 180] => [3, 9, 18, 90, 180, 900, 4500]
[17, 17, 17, 17] => [17, 17, 17, 17]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] => [1, 1, 1, 1, 1, 2, 2, 6, 60, 2520]

果冻，9字节

ÆEz0Ṣ€ZÆẸ

在线尝试！

怎么运行的

ÆEz0Ṣ€ZÆẸ  Main link. Argument: A (array)

ÆE         For each n in A, compute the exponents of n's prime factorization.
           E.g., 2000000 = 2⁷3⁰5⁶ gets mapped to [7, 0, 6].
  z0       Zip 0; append 0's to shorter exponent arrays to pad them to the same
           length, then read the resulting matrix by columns.
    Ṣ€     Sort the resulting arrays (exponents that correspond to the same prime).
      Z    Zip; read the resulting matrix by columns, re-grouping the exponents by
           the integers they represent.
       ÆẸ  Unexponents; map the exponent arrays back to integers.

巴黎/ GP，33字节

计算对角矩阵的基本除数。

a->Vecrev(matsnf(matdiagonal(a)))

在线尝试！

J，17个字节

/:~"1&.|:&.(_&q:)

在线尝试！

可能是对PPCG的第一个J答案使用了&.两次。之后，那，我开始觉得自己像一个奇怪的Ĵ黑客。

基本上是从 丹尼斯·杰利答案。

怎么运行的

/:~"1&.|:&.(_&q:)  Single monadic verb.
           (_&q:)  Convert each number to prime exponents
                   (automatically zero-filled to the right)
       |:&.        Transpose
/:~"1&.            Sort each row in increasing order
       |:&.        Transpose again (inverse of transpose == transpose)
           (_&q:)  Apply inverse of prime exponents; convert back to integers

Wolfram语言（Mathematica），44字节

Table[GCD@@LCM@@@#~Subsets~{i},{i,Tr[1^#]}]&

$k$$k$

$b_k = \gcd(\{\operatorname{lcm}(a_{i_1}, \cdots, a_{i_k}) | 1 \le i_1 < \cdots < i_k \le n\})$

在线尝试！

Python 3，103个字节

import math
def f(a,i=0,j=-1):d=math.gcd(a[i],a[j]);a[j]*=a[i]//d;a[i]=d;a[i:j]and f(a,i,j-1)==f(a,i+1)

在线尝试！

说明

这个问题本质上是对素因子的并行排序，并且（gcd（a，b），lcm（a，b））类似于（min（a，b），max（a，b））。因此，让我们谈谈排序。

我们将通过归纳证明，在f（i，j）之后，a [i]成为L（旧值）中的最小值，其中L是a [i]和a [j]之间的范围，包括两端。如果j = -1，则f（i，j）将对范围L进行排序。

L包含一个元素的情况是微不足道的。对于第一个索赔，请注意，交换之后L的最小值不能留在a [j]中，因此f（i，j-1）会将其放在a [i]中，而f（i + 1，- 1）不会影响它。

对于第二项权利要求，请注意a [i]是最小值，并且f（i + 1，-1）将对其余值进行排序，因此L在f（i，j）之后进行排序。

视网膜，65字节

\d+
*
+`\b((_+)(\2)+)\b(.*)\b(?!\1+\b)(\2+)\b
$2$4$5$#3*$5
_+
$.&

在线尝试！链接包括更快的测试用例。说明：

\d+
*

转换为一元。

+`\b((_+)(\2)+)\b(.*)\b(?!\1+\b)(\2+)\b

重复匹配：任何具有因子的数字，然后是不能被第一个数字整除但可以被因子整除的后一个数字。

$2$4$5$#3*$5

$1是第一个数字。$2是因素。因为正则表达式是贪婪的，所以这是最大的因素，即gcd。$4是原始数字之间匹配的一部分。$5是第二个数字。$#3（以十进制而不是一进制表示）小于$1除以1$2，因为它不包括原始$2。这意味着，要计算我们需要乘以LCM $5一个超过$#3其最succintly写成的总和$5和的产品$#3和$5。

_+
$.&

转换为十进制。

05AB1E，10个字节

这种方法的功劳归功于alephalpha。

εIæN>ù€.¿¿

在线尝试！

εIæN>ù€.¿¿     Full program. Takes a list from STDIN, outputs another one to STDOUT.
ε              Execute for each element of the input, with N as the index variable.
 Iæ            Powerset of the input.
   N>ù         Only keep the elements of length N+1.
      €.¿      LCM each.
         ¿     Take the GCD of LCMs.

Perl 6、53字节

{map {[gcd] map {[lcm] $_},.combinations: $^i},1..$_}

在线尝试！

alephalpha的Mathematica答案端口。

JavaScript（SpiderMonkey），69字节

a=>a.map((q,i)=>a.map(l=(p,j)=>a[j]=j>i&&(t=p%q)?p/t*l(q,j,q=t):p)|q)

在线尝试！

• 函数l分配lcm(p,q)给a[j]，并分配gcd(p, q)给qif j > i，否则保持所有内容不变。
  • lcm(p,q) = if p%q=0 then p else p*lcm(q,p%q)/(p%q)

旧答案：

JavaScript（SpiderMonkey），73字节

a=>a.map((u,i)=>a.map((v,j)=>i<j?a[j]*=u/(g=p=>p%u?g(u,u=p%u):u)(v):0)|u)

在线尝试！

• 函数g计算gcd(u, v)并将返回值分配给u。

05AB1E，15 14 13 字节

Ó¾ζ€{øεgÅpymP

港@丹尼斯♦ “果冻的答案，但遗憾的是05AB1E不具有Unexponents-内置，所以比减半的是需要更多的节目.. :(
-1字节感谢@ Mr.Xcoder。
-1感谢字节@Enigma。

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

说明：

Ó          # Prime exponents of the (implicit) input-list
 ¾ζ        # Zip, swapping rows and columns, with integer 0 as filler
   €{      # Sort each inner list
     ø     # Zip, swapping rows and columns again
ε          # Map each inner list:
 gÅp       #  Get the first `l` primes, where `l` is the size of the inner list
    ym     #  Take the power of the prime-list and inner list
      P    #  And then take the product of that result
           # (And output implicitly)