Masalah A3 dari kompetisi Putnam 2008 mengatakan:

Mulai dengan urutan hingga dari bilangan bulat positif. Jika memungkinkan, pilih dua indeks agar tidak membagi , dan ganti dan dengan dan \ text {lcm} (a_j, a_k) , masing-masing. Buktikan bahwa jika proses ini diulang, akhirnya harus berhenti dan urutan akhir tidak tergantung pada pilihan yang dibuat.$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)$

Tujuan Anda dalam tantangan ini adalah untuk mengambil urutan terbatas dari bilangan bulat positif sebagai input, dan output hasil mengulangi proses ini sampai tidak ada kemajuan lebih lanjut. (Yaitu, sampai setiap angka dalam urutan yang dihasilkan membagi semua angka yang datang setelah itu.) Anda tidak perlu menyelesaikan masalah Putnam.

Ini adalah kode-golf : solusi terpendek dalam setiap bahasa pemrograman yang menang.

Uji kasus

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

Jelly , 9 byte

ÆEz0Ṣ€ZÆẸ

Cobalah online!

Bagaimana itu bekerja

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

Hitung pembagi dasar dari matriks diagonal.

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

Cobalah online!

J , 17 byte

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

Cobalah online!

Mungkin jawaban J pertama di PPCG yang digunakan &.dua kali. Setelah ini dan itu , saya mulai merasa seperti hacker J yang aneh.

Pada dasarnya terjemahan dari jawaban Dennis 'Jelly .

Bagaimana itu bekerja

/:~"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

Bahasa Wolfram (Mathematica) , 44 byte

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

The unsur -th hasilnya adalah GCD dari LCM yang adalah dari subset dengan elemen.$k$$k$

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

Cobalah online!

Python 3 , 103 byte

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)

Cobalah online!

Penjelasan

Masalah ini pada dasarnya adalah semacam paralel pada faktor prima, dan (gcd (a, b), lcm (a, b)) analog dengan (min (a, b), maks (a, b)). Jadi mari kita bicara tentang penyortiran.

Kami akan membuktikan dengan induksi bahwa setelah f (i, j), a [i] menjadi nilai terkecil dalam (nilai lama) L, di mana L adalah kisaran antara [i] dan a [j], termasuk kedua ujungnya . Dan jika j = -1, f (i, j) akan mengurutkan rentang L.

Kasus ketika L mengandung satu elemen sepele. Untuk klaim pertama, perhatikan bahwa L terkecil tidak dapat tetap dalam [j] setelah swap, jadi f (i, j-1) akan memasukkannya ke dalam [i], dan f (i + 1, - 1) tidak akan mempengaruhinya.

Untuk klaim kedua, perhatikan bahwa [i] adalah nilai terkecil, dan f (i + 1, -1) akan mengurutkan nilai yang tersisa, sehingga L menjadi diurutkan setelah f (i, j).

Retina , 65 byte

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

Cobalah online! Tautan termasuk kasus uji lebih cepat. Penjelasan:

\d+
*

Konversikan ke unary.

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

Pencocokan berulang: angka apa pun dengan faktor, maka angka kemudian yang tidak dapat dibagi dengan angka pertama tetapi dapat dibagi oleh faktor.

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

$1adalah angka pertama. $2adalah faktornya. Karena regex serakah ini adalah faktor terbesar yaitu gcd. $4adalah bagian dari kecocokan antara angka-angka asli. $5adalah angka kedua. $#3(dalam desimal daripada unary) adalah yang kurang dari $1dibagi $2, karena tidak termasuk yang asli $2. Ini berarti bahwa untuk menghitung lcm kita perlu mengalikannya $5dengan satu lebih dari $#3yang paling berhasil ditulis sebagai jumlah $5dan produk dari $#3dan $5.

_+
$.&

Konversikan ke desimal.

05AB1E , 10 byte

Penghargaan untuk pendekatan ini diberikan kepada alephalpha .

εIæN>ù€.¿¿

Cobalah 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 byte

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

Cobalah online!

Jawaban Port of alephalpha Mathematica.

JavaScript (SpiderMonkey) , 69 byte

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)

Cobalah online!

• Fungsi lmenetapkan lcm(p,q)untuk a[j], dan menetapkan gcd(p, q)untuk qjika j > i, jika tidak menjaga semua berubah.
  • lcm(p,q) = if p%q=0 then p else p*lcm(q,p%q)/(p%q)

Jawaban lama:

JavaScript (SpiderMonkey) , 73 byte

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)

Cobalah online!

• Fungsi gmenghitung gcd(u, v)dan menetapkan nilai kembali ke u.

05AB1E , 15 14 13 byte

Ó¾ζ€{øεgÅpymP

Port @ Dennis ♦ 'Jelly menjawab , tapi sayangnya 05AB1E tidak memiliki built-in Unexponents, sehingga dibutuhkan lebih dari setengahnya program .. :(
-1 byte terima kasih kepada @ Mr.Xcoder .
-1 byte terima kasih kepada @Enigma .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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