O problema A3 do concurso Putnam de 2008 diz:

$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)$

Seu objetivo neste desafio é pegar uma sequência finita de números inteiros positivos como entrada e gerar o resultado da repetição desse processo até que nenhum progresso adicional seja possível. (Isto é, até que cada número na sequência resultante divida todos os números que vêm depois dela.) Você não precisa resolver o problema de Putnam.

Este é o código-golfe : a solução mais curta em todas as linguagens de programação vence.

Casos de teste

[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]

Geléia , 9 bytes

ÆEz0Ṣ€ZÆẸ

Experimente online!

Como funciona

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

Pari / GP , 33 bytes

Calcule os divisores elementares da matriz diagonal.

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

Experimente online!

J , 17 bytes

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

Experimente online!

Provavelmente, a primeira resposta J no PPCG deve ser usada &.duas vezes. Depois disso e daquilo , estou começando a me sentir um estranho hacker J.

Basicamente, uma tradução da resposta de Dennis 'Jelly .

Como funciona

/:~"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 Language (Mathematica) , 44 bytes

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\})$

Experimente online!

Python 3 , 103 bytes

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)

Experimente online!

Explicação

Esse problema é essencialmente uma classificação paralela dos fatores primos e (gcd (a, b), lcm (a, b)) é análogo a (min (a, b), max (a, b)). Então, vamos falar em termos de classificação.

Provaremos por indução que, após f (i, j), a [i] se torna o menor valor em (o valor antigo de) L, onde L é o intervalo entre a [i] e a [j], incluindo as duas extremidades . E se j = -1, f (i, j) classificará o intervalo L.

O caso em que L contém um elemento é trivial. Para a primeira reivindicação, observe que o menor de L não pode permanecer em um [j] após a troca, então f (i, j-1) o colocará em um [i] ef (i + 1, - 1) não afetará isso.

Para a segunda afirmação, observe que a [i] é o menor valor ef (i + 1, -1) classificará os valores restantes, portanto L será classificado após f (i, j).

Retina , 65 bytes

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

Experimente online!O link inclui os casos de teste mais rápidos. Explicação:

\d+
*

Converta para unário.

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

Corresponde repetidamente: qualquer número com um fator, depois um número posterior que não é divisível pelo primeiro número, mas é divisível pelo fator.

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

$1é o primeiro número. $2é o fator Como o regex é ganancioso, esse é o maior fator, ou seja, o MDC. $4é a parte da partida entre os números originais. $5é o segundo número. $#3(em decimal em vez de unário) é um a menos que $1dividido por $2, pois não inclui o original $2. Isso significa que, para calcular o lcm, precisamos multiplicar $5por um mais do que o $#3que é escrito de maneira mais sucinta como a soma $5e o produto de $#3e$5 .

_+
$.&

Converta para decimal.

05AB1E , 10 bytes

O crédito pela abordagem vai para os alefalpha .

εIæN>ù€.¿¿

Experimente online!

ε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 bytes

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

Experimente online!

Resposta do Mathematica do porto de alefhalpha.

JavaScript (SpiderMonkey) , 69 bytes

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)

Experimente online!

• A função latribuir lcm(p,q)a a[j], e atribuir gcd(p, q)a qse j > i, caso contrário, mantém tudo inalterado.
  • lcm(p,q) = if p%q=0 then p else p*lcm(q,p%q)/(p%q)

Resposta antiga:

JavaScript (SpiderMonkey) , 73 bytes

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)

Experimente online!

• Função gcalcular gcd(u, v)e atribuir valor de retorno para u.

05AB1E , 15 14 13 bytes

Ó¾ζ€{øεgÅpymP

A resposta da porta do @ Dennis ♦ 'Jelly , mas infelizmente o 05AB1E não possui um componente baseado em Unexponents, o que leva mais que a metade do programa .. :(
-1 byte graças a @ Mr.Xcoder .
-1 byte graças a @Enigma .

Experimente online ou verifique todos os casos de teste .

Explicação:

Ó          # 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)