Định nghĩa

• Một hình vuông hoàn hảo là một số nguyên có thể được biểu thị bằng hình vuông của một số nguyên khác. Ví dụ, 36là một hình vuông hoàn hảo bởi vì 6^2 = 36.
• Một số squarefree là một số nguyên không chia hết cho bất kỳ vuông hoàn hảo, ngoại trừ 1. Ví dụ, 10là một số vuông. Tuy nhiên, 12không phải là một số vuông, bởi vì 12chia hết cho 4và 4là một hình vuông hoàn hảo.

Bài tập

Cho một số nguyên dương n, xuất ra số không vuông lớn nhất sẽ chia n.

Tủ thử

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

Chấm điểm

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Tiêu chuẩn áp dụng.

Tài liệu tham khảo

• OEIS A007947

05AB1E , 2 byte

fP

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Brachylog , 3 byte

ḋd×

Hãy thử trực tuyến!

Một câu trả lời rất độc đáo ...

Giải trình

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

JavaScript (ES6), 55 54 50 46 byte

Trích dẫn OEIS :
a (n) là ước số nhỏ nhất của n sao cho n chia u ^ n

Cập nhật triển khai:
a (n) là ước số u nhỏ nhất của n số nguyên dương u sao cho n chia 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 byte

2 byte được lưu với sự trợ giúp từ @LeakyNun

Yfup

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào 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

Thạch , 4 byte

ÆfQP

Hãy thử trực tuyến!

Æ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 byte

rimf_&:*

^{Tại sao mọi hoạt động trong chương trình này phải là 2 byte -_-}

Hãy thử trực tuyến!

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

Võng mạc , 36 30 28 byte

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

Đầu vào và đầu ra trong unary .

Hãy thử trực tuyến! (Bao gồm một tiêu đề và chân trang cho số thập phân <-> chuyển đổi đơn nguyên và để chạy nhiều trường hợp thử nghiệm cùng một lúc.)

Giải trình

Ý tưởng là để phù hợp với đầu vào như một số lần nhân một số yếu tố. Regex cơ bản để khớp một hình vuông sử dụng tham chiếu chuyển tiếp để khớp tổng các số nguyên lẻ liên tiếp:

(^1|11\1)+$

Vì chúng tôi không muốn khớp các hình vuông hoàn hảo, nhưng các số chia hết cho một hình vuông, chúng tôi thay thế nó 1bằng một phản hồi chính:

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

Vì vậy, bây giờ nhóm bên ngoài 1sẽ được sử dụng n lần trong đó n ² là hình vuông lớn nhất phân chia đầu vào và nhóm 2lưu trữ các yếu tố còn lại. Điều chúng ta muốn là chia số nguyên cho n để loại bỏ hình vuông. Kết quả có thể được biểu thị bằng số lần lặp của nhóm 1lần nhóm 2, nhưng điều này hơi khó thực hiện. Retina $*có thể sẽ sớm được cải thiện để lấy mã thông báo không có ký tự làm đối số bên phải của nó trong trường hợp chúng ta có thể đơn giản thay thế nó bằng $#1$*$2, nhưng điều đó vẫn chưa hoạt động.

Thay vào đó, chúng tôi phân tách các số lẻ khác nhau. Chúng ta hãy quay trở lại ví dụ đơn giản hơn về việc khớp các ô vuông hoàn hảo với (^1|11\1)+$. Thay vì có một bộ đếm \1được khởi tạo thành 1 và tăng thêm 2 trên mỗi lần lặp, chúng ta sẽ có hai bộ đếm. Một được khởi tạo thành 0 và một được khởi tạo thành 1 và cả hai đều tăng 1 trên mỗi lần lặp. Vì vậy, về cơ bản chúng tôi đã phân tách các số lẻ 2n + 1 thành (n) + (n + 1) . Lợi ích là chúng tôi sẽ kết thúc với n trong một trong các nhóm. Ở dạng đơn giản nhất, nó trông như thế này:

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

Trong trường hợp \2là n và \3là n + 1 . Tuy nhiên, chúng ta có thể làm điều này hiệu quả hơn một chút bằng cách nhận thấy rằng n + 1 của một lần lặp bằng với n của lần lặp tiếp theo, vì vậy chúng ta có thể lưu vào 1đây:

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

Bây giờ chúng ta chỉ cần quay lại sử dụng một yếu tố ban đầu thay vì 1khớp các đầu vào được chia cho một hình vuông hoàn hảo:

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

Bây giờ tất cả những gì chúng ta cần làm là thay thế toàn bộ điều này bằng $3ở cuối, nơi lưu trữ hệ số ban đầu nhân với số bước, làm giảm một yếu tố của hình vuông khỏi đầu vào.

Điều này được thực hiện lặp đi lặp lại +ngay từ đầu chương trình, để tính đến các yếu tố đầu vào có sức mạnh cao hơn bình phương.

Octave, 27 byte

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

Cách tiếp cận tương tự như các câu trả lời khác. Sự khác biệt là: Các chức năng có tên dài hơn nhiều. Tôi tin rằng mã giải thích chính nó thực sự: Đưa ra prodcác uniquesố nguyên tố factorcủa một số.

Ngôn ngữ Wolfram, 29 28 byte

-1 Cảm ơn @Martin Ender ♦

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

Giải trình:

           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 byte

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

Hãy thử trực tuyến!

Số chia vuông góc lớn nhất nlà số nhỏ nhất rvới tất cả các thừa số nnguyên tố. Chúng ta có thể kiểm tra điều này vì r**n%n==0, r**ntạo các nbản sao của từng yếu tố chính rvà chỉ chia hết nnếu mỗi nyếu tố chính được biểu diễn.

Các 1>>r**n%n này tương đương với int(r**n%n==0). Nếu Truecó thể được sử dụng đầu ra 1, thì ngắn hơn 2 byte.

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

Toán học , 40 byte

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

Hãy thử trực tuyến!

Alice , 4 byte

iDo@

Hãy thử trực tuyến!

Đầu vào và đầu ra được đưa ra dưới dạng điểm mã của một ký tự (hoạt động cho tất cả các điểm mã Unicode hợp lệ).

Giải trình

Chà, Alice có tích hợp sẵn Dvới định nghĩa là "Các yếu tố chính không trùng lặp". Nghĩa là, miễn là một giá trị chia hết cho một số p ² cho một số nguyên tố p , chia giá trị đó cho p . Điều này xảy ra chính xác là chức năng cần thiết trong thử thách này. Phần còn lại chỉ là đầu vào, đầu ra, chấm dứt chương trình.

Lý do điều này đã được thêm vào Alice thực sự không liên quan gì đến chuỗi số nguyên này. Tôi đã cố gắng bám sát chủ đề liên kết các ước số với các chuỗi con và các thừa số nguyên tố với các ký tự. Và tôi cần một hàm đi kèm với "các ký tự lặp lại" (nói chung hữu ích hơn nhiều, vì nó cho phép bạn coi các chuỗi là các tập hợp, đặc biệt là khi được sử dụng cùng với các toán tử đa biến khác nhau).

Haskell , 31 byte

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

Hãy thử trực tuyến!

Pyke , 3 byte

P}B

Hãy thử trực tuyến!

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

Prolog (SWI) , 84 39 byte

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

Hãy thử trực tuyến!

Điều chỉnh ý tưởng của câu trả lời Haskell của @ xnor cho Prolog.

PHP, 70 byte

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

Hãy thử trực tuyến!

Bình thường, 8 6 byte

*F+1{P

* -2 byte nhờ @LeakyNun

Sẽ là 3 nếu Pyth tích hợp sẵn các sản phẩm của danh sách ...

Thử nó!

*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 byte

Cảm ơn @ rjan Johansen vì đã loại bỏ nhu cầu r. Nhờ điều này và một số thủ thuật bẩn thỉu khác, tôi đã có thể giảm 15 byte!

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

whileđã biến mất và thay thế bằng ||và chỉ số twiddling. <=nên đã được <tất cả cùng.

<=chuyển sang <bằng cách di chuyển gia số để có được n%(++d*d)(nên được xác định rõ do ưu tiên toán tử).

Mã gốc:

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

Tiên đề, 89 byte

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

kiểm tra và kết quả

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

đây là hàm không sử dụng nhân tố ()

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)

nhưng nó chỉ có 125 byte

R, 52 byte

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

đọc ntừ stdin. Yêu cầu gmpthư viện phải được cài đặt (vì vậy TIO sẽ không hoạt động). Sử dụng cách tiếp cận giống như nhiều câu trả lời ở trên, nhưng nó gặp sự cố với đầu vào 1, bởi vì factorize(1)trả về một vectơ trống của lớp bigz, bị treo unique, than ôi.

Trên thực tế , 2 byte

yπ

Hãy thử trực tuyến!

Giải trình:

yπ
y   prime divisors
 π  product

Pari / GP , 28 byte

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

Hãy thử trực tuyến!

Pyt , 3 byte

←ϼΠ

Giải trình:

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