Landau के कार्य की गणना करें

Question

Landau के फ़ंक्शन $g(n)$ ( OEIS A000793 ) सममित समूह $S_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)$ जहां $a_1 + \cdots + a_k = n$ के साथ $a_1, \ldots, a_k$ धनात्मक पूर्णांक।

मुसीबत

एक समारोह या कार्यक्रम लिखें जो लैंडौ के कार्य की गणना करता है।

इनपुट

एक सकारात्मक पूर्णांक $n$ ।

उत्पादन

$g(n)$ , सममित समूह S n के एक तत्व का अधिकतम क्रम$S_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

स्कोर

यह कोड-गोल्फ है : बाइट्स जीत में सबसे छोटा कार्यक्रम। (फिर भी, कई भाषाओं में कम से कम कार्यान्वयन स्वागत योग्य है।)

ध्यान दें कि रन-टाइम पर कोई आवश्यकता नहीं है; इसलिए, आपके कार्यान्वयन के लिए आवश्यक नहीं है कि किसी भी उचित समय में उपरोक्त सभी उदाहरण परिणाम उत्पन्न किए जा सकें।

मानक खामियों को मना किया जाता है।

Answer 1

05AB1E , 6 बाइट्स

Åœ€.¿Z

इसे ऑनलाइन आज़माएं!

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

Answer 2

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वोल्फ्राम भाषा (गणितज्ञ) , 31 बाइट्स

@DanielSchepler का बेहतर समाधान है:

Max[LCM@@@IntegerPartitions@#]&

इसे ऑनलाइन आज़माएं!

Comments

भाषा से परिचित नहीं - लेकिन Max[Apply@LCM/@IntegerPartitions@#]&यह मेरे लिए काम करता है और अगर यह सही है तो 36 बाइट देगा।

— डैनियल शेपलर

@DanielSchepler हाँ, सुपर! आप इसे एक अलग समाधान के रूप में क्यों प्रस्तावित नहीं करते हैं? तुम भी कर सकते हैं Max[LCM@@@IntegerPartitions@#]&के लिए 31 बाइट्स , क्योंकि @@@करता Applyस्तर 1. पर

— रोमन

Answer 3

पायथन , 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])

इसे ऑनलाइन आज़माएं!

एक पुनरावर्ती कार्य जो बचे nहुए विभाजन और चल रहे LCM को ट्रैक करता है d। ध्यान दें कि इसका मतलब है कि हमें विभाजन में वास्तविक संख्याओं को ट्रैक करने की आवश्यकता नहीं है या उनमें से कितने का हमने उपयोग किया है। हम हर संभव अगले भाग की कोशिश करते हैं n-m, जो nबचा है m, और उसके dसाथ बदल रहा है lcm(d,n-m)। हम उन पुनरावर्ती परिणामों का अधिकतम लाभ उठाते हैं d। जब कुछ भी नहीं रहता है n=0, तो परिणाम केवल ist होता हैd ।

मुश्किल बात यह है कि पायथन के पास एलसीएम, जीसीडी या प्राइम फैक्टराइजेशन के लिए कोई बिल्ट-इन नहीं है। ऐसा करने के लिए lcm(d,m-n), हम के गुणकों की एक सूची उत्पन्न d, और मूल्य कम से कम सापेक्ष प्राप्त लेने के n-mसाथ यह है कि, key=(n-m).__rmod__। चूंकि minटाई के मामले में पहले का मूल्य देगा, इसलिए यह हमेशा का पहला नॉनजेरो मल्टिपल dहै n-m, जिसके द्वारा विभाज्य है , इसलिए उनका एलसीएम। हम केवल के गुणकों dअप करने के लिए d*(n-m)एलसीएम हिट करने के लिए गारंटी करने के लिए किया जाएगा, लेकिन यह लिखने के लिए छोटा है d<<n(जो d*2**n) जो अजगर की ऊपरी सीमा अनन्य होने के साथ पर्याप्त होता।

पायथन 3 की mathलाइब्रेरी में 3.5 के बाद gcd(लेकिन नहीं lcm) है, जो कुछ बाइट्स से कम है। आयात को छोटा करने के लिए @Joel को धन्यवाद।

पायथन 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की lcmअभी तक कम है।

अजगर, सुन्न के साथ , 77 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

उपयोग करना from math import*85 बाइट्स है और import math+ math.gcd(...)का उपयोग करना 84 बाइट्स है। वही लागू होता है numpy।

— जोएल

@Joel धन्यवाद, मैं इसके बारे में भूल गया।

— xnor

@ जॉयल थैंक्स, मैं बाइट काउंट अपडेट करना भूल गया था, वे दोनों 77 हैं। numpy5 की लंबाई ब्रेक-ईवन बिंदु है import*।

— xnor

सही। उस स्थिति में मैं उपयोग करना पसंद करता हूं import numpyक्योंकि यदि उपयोग किया जाता है तो numpy.maxपायथन के बिल्ट-इन max(उसी के लिए min) को ओवरराइड करेगा from numpy import*। यह यहां समस्याओं का कारण नहीं है, लेकिन हम सभी जानते हैं कि import*सामान्य रूप से एक अच्छा प्रोग्रामिंग अभ्यास नहीं है।

— जोएल

@Joel जबकि import*कोई संदेह नहीं है बुरा व्यवहार है, मैं यह वास्तव में पायथन के अधिलेखित कर देता है नहीं लगता है minऔर max, इसलिए भ्रम की स्थिति किसी numpy के समारोह की उम्मीद है और आधार एक हो रही होगी।

— xnor

Answer 4

हास्केल , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

जेली , 7 बाइट्स

Œṗæl/€Ṁ

इसे ऑनलाइन आज़माएं!

एक विवादास्पद लिंक एक पूर्णांक को अपने तर्क के रूप में लेता है और एक पूर्णांक लौटाता है।

व्याख्या

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

Answer 6

जावास्क्रिप्ट (ईएस 6), 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

इसे ऑनलाइन आज़माएं!

---

जावास्क्रिप्ट (ईएस 6), 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)

इसे ऑनलाइन आज़माएं!

कैसे?

हम परिभाषित करते हैं:

$$\cases{ g(1)=0\\ g(n)=\sum_{j=1}^{N}{p_j}^{k_j}\quad\text{for}\enspace n>1\enspace\text{and}\enspace n=\prod_{j=1}^{N}{p_j}^{k_j} }$$

(यह A008475 है )

तब हम सूत्र का उपयोग करते हैं ( A000793 से ):

$$f(n)=\max_{g(k)\le n}k$$

Answer 7

पर्ल 6 , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सीधे @ histocrat के रूबी समाधान की तरह सभी क्रमपरिवर्तन की जाँच करता है।

व्याख्या

                                     &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 अलग-अलग मदों के किसी भी क्रम का उपयोग कर सकते हैं, इसलिए हम बस क्रमपरिवर्तन लेते हैं।

² यदि समापन बिंदु एक कंटेनर है, तो ...अनुक्रम ऑपरेटर पहले आइटम के खिलाफ स्मार्टमैच करता है। इसलिए हमें एकल-तत्व सूची पास करनी होगी।

Answer 8

रूबी , 77 बाइट्स

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

इसे ऑनलाइन आज़माएं!

(1..) अनंत रेंज सिंटैक्स TIO के लिए बहुत नया है, इसलिए लिंक एक मनमाना ऊपरी सीमा निर्धारित करता है।

यह प्रत्यक्ष परिभाषा का उपयोग करता है - सभी संभव क्रमपरिवर्तन की गणना करें, तब aतक हर एक का परीक्षण करें जब तक कि यह अपनी मूल स्थिति में वापस नहीं आता है (जिसका अर्थ है कि मैं आसानी से प्रत्येक लूप में मूल सरणी को बदल सकता हूं)।

Answer 9

गैया , २५ २३ २२ बाइट्स

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

इसे ऑनलाइन आज़माएं!

LCM या पूर्णांक विभाजन नहीं होने से यह दृष्टिकोण लंबा हो जाता है।

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


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

Answer 10

हास्केल, 70 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: -3 बाइट्स @xnor के लिए धन्यवाद।

Comments

मुझे लगता है कि इसे करने के लिए काम करना चाहिए mapM(:[1..n]), क्योंकि अतिरिक्त तत्व हानिरहित है।

— xnor

Answer 11

पायथन 3 + सुन्न, 115 102 99 बाइट्स

-13 बाइट्स @ डैनियल शेलर को धन्यवाद

@ डैनियल शेलर से -3 अधिक बाइट्स

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 वाले को चुनें।

Comments

संयोग से, मेरे पास पायथन 3 + संख्यात्मक समाधान 87 बाइट्स चल रहा है।

— डैनियल शेपलर

मुझे यह पता करने के लिए पर्याप्त पर्याप्त नहीं है कि ऐसा कैसे किया जाए, इसलिए मेरा सुझाव है कि आप अपना समाधान अलग से पोस्ट करें।

— Hiatsu

खैर, मैं इसे पोस्ट करने के लिए थोड़ी देर इंतजार करने की योजना बना रहा था।

— डैनियल स्कीपर

मुझे सिर्फ एहसास हुआ कि आपने इस चुनौती को पोस्ट किया है। क्षमा करें, मैं अपना सर्वश्रेष्ठ करूंगा।

— Hiatsu

आप को बदलते हैं c: एक सेट लौट सकते हैं और memoize यह सब पर बुरी तरह से नहीं करता है (हालांकि बेशक यह ungolf थोड़ा करता है) tio.run/##RY1BCsIwEEX3PUWWM1CLoiuhV/AKEsfUTkkmIU3AWnr2Ggvq7vM@//...

— डैनियल Schepler

Answer 12

पायथ , 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 बाइट्स: ध्यान दिया और देखा कि पायथ वास्तव में एक जीसीडी बिलिन ( i) है।