有时在数学问题或谜语中会出现一个相当奇怪的数字。伪因子（N）是数字1到N的最小（即最低）公倍数；换句话说，它是最低的数字，其中包含从1到N的所有数字。

例如pseudofactorial（7）= 3 * 4 * 5 * 7，与7相同！除了2和6已删除，因为它们包含在其他术语中。

编写一个程序来计算pseudofactorial（N），并且一如既往地以最短的代码为准。

这是供您使用的简短列表。可以在OEIS中的A003418下找到更多测试用例。

阶乘：

1. 1个
2. 2
3. 6
4. 24
5. 120
6. 720
7. 5040

伪因子：

1. 1个
2. 2
3. 6
4. 12
5. 60
6. 60
7. 420

Dyalog APL，3个字节

∧/⍳

APL击败果冻 ‽

⍳ 1尽管自变量

∧/ 跨LCM

果冻，4 字节

Ræl/

在线尝试！或验证所有测试用例。

这个怎么运作

Ræl/  Main link. Input: n

R     Range; yield [1, ..., n].
   /  Reduce the range...
 æl     by LCM.

C（x86），52个字节

d(n,k,b,t){for(b=k=1;b;++k)for(t=n,b=0;t;b+=k%t--);}

从1开始检查数字。对于每个数字，将其除以从n到1的所有数字，然后将余数相加。总和为0时停止。

用法：

main()
{
    printf("%d\n", d(7)); // outputs 420
}

它如何返回值（没有return语句）并不明显。

x86的调用约定表示该函数必须在eax寄存器中返回其值。方便地，除法指令idiv期望在中输入eax，并在eax（商）和edx（余数）中输出结果。最后的迭代分裂k的1，所以eax将包含正确的价值函数退出的时候。

这仅适用于的优化（在调试模式下，输出421）。

Haskell，20个字节

f x=foldr1 lcm[1..x]

用法示例：map f [1..7]-> [1,2,6,12,60,60,420]。

的 lcmHaskell把戏。

Python + SymPy，45个字节

import sympy
lambda n:sympy.lcm(range(1,n+1))

相当不言自明。

Python 2，57 54字节

i=r=input();exec't=r\nwhile r%i:r+=t\ni-=1;'*r;print r

在Ideone上测试。

这个怎么运作

输入存储在变量i和r中。

exec执行以下代码r次。

t=r
while r%i:r+=t
i-=1

当i从r变为1时，我们将r的初始值（存储在t中）加到r本身所需的次数上，以创建i的倍数。结果显然是t的倍数。

r的最终值因此是[1，...，n]范围内所有整数的倍数，其中n是输入。

Python，46个字节

g=lambda n,c=0:n<1or(c%n<1)*c or g(n,c+g(n-1))

寻找多c的g(n-1)直接。我之前曾有过这种方法会错误地将0查找为任何东西的倍数，但是由于0为Falsey，因此or短路或(c%n<1)*c也会跳过c==0。

50个字节：

g=lambda n,i=1:n<1or(i*n%g(n-1)<1)*i*n or g(n,i+1)

类似于Dennis的解决方案，但作为递归函数。有计算g(n-1)，外观为最小倍数i*n的n这也是倍数g(n-1)。真的很慢

感谢Dennis通过查看n而不是的倍数获得了4个字节g(n-1)。

J，9个字节

[:*./1+i.

直截了当的方法。创建数字范围[0, ..., n-1]，然后将每个，然后使用LCM对其进行缩减。

用法

   f =: [:*./1+i.
   f 7
420

MATL，4个字节

:&Zm

在线尝试！

说明

:      % Take input N implicitly. Generate range [1 2 ... N]
&Zm    % LCM of the numbers in that array. Display implicitly

Mathematica，13个字节

LCM@@Range@#&

朱莉娅，11个字节

!n=lcm(1:n)

在线尝试！

Pyth-8个字节

检查所有数字，直到找到可被整除的数字[1..N]。

f!s%LTSQ

测试套件。

八度，27字节

@(x)lcm(1,num2cell(1:x){:})

创建一个可以作为调用的匿名函数ans(N)。

在线演示

说明

该解决方案产生的所有数字之间的列表1和x（1:x它们），转换成与单元阵列num2cell。然后，{:}索引创建一个逗号分隔列表，该列表lcm作为多个输入参数传递给该列表，以计算最小公倍数。lcm因为lcm始终需要至少两个输入参数，所以始终将1作为第一个参数传递。

MATLAB，49字节

@(x)find(~any(bsxfun(@rem,1:prod(1:x),(1:x)')),1)

Perl 6、13个字节

{[lcm] 1..$_}

匿名代码块创建一个从1到输入（包括）的范围，然后使用 &infix:<lcm>。

例：

#! /usr/bin/env perl6
use v6.c;

my &postfix:<p!> = {[lcm] 1..$_}

say 1p!; # 1
say 2p!; # 2
say 3p!; # 6
say 4p!; # 12
say 5p!; # 60
say 6p!; # 60
say 7p!; # 420

say 10000p!; # 5793339670287642968692270879...
# the result from this is 4349 digits long

JavaScript（ES6），92 88 80 74 69字节：

谢谢@ConorOBrien和@Neil

y=>(g=(a,b)=>b?g(b,a%b):a,[...Array(y)].map((_,i)=>y=y*++i/g(y,i)),y)

05AB1E，20字节

Lpvyi¹LÒN>¢àN>*ˆ}}¯P

说明

Lpv                    # for each item in isprime(range(1,N)): N=7 -> [0,1,1,0,1,0,1]
   yi                  # if prime
     ¹LÒN>¢            # count occurrences of the prime 
                         in the prime-factorization of range(1,N):
                         p=2 -> [0,1,0,2,0,1,0]
           àN>*ˆ       # add max occurrence of that prime multiplied by the prime 
                         to global array: N=7 -> [4,3,5,7]
                }}     # end if/loop
                  ¯P   # get product of global array

在线尝试

Minkolang 0.15，12个字节

我有两个 12字节的解决方案，并且都包括了它们。

1n[i1+4$M]N.

在这里尝试！

说明

1               Push 1
 n              Take number from input
  [             For loop that repeats n times
   i1+          Push loop counter + 1
      4$M       Pop b, a and push lcm(a,b)
         ]      Close for loop
          N.    Output as number and stop.

尽可能简单。

11nLd[4$M]N.

在这里尝试！

说明

11              Push two 1s
  n             Take number from input
   L            Pop b, a and push range from a to b, inclusive
    d           Duplicate top of stack (n)
     [4$M]      Pop b, a and push lcm(a,b), n times
          N.    Output as number and stop.

由此可以得出第三个解决方案：删除a 1并d在current之后添加a d。在这两种情况下，都需要额外的数字，因为for循环运行太多次，而使其运行时间减少了两个字节（1-恰好在之前[）。

Ruby，25个字节

g=->n{(1..n).reduce :lcm}

Ruby，25个字节

g=->n{n<1?1:a[n-1].lcm n}

GameMaker语言，60字节

for(b=k=1;b;++k){b=0for(t=argument0;t;b+=k mod t--)}return k

基于anatolyg答案的逻辑。

PHP，61 52 48字节

@ user59178节省了9个字节，通过合并循环节省了4个字节。

由于function关键字的存在，PHP中的递归非常繁琐。所以我使用迭代。
并以一些“小”技巧，我现在甚至击败了Arnauld的JS。

while(++$k%++$i?$i>$argv[1]?0:$i=1:$k--);echo$k;

从命令行参数获取输入。用运行-r。

分解

while(++$k%++$i?    # loop $i up; if it does not divide $k
    $i>$argv[1]?0       # break if $i (smallest non-divisor of $k) is larger than input
    :$i=1               # while not, reset $i and continue loop with incremented $k
    :$k--);         # undo increment while $i divides $k
echo$k;         # print $k

不打高尔夫球

实际上这是两个循环：

while($i<=$argv[1]) # loop while $i (smallest non-divisor of $k) is not larger than input
    for($k++,       # loop $k up from 1
        $i=0;$k%++$i<1;);   # loop $i up from 1 while it divides $k
echo$k;             # print $k

注意：复制自我的答案

AWK，42个字节

{for(x=n=1;n<=$1;)if(x%n++){x++;n=1}$0=x}1

命令行用法：

awk '{for(x=n=2;n<=$1;)if(x%n++){x++;n=2}$0=x}1' <<< NUM

我没有看到一个AWK解决方案，并且昨天刚发布了一个重复的问题，所以我认为我应该把它放在一起。19在我的盒子上或更大的盒子上求解起来相当慢，但它可以工作。

Japt，10个字节

没有内置的LCM。

@õ e!vX}a1

试试吧

Pyke，3个字节，无竞争

S.L

在这里尝试！

S   - range(1, input+1)
 .L - lowest_common_multiple(^)

Hoon，67个字节

|*
*
(roll (gulf 1 +<) |=({a/@ b/_1} (div (mul a b) d:(egcd a b))))

创建列表[1..n]，然后用lcm折叠在列表上。不幸的是，Hoon stdlib没有一个我可以使用的预构建版本：/

𝔼𝕊𝕄𝕚𝕟，7个字符/ 9个字节

Мū…⩤⁽1ï

Try it here (ES6 only).

仅LCM包含从1到输入的范围。

QBIC，35 32字节

这把我带到这里。

:{p=0[a|~q%b|p=1]]~p=0|_Xq\q=q+1

说明：

:        Get cmd line param as number 'a'
{        Start an infinite DO loop
p=0      Sets a flag that shows if divisions failed
[a|      FOR (b=1; b<=a; b++)
~q%b     IF 'q' (which starts at 1 in QBIC) is not cleanly divisible by 'b'
|p=1     THEN Set the flag
]]   Close the FOR loop and the IF, leave the DO open
~p=0     IF 'q' didn't get flagged
|_Xq     THEN quit, printing 'q'
\q=q+1   ELSE raise 'q', redo
         [DO Loop implicitly closed by QBIC]

这是一个q在b没有明确划分时会停止测试的版本。此外，测试顺序b的反对q在假设相反，较高b的将是难以除以（取2，3，4例如：如果%2=0，%4可能!0，反之没有那么多...）。

:{p=0[a,2,-1|~q%b|p=1┘b=2]]~p=0|_Xq\q=q+1

公理，35字节

f(x)==reduce(lcm,[i for i in 1..x])

测试代码和结果

(25) -> [[i,f(i)] for i in [1,6,19,22,30]]
   (25)  [[1,1],[6,60],[19,232792560],[22,232792560],[30,2329089562800]]
                                                  Type: List List Integer

我只是提出寻找最小正整数的解决方案， 该整数具有从1到n的所有整数作为因子，因为 您说它是重复的，所以我将其发布在这里

Pari / GP，14个字节

n->lcm([1..n])

在线尝试！

8th，23个字节

码

1 ' lcm rot 2 swap loop

该代码将结果伪伪数留在TOS上

用法和示例

ok> 7 1 ' lcm rot 2 swap loop .
420

或更清楚

ok> : pseudofact 1 ' n:lcm rot 2 swap loop ;

ok> 7 pseudofact .
420