กุ๊บของฟังก์ชั่น $g(n)$ ( OEIS A000793 ) ให้การสั่งซื้อสูงสุดขององค์ประกอบของกลุ่มได้ส่วน$S_n$ n ที่นี่คำสั่งของการเปลี่ยนลําดับ$\pi$เป็นที่เล็กที่สุดจำนวนเต็มบวก$k$ดังกล่าวว่า$\pi^k$เป็นตัวตน - ซึ่งเท่ากับตัวคูณร่วมน้อยของความยาวของรอบในการสลายตัวของวงจรการเปลี่ยนแปลงของ ตัวอย่างเช่น$g(14) = 84$ซึ่งทำได้โดย (1,2,3) (4,5,6,7) (8,9,10,11,12,13,14)

ดังนั้น$g(n)$นอกจากนี้ยังเท่ากับค่าสูงสุดของ$\operatorname{lcm}(a_1, \ldots, a_k)$ที่1 + ⋯ + k = nกับ1 , ...$a_1 + \cdots + a_k = n$$a_1, \ldots, a_k$จำนวนเต็มบวก

ปัญหา

เขียนฟังก์ชั่นหรือโปรแกรมที่คำนวณฟังก์ชั่นของ Landau

อินพุต

จำนวนเต็มบวก $n$n

เอาท์พุต

$g(n)$ลำดับสูงสุดขององค์ประกอบของกลุ่มสมมาตร$S_n$ n

ตัวอย่าง

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

คะแนน

นี่คือ code-golf : โปรแกรมที่สั้นที่สุดในหน่วยไบต์ชนะ (อย่างไรก็ตามการใช้งานที่สั้นที่สุดในหลายภาษายินดีต้อนรับ)

โปรดทราบว่าไม่มีข้อกำหนดที่กำหนดในเวลาทำงาน; ดังนั้นการใช้งานของคุณไม่จำเป็นต้องสามารถสร้างผลลัพธ์ตัวอย่างทั้งหมดข้างต้นได้ในเวลาที่เหมาะสม

ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

05AB1E , 6 ไบต์

Åœ€.¿Z

ลองออนไลน์!

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

ภาษา Wolfram (Mathematica)ขนาด 44 ไบต์

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

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 31 ไบต์

@DanielSchepler มีทางออกที่ดีกว่า:

Max[LCM@@@IntegerPartitions@#]&

ลองออนไลน์!

Pythonขนาด 87 ไบต์

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

ลองออนไลน์!

ฟังก์ชั่น recursive ที่ติดตามที่เหลือnพาร์ทิชันและ dLCM โปรดทราบว่านี่หมายความว่าเราไม่จำเป็นต้องติดตามตัวเลขจริงในพาร์ติชันหรือจำนวนที่เราใช้ เราพยายามที่แต่ละส่วนถัดไปได้n-mแทนที่nด้วยสิ่งที่เหลือmและมีd lcm(d,n-m)เรารับประโยชน์สูงสุดจากผลลัพธ์แบบเรียกซ้ำเหล่านั้นและdตัวมันเอง เมื่อไม่มีสิ่งใดเหลืออยู่n=0ผลลัพธ์ก็จะเป็นเช่นdนั้น

สิ่งที่ยุ่งยากคือ Python ไม่มีบิวด์อินสำหรับ LCM, GCD หรือการแยกตัวประกอบเฉพาะ ที่จะทำlcm(d,m-n)เราสร้างรายการหลายรายการของdและใช้ค่าโมดูโลบรรลุขั้นต่ำn-m, key=(n-m).__rmod__ที่อยู่กับ เนื่องจากminจะให้ค่าก่อนหน้านี้ในกรณีที่เสมอกันนี่เป็นผลคูณที่ไม่ใช่ศูนย์แรกdที่หารด้วยn-mดังนั้น LCM ของพวกเขา เราทวีคูณdมากถึงd*(n-m)จะได้รับการรับรองในการเข้าสู่ LCM แต่มันสั้นกว่าที่จะเขียนd<<n(ซึ่งก็คือd*2**n) ซึ่งพอเพียงกับขอบเขตบนของไพ ธ อน

mathไลบรารีของ Python 3 มีgcd(แต่ไม่ใช่lcm) หลังจาก 3.5 ซึ่งสั้นกว่าไม่กี่ไบต์ ขอบคุณ @Joel ที่ทำให้การนำเข้าสั้นลง

Python 3.5+ , 84 ไบต์

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

ลองออนไลน์!

ใช้numpy's lcmยังสั้น

งูหลามกับnumpy 77 ไบต์

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

ลองออนไลน์!

Haskell , 44 ไบต์

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

ลองออนไลน์!

เยลลี่ขนาด 7 ไบต์

Œṗæl/€Ṁ

ลองออนไลน์!

ลิงก์ monadic ที่ใช้จำนวนเต็มเป็นอาร์กิวเมนต์และส่งคืนจำนวนเต็ม

คำอธิบาย

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

JavaScript (ES6), 92 ไบต์

คำนวณค่าสูงสุดของ $\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

ลองออนไลน์!

JavaScript (ES6), 95 ไบต์

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)

ลองออนไลน์!

อย่างไร?

เรากำหนด:

(นี่คือA008475 )

จากนั้นเราใช้สูตร (จากA000793 ):

Perl 6 , 50 ไบต์

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

ลองออนไลน์!

ตรวจสอบวิธีเรียงสับเปลี่ยนทั้งหมดโดยตรงเช่นโซลูชัน Ruby ของฮิสโทแคต

คำอธิบาย

                                     &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

¹เราสามารถใช้ลำดับของรายการที่แตกต่างกัน n สำหรับการตรวจสอบดังนั้นเราก็ใช้การเปลี่ยนแปลง

²หากจุดปลายเป็นคอนเทนเนอร์ตัว...ดำเนินการลำดับจะจับคู่กับรายการแรก ดังนั้นเราต้องผ่านรายการองค์ประกอบเดียว

Ruby , 77 ไบต์

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

ลองออนไลน์!

(1..) ไวยากรณ์ช่วงไม่ จำกัด นั้นใหม่เกินไปสำหรับ TIO ดังนั้นลิงก์จะตั้งค่าขอบเขตบนโดยพลการ

สิ่งนี้ใช้คำจำกัดความโดยตรง - ระบุพีชคณิตที่เป็นไปได้ทั้งหมดจากนั้นทดสอบแต่ละอันด้วยการกลายพันธุ์aจนกว่าจะกลับสู่ตำแหน่งเดิม

Gaia , 25 23 22 ไบต์

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

ลองออนไลน์!

การไม่มี LCM หรือพาร์ติชันจำนวนเต็มทำให้วิธีนี้ค่อนข้างยาว

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


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

Haskell, 70 67 ไบต์

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

ลองออนไลน์!

แก้ไข: -3 ไบต์ขอบคุณ @xnor

Python 3 + จำนวน, 115 102 99 ไบต์

-13 ไบต์ขอบคุณ @Daniel Shepler

-3 ไบต์เพิ่มเติมจาก @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))

ลองออนไลน์!

วิธีกำลังดุร้าย: ค้นหาลำดับที่เป็นไปได้ทั้งหมด a, b, c, ... โดยที่ a + b + c + ... = n จากนั้นเลือกอันที่มี lcm สูงสุด

Pyth , 24 15 ไบต์

eSm.U/*bZibZd./

ลองออนไลน์!

             ./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 ไบต์: ให้ความสนใจและสังเกตว่า Pyth มี GCD ในตัว ( i)