定义

• 甲完全平方是可以被表示为正方形另一个整数的整数。例如，36是一个完美的正方形，因为6^2 = 36。
• 无平方数是一个整数，除之外，任何整数都不能将其整除1。例如，10是一个无平方数。但是，12不是自由平方数，因为12它可以被整除4并且4是一个完美的平方。

任务

给定一个正整数n，输出除的最大平方无数n。

测试用例

n   output
1   1
2   2
3   3
4   2
5   5
6   6
7   7
8   2
9   3
10  10
11  11
12  6
13  13
14  14
15  15
16  2
17  17
18  6
19  19
20  10
21  21
22  22
23  23
24  6
25  5
26  26
27  3
28  14
29  29
30  30
31  31
32  2
33  33
34  34
35  35
36  6
37  37
38  38
39  39
40  10
41  41
42  42
43  43
44  22
45  15
46  46
47  47
48  6
49  7
50  10

计分

这是代码高尔夫球。以字节为单位的最短答案将获胜。

有标准漏洞。

参考

• OEIS A007947

05AB1E，2个字节

fP

在线尝试！

这个怎么运作

f   Implicitly take input and compute the integer's unique prime factors.
 P  Take the product.

Brachylog，3个字节

ḋd×

在线尝试！

一个非常原始的答案...

说明

ḋ          Take the prime factors of the Input
 d         Remove duplicates
  ×        Multiply

JavaScript（ES6），55 54 50 46字节

引用OEIS：
a（n）是n的最小除数u，使得n除以u ^ n

更新的实现：
a（n）是n个正整数u 的最小除数u，使得n除以u ^ n

let f =

n=>(g=(p,i=n)=>i--?g(p*p%n,i):p?g(++u):u)(u=1)

for(n = 1; n <= 50; n++) {
  console.log(n,f(n));
}

MATL，6 4字节

在@LeakyNun的帮助下保存了2个字节

Yfup

在线尝试！

说明

考虑输入48。

Yf   % Implicit input. Push prime factors with repetitions.  STACK: [2 2 2 2 3]
u    % Unique.                                               STACK: [2 3]
p    % Product of array. Implicit display.                   STACK: 6

果冻，4字节

ÆfQP

在线尝试！

ÆfQP  Main link, argument is z
Æf    Takes the prime factors of z
  Q   Returns the unique elements of z
   P  Takes the product

CJam，8个字节

rimf_&:*

^{为什么该程序中的每个操作都必须为2个字节-_-}

在线尝试！

ri       e# Read int from input
  mf     e# Get the prime factors
    _&   e# Deduplicate
      :* e# Take the product of the list

视网膜，36 30 28字节

+`((^|\3)(^(1+?)|\3\4))+$
$3

一元的输入和输出。

在线尝试！（包括用于十进制<->一元转换的标头和页脚，并一次运行多个测试用例。）

说明

想法是将输入匹配为某个因子的平方。用于匹配正方形的基本正则表达式使用前向引用来匹配连续奇数整数的和：

(^1|11\1)+$

由于我们不希望匹配完美的正方形，而是要被正方形整除的数字，因此我们将其替换1为反向引用本身：

(^(1+?)|\1\2\2)+$

因此，现在1将使用外部组n次，其中n ²是划分输入的最大平方，并且组2存储剩余因子。我们想要的是将整数除以n以除去平方。结果可以表示为group 1times group 的迭代次数2，但这有点棘手。视网膜的视网膜$*可能很快会得到改进，以使用非字符标记作为其右手参数，在这种情况下，我们可以简单地将其替换为$#1$*$2，但这还行不通。

相反，我们以不同的方式分解奇数。让我们回到用匹配完美正方形的简单示例(^1|11\1)+$。我们将拥有两个计数器，而不是拥有一个\1初始化为1并在每次迭代时增加2的计数器。一个初始化为0，一个初始化为1，并且每次迭代它们都都增加1。因此，我们基本上已经将奇数2n + 1分解为（n）+（n + 1）。好处是我们将在其中一个组中得到n。最简单的形式如下：

((^|1\2)(^1|1\3))+$

哪里\2是ñ和\3为N + 1。然而，我们可以稍微更有效地通过注意到这样做N + 1一个迭代等于ñ下一个迭代的，所以我们可以节省一个1位置：

((^|\3)(^1|1\3))+$

现在，我们只需要返回到使用初始因子，而不是1匹配被完美平方除以的输入：

((^|\3)(^(1+?)|\3\4))+$

现在，我们需要做的是最后将整个东西替换$3为，它存储初始因子乘以步数，从输入中减去平方的一个因子。

+程序一开始就反复进行此操作，以计算输入功率包含比平方高的功率。

八度，27字节

@(x)prod(unique(factor(x)))

与其他答案类似的方法。区别在于：函数具有更长的名称。我相信代码可以真正说明自己：采用数字素数的prod引数。uniquefactor

Wolfram语言，29 28字节

-1感谢@Martin Ender♦

Most[1##&@@FactorInteger@#]&

说明：

           FactorInteger@#    (*Get prime factorization as {{a,b},{c,d}}*)
     1##&@@                   (*Multiply list elements together, to get the product of the factors and the product of their exponents*)
Most[                     ]&  (*Take the first element*)

Python，37个字节

f=lambda n,r=1:1>>r**n%n or-~f(n,r+1)

在线尝试！

最大的无平方除数n是r具有所有n素数的最小数。我们可以将其检查为r**n%n==0，因为r**n制作n的每个素因的副本r，并且n只有在每个n素因均被表示时才能被整除。

在1>>r**n%n相当于int(r**n%n==0)。如果True可以使用输出1，则需要少2个字节。

f=lambda n,r=1:r**n%n<1or-~f(n,r+1)

数学，40字节

Times@@(Transpose@FactorInteger@#)[[1]]&

在线尝试！

爱丽丝，4个字节

iDo@

在线尝试！

输入和输出作为字符的代码点给出（适用于所有有效的Unicode代码点）。

说明

好吧，爱丽丝有一个内置的组件，D其定义是“重复的主要因子”。也就是说，只要一个质数p的值可以被p ²整除，就可以将该值除以p。这恰好是此挑战所需的功能。其余的只是输入，输出，终止程序。

将其添加到Alice的原因实际上与该整数序列无关。我试图坚持将除数与子字符串和素数与字符相关联的主题。而且我需要一个与“重复字符”一起使用的函数（通常更有用，因为它使您可以将字符串视为集合，尤其是与各种多集运算符一起使用时）。

Haskell，31个字节

f n=until(\r->r^n`mod`n<1)(+1)1

在线尝试！

派克（Pyke），3个字节

P}B

在线尝试！

P   -   factors(input)
 }  -  uniquify(^)
  B - product(^)

Prolog（SWI），84 39字节

f(N,P):-between(1,N,P),P^N mod N=:=0,!.

在线尝试！

将@xnor的Haskell答案的想法改编为Prolog。

PHP，70字节

for($r=1,$i=2;1<$n=&$argn;)$n%$i?++$i:$n/=$i+!($r%$i?$r*=$i:1);echo$r;

在线尝试！

Pyth，8个 6字节

*F+1{P

* -2个字节，感谢@LeakyNun

如果Pyth内置列表产品将为3 ...

试试吧！

*F+1{P
      Q     # Implicit input
     P      # Prime factors of the input
    {       # Deduplicate
  +1        # Prepend 1 to the list (for the case Q==1)
*F          # Fold * over the list

C，65 50字节

感谢@ØrjanJohansen消除了对的需要r。由于这个和其他一些肮脏的技巧，我得以压缩15个字节！

d;f(n){for(d=1;d++<n;)n%(d*d)||(n/=d--);return n;}

while消失了，取而代之的是||索引扭曲。<=应该一直<。

<=转向<通过移动的增量来获得n%(++d*d)（应该是由于很好地定义运算符优先级）。

原始代码：

d;r;f(n){for(r=d=1;d++<=n;)while(n%d<1)r*=r%d?d:1,n/=d;return r;}

公理，89字节

f(x:PI):PI==(x=1=>1;g:=factor x;reduce(*,[nthFactor(g,i) for i in 1..numberOfFactors g]))

测试与结果

(38) -> [[i, f(i)] for i in 1..30 ]
   (38)
   [[1,1], [2,2], [3,3], [4,2], [5,5], [6,6], [7,7], [8,2], [9,3], [10,10],
    [11,11], [12,6], [13,13], [14,14], [15,15], [16,2], [17,17], [18,6],
    [19,19], [20,10], [21,21], [22,22], [23,23], [24,6], [25,5], [26,26],
    [27,3], [28,14], [29,29], [30,30]]

这是一个不使用factor（）函数的函数

g(x:PI):PI==(w:=sqrt(x);r:=i:=1;repeat(i:=i+1;i>w or x<2=>break;x rem i=0=>(r:=r*i;repeat(x rem i=0=>(x:=x quo i);break)));r)

但是只有125字节

R，52个字节

`if`((n=scan())<2,1,prod(unique(c(1,gmp::factorize(n))))

n从标准输入读取。需要gmp安装该库（因此TIO无法正常工作）。使用与上述许多答案相同的方法，但是1由于输入，它会崩溃，因为factorize(1)返回的是class的空向量bigz，崩溃unique，可惜。

实际上，2个字节

yπ

在线尝试！

说明：

yπ
y   prime divisors
 π  product

Pari / GP，28个字节

n->factorback(factor(n)[,1])

在线尝试！

Pyt，3个字节

←ϼΠ

说明：

←                  Get input
 ϼ                 Get list of unique prime factors
  Π                Compute product of list
                   Implicit print