2008 Putnam yarışmasının A3 sorunu şöyle diyor:

Sonlu bir dizi pozitif tamsayı ile başlayın . Mümkünse, iki endeks seçim öyle bölmek yok ve yerine ve tarafından ve \ metni {LCM} (a_j, a_k) sırasıyla. Bu işlem tekrarlanırsa, sonunda durması gerektiğini ve son sekansın yapılan seçimlere bağlı olmadığını kanıtlayın.$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)$

Bu zorluktaki hedefiniz girdi olarak sonlu bir pozitif tamsayı dizisi almak ve daha fazla ilerleme mümkün olmayana kadar bu işlemi tekrarlamanın sonucunu çıkarmaktır. (Yani, sonuç dizisindeki her sayı, ondan sonra gelen tüm sayıları bölene kadar.) Putnam sorununu çözmenize gerek yoktur.

Bu kod golf : her programlama dilinde en kısa çözüm kazanıyor.

Test senaryoları

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

Jöle , 9 bayt

ÆEz0Ṣ€ZÆẸ

Çevrimiçi deneyin!

Nasıl çalışır

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

Diyagonal matrisin temel bölmelerini hesaplar .

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

Çevrimiçi deneyin!

J , 17 bayt

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

Çevrimiçi deneyin!

Muhtemelen PPCG'de &.iki kez kullanılan ilk J cevabı . Bu ve sonra o , garip J korsan gibi hissetmeye başlıyorum.

Temelde Dennis'in cevabından bir çeviri .

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Python 3 , 103 bayt

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)

Çevrimiçi deneyin!

açıklama

Bu problem temelde asal faktörler üzerinde paralel bir sıralamadır ve (gcd (a, b), lcm (a, b)) (min (a, b), maks (a, b)) ile benzerdir. Öyleyse sıralama açısından konuşalım.

İndüksiyonla, f (i, j) 'den sonra a [i]' nin L'nin en eski değeri (eski değeri) haline geldiğini kanıtlayacağız, burada L, her iki ucu da içeren bir [i] ve bir [j] arasındaki aralıktır. . Ve j = -1 ise, f (i, j) L aralığını sıralar.

L'nin bir öğe içerdiği durumda önemsizdir. İlk iddia için, L'nin en küçüğünün takastan sonra [j] 'de kalamayacağına dikkat edin, bu yüzden f (i, j-1) onu [i]' ye koyar ve f (i + 1, - 1) etkilemez.

İkinci iddia için, a [i] 'nin en küçük değer olduğunu ve f (i + 1, -1) kalan değerleri sıralayacağını unutmayın, bu nedenle L, f (i, j)' den sonra sıralanır.

Retina , 65 bayt

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

Çevrimiçi deneyin! Bağlantı daha hızlı test senaryolarını içerir. Açıklama:

\d+
*

Tekli'ye dönüştür.

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

Tekrarlı olarak eşleme: faktörlü herhangi bir sayı, daha sonra ilk sayıya bölünemeyen ancak faktör tarafından bölünebilen sonraki bir sayı.

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

$1ilk sayıdır. $2faktördür. Normal ifade açgözlü olduğu için bu en büyük faktör yani gcd'dir. $4eşleşmenin orijinal sayılar arasındaki kısmıdır. $5ikinci sayıdır. $#3(tekli yerine ondalık olarak), orijinali içermediğinden, $1bölünmekten daha azdır . Biz çarpın gerek LCM hesaplamak için bu araçlar daha teker daha hangi en succintly toplamı olarak yazılır ve ürünü ve .$2$2$5$#3$5$#3$5

_+
$.&

Ondalık biçime dönüştür.

05AB1E , 10 bayt

Yaklaşımın kredisi alefafalfa gider .

εIæN>ù€.¿¿

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Port of alephalpha'nın Mathematica cevap.

JavaScript (SpiderMonkey) , 69 bayt

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)

Çevrimiçi deneyin!

• Fonksiyon latama lcm(p,q)için a[j]ve atama gcd(p, q)için qeğer j > i, aksi takdirde her şeyi değişmeden tutar.
  • lcm(p,q) = if p%q=0 then p else p*lcm(q,p%q)/(p%q)

Eski cevap:

JavaScript (SpiderMonkey) , 73 bayt

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)

Çevrimiçi deneyin!

• İşlev dönüş değerini ghesapla gcd(u, v)ve ata u.

05AB1E , 15 14 13 bayt

Ó¾ζ€{øεgÅpymP

@ Dennis ♦ ' limanından Jelly cevap , ama ne yazık ki 05AB1E Unexponents-builtin yok, bu yüzden programı yarıya indirmek daha fazla sürer .. :(
-1 byte @ Mr.Xcoder
sayesinde . -1 byte @Enigma sayesinde .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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