definizioni

• Un quadrato perfetto è un numero intero che può essere espresso come il quadrato di un altro numero intero. Ad esempio, 36è un quadrato perfetto perché 6^2 = 36.
• Un numero quadrato è un numero intero che non è divisibile per nessun quadrato perfetto, tranne che per 1. Ad esempio, 10è un numero quadrato. Tuttavia, 12non è un numero quadrato, perché 12è divisibile per 4ed 4è un quadrato perfetto.

Compito

Dato un numero intero positivo n, genera il numero quadrato più grande che divide n.

Casi test

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

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

Si applicano scappatoie standard .

Riferimento

• OEIS A007947

05AB1E , 2 byte

fP

Provalo online!

Come funziona

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

Brachylog , 3 byte

ḋd×

Provalo online!

Una risposta molto originale ...

Spiegazione

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

JavaScript (ES6), 55 54 50 46 byte

Citando OEIS :
a (n) è il divisore più piccolo u di n tale che n divide u ^ n

Implementazione aggiornata:
a (n) è il divisore più piccolo u di n intero positivo u tale che n divide 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 salvati con l'aiuto di @LeakyNun

Yfup

Provalo online!

Spiegazione

Considera l'input 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

Gelatina , 4 byte

ÆfQP

Provalo online!

Æ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_&:*

^{Perché ogni operazione in questo programma deve essere di 2 byte -_-}

Provalo online!

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

Retina , 36 30 28 byte

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

Input e output in unario .

Provalo online! (Include un'intestazione e un piè di pagina per la conversione decimale <-> unaria e per eseguire più casi di test contemporaneamente.)

Spiegazione

L'idea è di abbinare l'input come un quadrato per qualche fattore. La regex di base per la corrispondenza di un quadrato utilizza un riferimento in avanti per abbinare somme di numeri dispari consecutivi:

(^1|11\1)+$

Dal momento che non vogliamo abbinare i quadrati perfetti, ma i numeri che sono divisibili per un quadrato, lo sostituiamo 1con uno stesso riferimento:

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

Quindi ora il gruppo esterno 1verrà utilizzato n volte in cui n ² è il quadrato più grande che divide l'input e il gruppo 2memorizza il fattore rimanente. Quello che vogliamo è dividere il numero intero per n per rimuovere il quadrato. Il risultato può essere espresso come il numero di iterazioni del gruppo 1volte gruppo 2, ma questo è un po 'difficile da fare. $*Probabilmente la Retina sarà presto migliorata per prendere un token non personaggio come argomento della mano destra, nel qual caso potremmo semplicemente sostituirlo con $#1$*$2, ma non funziona ancora.

Invece, scomponiamo i numeri dispari in modo diverso. Torniamo all'esempio più semplice di abbinamento dei quadrati perfetti con (^1|11\1)+$. Invece di avere un contatore \1che è inizializzato su 1 e incrementato di 2 su ogni iterazione, avremo due contatori. Uno è inizializzato su 0 e uno è inizializzato su 1 , ed entrambi sono incrementati di 1 su ogni iterazione. Quindi abbiamo sostanzialmente decomposto i numeri dispari 2n + 1 in (n) + (n + 1) . Il vantaggio è che finiremo con n in uno dei gruppi. Nella sua forma più semplice, assomiglia a questo:

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

Dove \2è n ed \3è n + 1 . Tuttavia, possiamo farlo in modo un po 'più efficiente notando che n + 1 di una iterazione è uguale alla n della prossima iterazione, quindi possiamo risparmiare su un 1qui:

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

Ora non ci resta che tornare a utilizzare un fattore iniziale anziché 1abbinare gli input che sono divisi per un quadrato perfetto:

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

Ora tutto ciò che dobbiamo fare è sostituire l'intera cosa con $3alla fine, che memorizza il fattore iniziale per il numero di passi, che fa cadere un fattore del quadrato dall'input.

Questo viene fatto più volte +all'inizio del programma, per tenere conto degli input che contengono potenze più elevate dei quadrati.

Ottava, 27 byte

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

Approccio simile come le altre risposte. La differenza è: le funzioni hanno nomi molto più lunghi. Credo che il codice si spieghi davvero: prende l' product dei uniqueprimi factors di un numero.

Wolfram Language, 29 28 byte

-1 Grazie a @Martin Ender ♦

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

Spiegazione:

           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)

Provalo online!

Il più grande divisore squarefree di nè quel numero più piccolo rcon tutti ni fattori primi di. Possiamo verificarlo come r**n%n==0, dal momento che r**nfare ncopie di ogni fattore primo di r, ed è divisibile nsolo se nè rappresentato ciascuno dei fattori primi.

Il 1>>r**n%nequivale a int(r**n%n==0). Se è Truepossibile utilizzare l'output 1, è più breve di 2 byte.

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

Matematica , 40 byte

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

Provalo online!

Alice , 4 byte

iDo@

Provalo online!

L'input e l'output sono indicati come punto di codice di un carattere (funziona per tutti i punti di codice Unicode validi).

Spiegazione

Bene, Alice ha un built-in la Dcui definizione è "fattori primi deduplicati". Cioè, fintanto che un valore è divisibile per alcuni p ² per un primo p , dividi quel valore per p . Questa sembra essere esattamente la funzione richiesta in questa sfida. Il resto è solo input, output, termina il programma.

Il motivo per cui questo è stato aggiunto ad Alice non ha nulla a che fare con questa sequenza di numeri interi. Stavo cercando di attenermi al tema di associare i divisori con sottostringhe e fattori primi con personaggi. E avevo bisogno di una funzione che accompagni i "caratteri deduplicati" (che è molto più utile in generale, perché ti permette di trattare le stringhe come set, specialmente se usate insieme ai vari operatori multiset).

Haskell , 31 byte

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

Provalo online!

Pyke , 3 byte

P}B

Provalo online!

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

Prolog (SWI) , 84 39 byte

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

Provalo online!

Adattato l'idea della risposta Haskell di @ xnor a Prolog.

PHP, 70 byte

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

Provalo online!

Pyth, 8 6 byte

*F+1{P

* -2 byte grazie a @LeakyNun

Sarebbe 3 se Pyth avesse un built-in per i prodotti delle liste ...

Provalo!

*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

Grazie a @ Ørjan Johansen per aver rimosso la necessità di r. Grazie a questo e ad altri trucchi sporchi sono stato in grado di spremere 15 byte!

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

whileè sparito e sostituito con ||e indicizzare il twiddling. <=avrebbe dovuto essere da <sempre.

<=attivato <spostando l'incremento per ottenere n%(++d*d)(dovrebbe essere ben definito a causa della precedenza dell'operatore).

Codice originale:

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

Assioma, 89 byte

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

test e risultati

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

questa è la funzione factor () non use

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)

ma è solo 125 byte

R, 52 byte

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

legge nda stdin. Richiede l' gmpinstallazione della libreria (quindi TIO non funzionerà). Utilizza lo stesso approccio di molte delle risposte precedenti, ma si arresta in modo anomalo su un input di 1, perché factorize(1)restituisce un vettore vuoto di classe bigz, che si arresta in modo uniqueanomalo, ahimè.

In realtà , 2 byte

yπ

Provalo online!

Spiegazione:

yπ
y   prime divisors
 π  product

Pari / GP , 28 byte

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

Provalo online!

Pyt , 3 byte

←ϼΠ

Spiegazione:

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