Definiciones

• Un cuadrado perfecto es un entero que se puede expresar como el cuadrado de otro entero. Por ejemplo, 36es un cuadrado perfecto porque 6^2 = 36.
• Un número libre de cuadrados es un número entero que no es divisible por ningún cuadrado perfecto, excepto por 1. Por ejemplo, 10es un número libre de cuadrados. Sin embargo, 12no es un número libre de cuadrados, porque 12es divisible por 4y 4es un cuadrado perfecto.

Tarea

Dado un entero positivo n, genera el número libre de cuadrados más grande que divide n.

Casos de prueba

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

Tanteo

Este es el código de golf . La respuesta más corta en bytes gana.

Se aplican lagunas estándar .

Referencia

• OEIS A007947

05AB1E , 2 bytes

fP

Pruébalo en línea!

Cómo funciona

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

Brachylog , 3 bytes

ḋd×

Pruébalo en línea!

Una respuesta muy original ...

Explicación

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

JavaScript (ES6), 55 54 50 46 bytes

Citando OEIS :
a (n) es el divisor más pequeño u de n tal que n divide u ^ n

Implementación actualizada:
a (n) es el divisor más pequeño u de n entero positivo u tal que 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 bytes

2 bytes guardados con ayuda de @LeakyNun

Yfup

Pruébalo en línea!

Explicación

Considere la entrada 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

Jalea , 4 bytes

ÆfQP

Pruébalo en línea!

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

rimf_&:*

^{¿Por qué cada operación en este programa tiene que ser de 2 bytes?}

Pruébalo en línea!

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 bytes

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

Entrada y salida en unario .

Pruébalo en línea! (Incluye un encabezado y pie de página para la conversión decimal <-> unaria y para ejecutar múltiples casos de prueba a la vez).

Explicación

La idea es hacer coincidir la entrada como un cuadrado multiplicado por algún factor. La expresión regular básica para unir un cuadrado utiliza una referencia directa para unir sumas de enteros impares consecutivos:

(^1|11\1)+$

Como no queremos hacer coincidir cuadrados perfectos, sino números que son divisibles por un cuadrado, lo reemplazamos 1con una referencia misma:

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

Así que ahora el grupo externo 1se usará n veces donde n ² es el cuadrado más grande que divide la entrada y el grupo 2almacena el factor restante. Lo que queremos es dividir el número entero entre n para eliminar el cuadrado. El resultado puede expresarse como el número de iteraciones de grupo por 1grupo 2, pero esto es un poco difícil de hacer. La retina $*probablemente se mejorará pronto para tomar un token que no sea de personaje como argumento de la mano derecha, en cuyo caso podríamos simplemente reemplazarlo por $#1$*$2, pero eso aún no funciona.

En cambio, descomponemos los números impares de manera diferente. Volvamos al ejemplo más simple de combinar cuadrados perfectos con (^1|11\1)+$. En lugar de tener un contador \1que se inicializa en 1 y se incrementa en 2 en cada iteración, tendremos dos contadores. Uno se inicializa a 0 y el otro a 1 , y ambos se incrementan en 1 en cada iteración. Básicamente, hemos descompuesto los números impares 2n + 1 en (n) + (n + 1) . El beneficio es que terminaremos con n en uno de los grupos. En su forma más simple, se ve así:

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

Donde \2es n y \3es n + 1 . Sin embargo, podemos hacer esto un poco más eficiente al notar que el n + 1 de una iteración es igual al n de la siguiente iteración, por lo que podemos ahorrar 1aquí:

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

Ahora solo tenemos que volver a usar un factor inicial en lugar de 1hacer coincidir las entradas divididas por un cuadrado perfecto:

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

Ahora todo lo que tenemos que hacer es reemplazar todo esto $3al final, que almacena el factor inicial multiplicado por el número de pasos, lo que elimina un factor del cuadrado de la entrada.

Esto se hace repetidamente con el +principio del programa, para tener en cuenta las entradas que contienen potencias más altas que los cuadrados.

Octava, 27 bytes

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

Enfoque similar a las otras respuestas. La diferencia es: las funciones tienen nombres mucho más largos. Creo que el código se explica realmente: toma el efecto prodde los uniquenúmeros primos factorde un número.

Wolfram Language, 29 28 bytes

-1 Gracias a @Martin Ender ♦

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

Explicación:

           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 bytes

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

Pruébalo en línea!

El mayor divisor libre de cuadrados nes el número más pequeño rcon todos nlos factores primos de. Podemos verificar esto como r**n%n==0, ya que r**nhacer ncopias de cada factor primo de r, y es divisible por nsolo si cada uno den los factores primos está representado.

El 1>>r**n%nes equivalente a int(r**n%n==0). Si Truese puede usar la salida 1, es 2 bytes más corto para hacerlo.

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

Matemáticas , 40 bytes.

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

Pruébalo en línea!

Alice , 4 bytes

iDo@

Pruébalo en línea!

La entrada y la salida se proporcionan como el punto de código de un carácter (funciona para todos los puntos de código Unicode válidos).

Explicación

Bueno, Alice tiene una Ddefinición incorporada que es "Deduplicar factores primos". Es decir, siempre que un valor sea divisible por alguna p ² para una prima p , divida ese valor entre p . Esta es exactamente la función requerida en este desafío. El resto es solo entrada, salida, terminar el programa.

La razón por la que esto se agregó a Alice en realidad no tiene nada que ver con esta secuencia de enteros. Estaba tratando de mantener un tema de asociar divisores con subcadenas y factores primos con caracteres. Y necesitaba una función que vaya con "deduplicar caracteres" (que es mucho más útil en general, porque te permite tratar las cadenas como conjuntos, especialmente cuando se usan junto con los diversos operadores de conjuntos múltiples).

Haskell , 31 bytes

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

Pruébalo en línea!

Pyke , 3 bytes

P}B

Pruébalo en línea!

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

Prólogo (SWI) , 84 39 bytes

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

Pruébalo en línea!

Adaptó la idea de la respuesta de Haskell de @xnor a Prolog.

PHP, 70 bytes

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

Pruébalo en línea!

Pyth, 8 6 bytes

*F+1{P

* -2 bytes gracias a @LeakyNun

Sería 3 si Pyth tuviera una función incorporada para productos de listas ...

¡Intentalo!

*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

Gracias a @ Ørjan Johansen por eliminar la necesidad de r. ¡Gracias a este y algunos otros trucos sucios pude exprimir 15 bytes!

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

whilese ha ido y reemplazado con un ||índice de giro. <=debería haber estado <todo el tiempo.

<=se gira <moviendo el incremento para obtener n%(++d*d)(debe estar bien definido debido a la precedencia del operador).

Código original:

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

Axioma, 89 bytes

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

prueba y resultados

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

esta es la función de no usar 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)

pero solo tiene 125 bytes

R, 52 bytes

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

lee nde stdin. Requiere gmpque se instale la biblioteca (para que TIO no funcione). Utiliza el mismo enfoque que muchas de las respuestas anteriores, pero se bloquea en una entrada de 1, porque factorize(1)devuelve un vector de clase vacío bigz, que se bloquea unique, por desgracia.

En realidad , 2 bytes

yπ

Pruébalo en línea!

Explicación:

yπ
y   prime divisors
 π  product

Pari / GP , 28 bytes

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

Pruébalo en línea!

Pyt , 3 bytes

←ϼΠ

Explicación:

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