Landau fonksiyonu $g(n)$ ( OEIS A000793 ) simetrik grubun bir elemanının maksimum seviyesini verir $S_n$ . Burada, bir permütasyon sırası $\pi$ en küçük pozitif tam sayı olduğu $k$ şekilde $\pi^k$ permütasyon en döngüsü ayrışma döngü uzunlukları en az ortak katı eşittir - kimliktir. Örneğin, $g(14) = 84$ , örneğin (1,2,3) (4,5,6,7) (8,9,10,11,12,13,14) ile elde edilir.

Bu nedenle, $g(n)$ , aynı zamanda, en yüksek değerine eşit olan $\operatorname{lcm}(a_1, \ldots, a_k)$ burada $a_1 + \cdots + a_k = n$ olan $a_1, \ldots, a_k$ pozitif tamsayı.

Sorun

Landau'nun işlevini hesaplayan bir işlev veya program yazın.

Giriş

Pozitif bir tam sayı $n$ .

Çıktı

$g(n)$ , simetrik grup$S_n$ bir elemanının maksimum sırası.

Örnekler

n    g(n)
1    1
2    2
3    3
4    4
5    6
6    6
7    12
8    15
9    20
10   30
11   30
12   60
13   60
14   84
15   105
16   140
17   210
18   210
19   420
20   420

Puan

Bu kod golf : bayt en kısa program kazanır. (Bununla birlikte, birden çok dilde en kısa uygulamalar kabul edilir.)

Çalışma zamanı için herhangi bir gereksinim olmadığını unutmayın; bu nedenle, uygulamanızın yukarıdaki örnek sonuçların tümünü makul bir zamanda oluşturabilmesi gerekmez.

Standart boşluklar yasaktır.

05AB1E , 6 bayt

Åœ€.¿Z

Çevrimiçi deneyin!

    Ŝ       # integer partitions of the input
      €.¿    # lcm of each
         Z   # maximum

Wolfram Dili (Mathematica) , 44 bayt

Max[PermutationOrder/@Permutations@Range@#]&

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 31 bayt

@DanielSchepler daha iyi bir çözüme sahiptir:

Max[LCM@@@IntegerPartitions@#]&

Çevrimiçi deneyin!

Python , 87 bayt

f=lambda n,d=1:max([f(m,min(range(d,d<<n,d),key=(n-m).__rmod__))for m in range(n)]+[d])

Çevrimiçi deneyin!

Kalan nbölümü ve çalışan LCM'yi izleyen özyinelemeli işlev d. Bunun, bölümdeki gerçek sayıları veya kaç tanesini kullandığımızı izlememiz gerekmediği anlamına gelir. Biz olası her bir sonraki bölümü, deneyin n-m, yerine ngeriye ne ile mve dile lcm(d,n-m). Bu özyinelemeli sonuçların ve dkendisinin maksimumunu alıyoruz . Hiçbir şey kalmadığında n=0, sonuç adil olur d.

Zor olan şey, Python'un LCM, GCD veya asal çarpanlara ayırma için yerleşik olmadığıdır. Yapmak için lcm(d,m-n), biz katları listesini oluşturmak dve minimum modulo ulaşma değeri almak n-mile, key=(n-m).__rmod__. Yana minbir eşitlik olması durumunda daha erken değeri verecektir, bu ilk sıfırdan farklı çoklu her zaman dki bölünemeyen var n-m, onların LCM yüzden. Biz sadece katları dup d*(n-m)LCM vurmak için garantili, ancak yazma için daha kısa olması d<<n(olduğu d*2**nPython'un üst sınırları münhasır olmak yeterli).

Python 3'ün mathkütüphanesi 3.5'ten sonra gcd(ancak değil lcm), birkaç bayt daha kısa. İçe aktarmayı kısalttığı için @Joel'e teşekkürler.

Python 3.5+ , 84 bayt

import math
f=lambda n,d=1:max([f(m,d*(n-m)//math.gcd(n-m,d))for m in range(n)]+[d])

Çevrimiçi deneyin!

numpy'S kullanmak lcmhenüz daha kısadır.

İle Python numpy , 77 bayt

from numpy import*
f=lambda n,d=1:max([f(m,lcm(d,n-m))for m in range(n)]+[d])

Çevrimiçi deneyin!

Haskell , 44 bayt

(%1)
n%t=maximum$t:[(n-d)%lcm t d|d<-[1..n]]

Çevrimiçi deneyin!

Jöle , 7 bayt

Œṗæl/€Ṁ

Çevrimiçi deneyin!

Bir tamsayıyı argümanı olarak alan ve bir tamsayıyı döndüren monadik bir bağlantı.

açıklama

Œṗ      | Integer partitions
  æl/€  | Reduce each using LCM
      Ṁ | Maximum

JavaScript (ES6), 92 bayt

Maksimum değerini hesaplar $\operatorname{lcm}(a_1,\ldots,a_k)$ nerede $a_1+\ldots+a_k$ bir bölümüdür $n$.

f=(n,i=1,l=m=0)=>n?i>n?m:f(n-i,i,l*i/(G=(a,b)=>b?G(b,a%b):a)(l,i)||i)&f(n,i+1,l)|m:m=l>m?l:m

Çevrimiçi deneyin!

JavaScript (ES6), 95 bayt

f=(n,i=1,m)=>i>>n?m:f(n,i+1,i<m|(g=(n,k=2,p=0)=>k>n?p:n%k?p+g(n,k+1):g(n/k,k,p*k||k))(i)>n?m:i)

Çevrimiçi deneyin!

Nasıl?

Biz tanımlarız:

(bu A008475 )

Sonra aşağıdaki formülü kullanıyoruz ( A000793'ten ):

Perl 6 , 50 bayt

{max .map:{+(.[$_],{.[@^a]}...$_,)}}o&permutations

Çevrimiçi deneyin!

@ Histocrat'ın Ruby çözümü gibi tüm permütasyonları doğrudan kontrol eder.

açıklama

                                     &permutations  # Permutations of [0;n)
{                                  }o  # Feed into block
     .map:{                       }  # Map permutations
                           ...  # Construct sequence
             .[$_]  # Start with permutation applied to itself [1]
                  ,{.[@^a]}  # Generate next item by applying permutation again
                              $_,  # Until it matches original permutation [2]
           +(                    )  # Length of sequence
 max  # Find maximum

¹ Kontrol için herhangi bir n farklı öğe dizisi kullanabiliriz, böylece sadece permütasyonun kendisini alırız.

² Uç nokta bir ...kapsa , sıra operatörü ilk öğeye karşılık gelir. Bu yüzden tek elemanlı bir listeden geçmek zorundayız.

Ruby , 77 bayt

f=->n{a=*0...n;a.permutation.map{|p|(1..).find{a.map!{|i|p[i]}==a.sort}}.max}

Çevrimiçi deneyin!

(1..) sonsuz aralık sözdizimi TIO için çok yeni olduğundan, bağlantı keyfi bir üst sınır belirler.

Bu doğrudan tanımı kullanır - olası tüm permütasyonları numaralandırır, ardından aorijinal konumuna geri dönene kadar mutasyona uğratarak her birini test edin (bu da her bir döngüdeki orijinal diziyi değiştirebileceğim anlamına gelir).

Gaia , 25 23 22 bayt

,:Π¤d¦&⊢⌉/
1w&ḍΣ¦¦⇈⊢¦⌉

Çevrimiçi deneyin!

LCM veya tamsayı bölümlerinin olmaması bu yaklaşımı oldukça uzun hale getirir.

,:Π¤d¦&⊢⌉/		;* helper function: LCM of 2 inputs


1w&ḍΣ¦¦			;* push integer partitions
         ¦		;* for each
       ⇈⊢		;* Reduce by helper function
	  ⌉		;* and take the max

Haskell, 70 67 bayt

f n=maximum[foldl1 lcm a|k<-[1..n],a<-mapM id$[1..n]<$[1..k],sum a==n]

Çevrimiçi deneyin!

Düzenleme: @xnor sayesinde -3 bayt.

Piton 3 + numpy, 115 102 99 bayt

@Daniel Shepler sayesinde -13 bayt

-3 more bytes from @Daniel Shepler

import numpy
c=lambda n:[n]+[numpy.lcm(i,j)for i in range(1,n)for j in c(n-i)]
l=lambda n:max(c(n))

Try it online!

Brute force method: find all possible sequences a,b,c,... where a+b+c+...=n, then pick the one with the highest lcm.

Pyth , 24 15 bayt

eSm.U/*bZibZd./

Çevrimiçi deneyin!

             ./Q  # List of partitions of the input
  m               # map that over lambda d:
   .U       d     # reduce d (with starting value first element of the list) on lambda b,Z:
     /*bZgbZ      # (b * Z) / GCD(b, Z)
 S                # this gives the list of lcms of all partitions. Sort this
e                 # and take the last element (maximum)

-9 bayt: Pyth'in aslında bir GCD yerleşik ( i) olduğunu fark etti .