计算Landau函数

19

Landau函数（OEIS A000793）给出对称组元素的最大阶数。在此，置换的顺序是最小的正整数，因此是恒等式-等于置换的循环分解中循环长度的最小公倍数。例如，，这是通过（1,2,3）（4,5,6,7）（8,9,10,11,12,13,14）实现的。 $g(n)$ $S_n$ $\pi$ $k$ $\pi^k$ $g(14) = 84$

因此， $g(n)$ 也等于 $\operatorname{lcm}(a_1, \ldots, a_k)$ 的最大值其中 $a_1 + \cdots + a_k = n$ 其中 $a_1, \ldots, a_k$ 正整数。

问题

编写一个计算Landau函数的函数或程序。

输入项

正整数 $n$ 。

输出量

$g(n)$ 是对称组 $S_n$ 元素的最大阶数。

例子

得分了

这是代码高尔夫球：以字节为单位的最短程序获胜。（不过，欢迎使用多种语言进行最短的实现。）

注意，对运行时没有任何要求。因此，您的实现不一定需要能够在任何合理的时间内生成所有上述示例结果。

禁止出现标准漏洞。

code-golf math arithmetic permutations integer-partitions

— 丹尼尔·谢普勒
source

Answers:

9

05AB1E，6个字节

Åœ€.¿Z

在线尝试！

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

— 肮脏的
source

10

Wolfram语言（Mathematica），44字节

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

在线尝试！

Wolfram语言（Mathematica），31个字节

@DanielSchepler有一个更好的解决方案：

Max[LCM@@@IntegerPartitions@#]&

在线尝试！

— 罗曼
source

不太熟悉该语言-但Max[Apply@LCM/@IntegerPartitions@#]&似乎对我有用，如果正确的话，会给出36个字节。

— Daniel Schepler

2

@DanielSchepler是的，超级！您为什么不建议将其作为单独的解决方案？你甚至可以Max[LCM@@@IntegerPartitions@#]&为31个字节，因为@@@确实Apply在1级

— 罗马

4

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

在线尝试！

一个递归函数，跟踪剩余n的分区和正在运行的LCM d。请注意，这意味着我们无需跟踪分区中的实际数字或已使用的数量。我们尝试每个可能的下一部分，分别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在平局时将给出较早的值，因此，这始终是该值的第一个非零倍数，因此可以将其LCM d整除n-m。我们d最多d*(n-m)只能保证达到LCM的倍数，但是编写起来更短d<<n（即d*2**n），这足以满足Python的上限要求。

Python 3的math库在3.5之后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的lcm时间更短。

带有numpy的 Python ，77个字节

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

在线尝试！

— 异或
source

使用from math import*是85个字节，使用import math+ math.gcd(...)是84个字节。同样适用于numpy。

— 乔尔

@Joel谢谢，我忘记了这一点。

— xnor

@Joel谢谢，我忘了更新的字节数，它们都是77 numpy的长度为5是盈亏平衡点的import*。

— xnor

对。在那种情况下，我更喜欢使用，import numpy因为numpy.max如果使用，它将覆盖Python的内置功能max（与相同min）from numpy import*。它不会在这里引起问题，但是我们都知道这import*通常不是一种好的编程习惯。

— 乔尔

@Joel虽然import*毫无疑问是一种不好的做法，但我认为它实际上不会覆盖Python的minand max，因此令人困惑的是有人期望numpy的功能并获得基本的功能。

— xnor

4

Haskell，44个字节

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

在线尝试！

— 异或
source

3

果冻，7个字节

Œṗæl/€Ṁ

在线尝试！

以整数为参数并返回整数的单子链接。

说明

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

— 尼克·肯尼迪
source

3

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)

在线尝试！

怎么样？

我们定义：

{\begin{cases} G （ 1个 ） = 0 \\ G （ ñ ） = \sum_{Ĵ = 1个}^{ñ} {p_{Ĵ}}^{ķ_{Ĵ}} 对于 ñ > 1个 和 ñ = \prod_{Ĵ = 1个}^{ñ} {p_{Ĵ}}^{ķ_{Ĵ}} \end{cases}

$\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 （ ñ ） = \underset{G （ ķ ） \leq ñ}{最高} ķ

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

— Arnauld
source

3

Perl 6，50个字节

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

在线尝试！

直接检查所有排列，例如@histocrat的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个不同项的任意序列进行检查，因此我们只需考虑排列本身。

²如果端点是容器，则...序列运算符将与第一项智能匹配。因此，我们必须传递一个单元素列表。

— 恩韦恩霍夫
source

2

Ruby，77个字节

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

在线尝试！

(1..) 无限范围语法对于TIO来说太新了，因此链接设置了一个任意上限。

这使用直接定义-枚举所有可能的排列，然后通过变异测试每个变异，a直到变异回到其原始位置（这也方便地意味着我可以在每个循环中变异原始数组）。

— 历史学家
source

2

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

— 朱塞佩
source

2

Haskell，70 67字节

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

在线尝试！

编辑：-3个字节，感谢@xnor。

— 妮米
source

我认为应该这样做mapM(:[1..n])，因为多余的元素是无害的。

— xnor

1

蟒3 + numpy的，115个 102 99字节

-13个字节，感谢@Daniel Shepler

@Daniel Shepler的-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的序列。

— atsu
source

顺便说一句，我有一个运行87字节的Python 3 + numpy解决方案。

— Daniel Schepler

我对numpy不太了解，所以我建议您单独发布解决方案。

— Hiatsu

好吧，我打算等待一段时间才能发布它。

— Daniel Schepler

我刚刚意识到您发布了这个挑战。对不起，我会努力的。

— Hiatsu

1

如果您更改c为返回一个集并记住它并不会做得不好（尽管可以承认它确实有点失误）：tio.run

— ##RY1BCsIwEEX3PUWWM1CLoiuhV

0

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）。

— ar4093
source

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.

Licensed under cc by-sa 3.0 with attribution required.