Hàm Landau $g(n)$ ( OEIS A000793 ) đưa ra thứ tự tối đa của một phần tử của nhóm đối xứng . Ở đây, thứ tự của một hoán vị là số nguyên dương nhỏ nhất sao cho là danh tính - bằng với bội số chung nhỏ nhất của độ dài của các chu kỳ trong phân rã chu kỳ hoán vị. Ví dụ: đạt được ví dụ bằng (1,2,3) (4,5,6,7) (8,9,10,11,12,13,14).$S_n$$\pi$$k$$\pi^k$$g(14) = 84$

Do đó, cũng bằng giá trị tối đa của trong đó với số nguyên dương.$g(n)$$\operatorname{lcm}(a_1, \ldots, a_k)$$a_1 + \cdots + a_k = n$$a_1, \ldots, a_k$

Vấn đề

Viết hàm hoặc chương trình tính toán hàm Landau.

Đầu vào

Một số nguyên dương .$n$

Đầu ra

$g(n)$ , thứ tự tối đa của một phần tử của nhóm đối xứng .$S_n$

Ví dụ

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

Ghi bàn

Đây là code-golf : Chương trình ngắn nhất tính bằng byte thắng. (Tuy nhiên, việc triển khai ngắn nhất bằng nhiều ngôn ngữ đều được chào đón.)

Lưu ý rằng không có yêu cầu áp đặt cho thời gian chạy; do đó, việc triển khai của bạn không nhất thiết phải có khả năng tạo ra tất cả các kết quả ví dụ trên trong bất kỳ thời gian hợp lý nào.

Sơ hở tiêu chuẩn bị cấm.

05AB1E , 6 byte

Åœ€.¿Z

Hãy thử trực tuyến!

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

Ngôn ngữ Wolfram (Mathicala) , 44 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 31 byte

@DanielSchepler có một giải pháp tốt hơn:

Max[LCM@@@IntegerPartitions@#]&

Hãy thử trực tuyến!

Python , 87 byte

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

Hãy thử trực tuyến!

Một hàm đệ quy theo dõi phần còn lại nđể phân vùng và LCM đang chạy d. Lưu ý rằng điều này có nghĩa là chúng ta không cần phải theo dõi các con số thực tế trong phân vùng hoặc số lượng chúng đã sử dụng. Chúng tôi thử từng phần tiếp theo có thể n-m, thay thế nbằng những gì còn lại mvà dbằng lcm(d,n-m). Chúng tôi lấy tối đa các kết quả đệ quy và dchính nó. Khi không còn gì n=0, kết quả chỉ là d.

Điều khó khăn là Python không có bất kỳ tích hợp nào cho LCM, GCD hoặc thừa số nguyên tố. Để làm lcm(d,m-n), chúng tôi tạo ra một danh sách bội số của dvà lấy giá trị đạt được modulo tối thiểu n-m, đó là với key=(n-m).__rmod__. Vì minsẽ đưa ra giá trị sớm hơn trong trường hợp hòa, đây luôn là bội số khác không đầu tiên dchia hết cho n-mLCM của chúng. Chúng tôi chỉ bội số của dlên đến d*(n-m)để được đảm bảo để đạt LCM, nhưng nó ngắn hơn để ghi d<<n(đó là d*2**n) mà cũng đủ với giới hạn trên của Python là độc quyền.

mathThư viện của Python 3 có gcd(nhưng không lcm) sau 3,5, ngắn hơn một vài byte. Cảm ơn @Joel đã rút ngắn quá trình nhập.

Python 3.5+ , 84 byte

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

Hãy thử trực tuyến!

Sử dụng numpy's lcmvẫn chưa ngắn hơn.

Python với numpy , 77 byte

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

Hãy thử trực tuyến!

Haskell , 44 byte

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

Hãy thử trực tuyến!

Thạch , 7 byte

Œṗæl/€Ṁ

Hãy thử trực tuyến!

Một liên kết đơn âm lấy một số nguyên làm đối số của nó và trả về một số nguyên.

Giải trình

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

JavaScript (ES6), 92 byte

$\operatorname{lcm}(a_1,\ldots,a_k)$$a_1+\ldots+a_k$$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

Hãy thử trực tuyến!

JavaScript (ES6), 95 byte

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)

Hãy thử trực tuyến!

Làm sao?

Chúng tôi xác định:

(đây là A008485 )

Sau đó, chúng tôi sử dụng công thức (từ A000793 ):

Perl 6 , 50 byte

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

Hãy thử trực tuyến!

Kiểm tra tất cả các hoán vị trực tiếp, như giải pháp Ruby của @ histocrat.

Giải trình

                                     &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

¹ Chúng ta có thể sử dụng bất kỳ chuỗi n mục riêng biệt nào cho việc kiểm tra, vì vậy chúng ta chỉ cần thực hiện phép hoán vị.

² Nếu điểm cuối là một thùng chứa, ...toán tử trình tự sẽ khớp với mục đầu tiên. Vì vậy, chúng ta phải vượt qua một danh sách các yếu tố duy nhất.

Ruby , 77 byte

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

Hãy thử trực tuyến!

(1..) cú pháp phạm vi vô hạn là quá mới đối với TIO, vì vậy liên kết đặt giới hạn trên tùy ý.

Điều này sử dụng định nghĩa trực tiếp - liệt kê tất cả các hoán vị có thể, sau đó kiểm tra từng cái bằng cách biến đổi acho đến khi nó trở lại vị trí ban đầu (điều này cũng có nghĩa là tôi có thể thay đổi mảng ban đầu trong mỗi vòng lặp).

Gaia , 25 23 22 byte

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

Hãy thử trực tuyến!

Không có phân vùng LCM hoặc số nguyên làm cho cách tiếp cận này khá dài.

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


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

Haskell, 70 67 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: -3 byte nhờ @xnor.

Python 3 + numpy, 115 102 99 byte

-13 byte nhờ @Daniel Shepler

-3 byte nữa từ @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))

Hãy thử trực tuyến!

Phương pháp Brute force: tìm tất cả các chuỗi có thể a, b, c, ... trong đó a + b + c + ... = n, sau đó chọn một chuỗi có lcm cao nhất.

Bình thường , 24 15 byte

eSm.U/*bZibZd./

Hãy thử trực tuyến!

             ./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 byte: đã chú ý và nhận thấy rằng Pyth thực sự có nội dung GCD ( i).