定義

• 完全な正方形は、別の整数の二乗として表すことができる整数です。たとえば、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

得点

これはcode-golfです。バイト単位の最短回答が優先されます。

標準の抜け穴が適用されます。

参照

• 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：
（n）は、NようにN分割U ^ n個の最小の約数であるU

更新された実装：
a（n）は、nがu ^ nを除算するn個の正の整数uの最小除数u

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

単項の入出力。

オンラインでお試しください！（10進数<->単項変換用のヘッダーとフッターを含み、複数のテストケースを一度に実行します。）

説明

アイデアは、入力を2乗倍して何らかの係数として一致させることです。正方形を照合するための基本的な正規表現は、前方参照を使用して、連続する奇数の整数の合計を照合します。

(^1|11\1)+$

完全な正方形に一致するのではなく、正方形で割り切れる数値に一致させたくないので、それを1後方参照自体に置き換えます。

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

今外基が1使用されるN場合回N ^2を入力し、グループ分割最大正方形で2格納し、残りの因子。必要なのは、整数をnで除算して正方形を削除することです。結果は、グループの反復の数として表すことができる1回群2が、これは実行するのが難しいビットです。Retina $*は、おそらくすぐに改善され、文字以外のトークンを右辺の引数として使用するようになります。この場合、これを単にに置き換えることができます$#1$*$2が、まだ機能しません。

代わりに、奇数を異なる方法で分解します。で完全な正方形を照合するより単純な例に戻りましょう(^1|11\1)+$。1に\1初期化され、各反復で2ずつ増加するカウンターを持つ代わりに、2つのカウンターがあります。1つは0に初期化され、もう1つは1に初期化されます。両方とも、反復ごとに1ずつ増加します。したがって、基本的に奇数2n + 1を（n）+（n + 1）に分解しました。利点は、いずれかのグループにnが追加されることです。最も単純な形式では、次のようになります。

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

どこ\2でNと\3であるN + 1。ただし、1つの反復のn + 1が次の反復のnと等しいことに注意することで、これをもう少し効率的に行うことができ1ます。

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

ここで1、完全な正方形で除算された入力を一致させるのではなく、初期係数を使用することに戻る必要があります。

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

ここで必要なのは、この$3要素全体を最後に置き換えることです。これは、初期係数にステップ数を掛けたものを格納し、入力から正方形の1つの係数を削除します。

これは+、プログラムの最初の段階で繰り返し実行され、平方よりも高いパワーを含む入力を考慮します。

オクターブ、27バイト

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

他の回答と同様のアプローチ。違いは次のとおりです。関数にはもっと長い名前があります。私はコードがそれ自体を本当に説明すると信じています：数の素数のproductを取ります。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最小数です。の各素因数のコピーを作成し、の各素因数が表されている場合にのみ割り切れるため、これをとして確認できます。rnr**n%n==0r**nnrnn

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。これはたまたまこの課題で必要な機能です。残りは入力、出力、プログラムの終了のみです。

これがアリスに追加された理由は、実際にはこの整数シーケンスとは関係ありません。除数を部分文字列に、素因数を文字に関連付けるというテーマに固執しようとしていました。また、「重複排除文字」に対応する関数が必要でした（特にさまざまなマルチセット演算子と組み合わせて使用​​する場合、文字列をセットとして扱うことができるため、一般的にはるかに便利です）。

Haskell、31バイト

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

オンラインでお試しください！

Pyke、3バイト

P}B

オンラインでお試しください！

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

プロローグ（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

* @LeakyNunのおかげで2バイト

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

nstdinから読み取ります。gmpライブラリをインストールする必要があります（したがって、TIOは機能しません）。上記回答の多くのと同じアプローチを使用するが、それはの入力にクラッシュする1ので、factorize(1)クラスの戻り空ベクターbigzクラッシュ、unique、ああを。

実際には、2バイト

yπ

オンラインでお試しください！

説明：

yπ
y   prime divisors
 π  product

パリ/ GP、28バイト

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

オンラインでお試しください！

Pyt、3バイト

←ϼΠ

説明：

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