Визначення

• Ідеальний квадрат представляє собою ціле число , яке може бути виражено як квадрат іншого цілого числа. Наприклад, 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.

Брахілог , 3 байти

ḋd×

Спробуйте в Інтернеті!

Дуже оригінальна відповідь ...

Пояснення

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

JavaScript (ES6), 55 54 50 46 байт

Цитуючи OEIS :
a (n) - найменший дільник u з n, такий, що n ділить u ^ n

Оновлена ​​реалізація:
a (n) - найменший дільник u на n додатного цілого числа 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 байти

2 байти збережено за допомогою @LeakyNun

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, щоб видалити квадрат. Результат можна виразити як кількість повторень групової групи 1часу 2, але це зробити трохи непросто. Retina - х $*, ймовірно , скоро буде покращено , щоб взяти несімвольний маркер в його правий аргумент в цьому випадку ми могли б просто замінити це $#1$*$2, але поки не працює.

Натомість ми розкладаємо непарні числа по-різному. Повернемося до більш простого прикладу відповідності ідеальних квадратів (^1|11\1)+$. Замість того, щоб мати лічильник, \1який ініціалізується на 1 і збільшується на 2 на кожній ітерації, у нас буде два лічильника. Один ініціалізується на 0, а один ініціалізується на 1 , і обидва вони збільшуються на 1 на кожній ітерації. Отже, ми в основному розклали непарні числа 2n + 1 на (n) + (n + 1) . Перевага полягає в тому , що ми в кінцевому підсумку з п в одній з груп. У своєму найпростішому вигляді це виглядає так:

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

Там , де \2це п і \3є п + 1 . Тим НЕ менше, ми можемо зробити це трохи більш ефективно, помітивши , що п + 1 однієї ітерації дорівнює п наступної ітерації, так що ми можемо заощадити на 1тут:

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

Тепер нам просто потрібно повернутися до використання початкового коефіцієнта, а не 1для введення даних, розділених ідеальним квадратом:

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

Тепер все, що нам потрібно зробити, це замінити всю цю річ $3 на кінець, який зберігає початковий коефіцієнт, менший за кількість кроків, який випадає з введення одного фактора квадрата.

Це робиться неодноразово +на початку програми для врахування входів, що містять більші потужності, ніж квадрати.

Октава, 27 байт

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

Аналогічний підхід, як і інші відповіді. Різниця полягає в тому, що функції мають набагато довші назви. Я вважаю, що код пояснює себе справді: Бере prodукт uniqueпросте factorчисло числа.

Мова Вольфрама, 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*)

Пітон , 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 . Це буває саме тією функцією, яка вимагається в цьому виклику. Решта - лише введення, вихід, завершення програми.

Причина, яку це додали до Аліси, насправді не має нічого спільного з цілою цілою послідовністю. Я намагався дотримуватися теми асоціації дільників з підрядками та простими факторами з символами. І мені була потрібна функція, яка поєднується з "подвійними символами" (що набагато корисніше загалом, тому що вона дозволяє вам трактувати рядки як набори, особливо якщо вони використовуються разом з різними операторами мультисети).

Haskell, 31 bytes

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

Try it online!

Pyke, 3 bytes

P}B

Try it online!

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

Prolog (SWI), 84 39 bytes

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

Try it online!

Adapted the idea of @xnor's Haskell answer to Prolog.

PHP, 70 Bytes

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

Try it online!

Pyth, 8 6 bytes

*F+1{P

*-2 bytes thanks to @LeakyNun

Would be 3 if Pyth had a built-in for products of lists...

Try it!

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

Thanks to @Ørjan Johansen for removing the need for r. Thanks to this and some other dirty tricks I was able to squeeze 15 bytes off!

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

while is gone and replaced with || and index twiddling. <= should have been < all along.

<= turned to < by moving the increment to get n%(++d*d) (should be well defined due to operator precedence).

Original code:

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

Axiom, 89 bytes

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

test and results

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

this is the one not use factor() function

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)

but it is only 125 bytes

R, 52 bytes

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

reads n from stdin. Requires the gmp library to be installed (so TIO won't work). Uses the same approach as many of the above answers, but it crashes on an input of 1, because factorize(1) returns an empty vector of class bigz, which crashes unique, alas.

Actually, 2 bytes

yπ

Try it online!

Explanation:

yπ
y   prime divisors
 π  product

Pari/GP, 28 bytes

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

Try it online!

Pyt, 3 bytes

←ϼΠ

Explanation:

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