Definições

• Um quadrado perfeito é um número inteiro que pode ser expresso como o quadrado de outro número inteiro. Por exemplo, 36é um quadrado perfeito porque 6^2 = 36.
• Um número sem quadrados é um número inteiro que não é divisível por nenhum quadrado perfeito, exceto por 1. Por exemplo, 10é um número sem quadrados. No entanto, 12não é um número sem quadrados, porque 12é divisível por 4e 4é um quadrado perfeito.

Tarefa

Dado um número inteiro positivo n, produza o maior número sem quadrados que divide n.

Casos de teste

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

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

Aplicam-se brechas padrão .

Referência

• OEIS A007947

05AB1E , 2 bytes

fP

Experimente online!

Como funciona

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

Braquilog , 3 bytes

ḋd×

Experimente online!

Uma resposta muito original ...

Explicação

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

JavaScript (ES6), 55 54 50 46 bytes

Citando OEIS :
a (n) é o menor divisor u de n de modo que n divide u ^ n

Implementação atualizada:
a (n) é o menor divisor u de n inteiro positivo u, de modo 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 salvos com a ajuda de @LeakyNun

Yfup

Experimente online!

Explicação

Considere 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

Gelatina , 4 bytes

ÆfQP

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

rimf_&:*

^{Por que todas as operações neste programa precisam ter 2 bytes -_-}

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

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

Entrada e saída em unário .

Experimente online! (Inclui um cabeçalho e rodapé para conversão decimal <-> unária e para executar vários casos de teste de uma só vez.)

Explicação

A idéia é combinar a entrada como um quadrado vezes algum fator. O regex básico para corresponder a um quadrado usa uma referência direta para corresponder a somas de números inteiros ímpares consecutivos:

(^1|11\1)+$

Como não queremos combinar quadrados perfeitos, mas números que são divisíveis por um quadrado, substituímos isso 1por uma referência própria:

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

Portanto, agora o grupo externo 1será usado n vezes em que n ² é o quadrado maior que divide a entrada e o grupo 2armazena o fator restante. O que queremos é dividir o número inteiro por n para remover o quadrado. O resultado pode ser expresso como o número de iterações do grupo de 1tempos do grupo 2, mas isso é um pouco complicado de fazer. O Retina $*provavelmente será aprimorado em breve para receber um token sem caractere como argumento à direita; nesse caso, poderíamos simplesmente substituí-lo por $#1$*$2, mas isso ainda não funciona.

Em vez disso, decompomos os números ímpares de maneira diferente. Vamos voltar ao exemplo mais simples de combinar quadrados perfeitos com (^1|11\1)+$. Em vez de ter um contador \1que é inicializado para 1 e incrementado por 2 em cada iteração, teremos dois contadores. Um é inicializado em 0 e um é inicializado em 1 , e ambos são incrementados em 1 em cada iteração. Então, decompusemos basicamente os números ímpares 2n + 1 em (n) + (n + 1) . O benefício é que acabaremos com n em um dos grupos. Na sua forma mais simples, fica assim:

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

Onde \2é n e \3é n + 1 . No entanto, podemos fazer isso com mais eficiência, observando que o n + 1 de uma iteração é igual ao n da próxima iteração, para que possamos economizar 1aqui:

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

Agora só precisamos voltar a usar um fator inicial em vez de 1combinar entradas divididas por um quadrado perfeito:

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

Agora tudo o que precisamos fazer é substituir essa coisa inteira por $3no final, que armazena o fator inicial vezes o número de etapas, o que retira um fator do quadrado da entrada.

Isso é feito repetidamente +no início do programa, para contabilizar entradas que contêm potências mais altas que quadrados.

Oitava, 27 bytes

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

Abordagem semelhante às outras respostas. A diferença é: As funções têm nomes muito mais longos. Acredito que o código se explica realmente: toma o resultado proddas uniqueprimos factors de um número.

Wolfram Language, 29 28 bytes

-1 Obrigado a @Martin Ender ♦

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

Explicação:

           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)

Experimente online!

O maior divisor de zero né o menor número rcom todos nos fatores primos. Podemos verificar isso como r**n%n==0, desde que r**nfaça ncópias de cada fator principal de r, e é divisível napenas se cada um dos nfatores primos estiver representado.

O 1>>r**n%né equivalente a int(r**n%n==0). Se Truepode ser usada a saída 1, são 2 bytes mais curtos.

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

Matemática , 40 bytes

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

Experimente online!

Alice , 4 bytes

iDo@

Experimente online!

A entrada e a saída são fornecidas como o ponto de código de um caractere (funciona para todos os pontos de código Unicode válidos).

Explicação

Bem, Alice tem um built-in Dcuja definição é "fatores principais com redução de redundância". Ou seja, desde que um valor seja divisível por alguns p ² para um p primo , divida esse valor por p . Essa é exatamente a função necessária neste desafio. O resto é apenas entrada, saída e finalização do programa.

A razão pela qual isso foi adicionado a Alice, na verdade, nada tem a ver com essa sequência inteira. Eu estava tentando manter um tema de associação de divisores com substrings e fatores primos com caracteres. E eu precisava de uma função que inclua "caracteres com desduplicação" (que é muito mais útil em geral, porque vamos tratar as strings como conjuntos, especialmente quando usadas em conjunto com os vários operadores de vários conjuntos).

Haskell , 31 bytes

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

Experimente online!

Pyke , 3 bytes

P}B

Experimente online!

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

Prolog (SWI) , 84 39 bytes

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

Experimente online!

Adaptou a idéia da resposta Haskell de @ xnor para Prolog.

PHP, 70 bytes

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

Experimente online!

Pitão, 8 6 bytes

*F+1{P

* -2 bytes graças a @LeakyNun

Seria 3 se Pyth tivesse um built-in para produtos de listas ...

Tente!

*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

Obrigado a Ørjan Johansen por remover a necessidade r. Graças a este e outros truques sujos, consegui extrair 15 bytes!

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

whiledesapareceu e foi substituído por um ||indexador. <=deveria ter sido o tempo <todo.

<=ativado <movendo o incremento para obter n%(++d*d)(deve ser bem definido devido à precedência do 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]))

teste e 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]]

essa é a função que não usa 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)

mas são apenas 125 bytes

R, 52 bytes

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

lê nde stdin. Requer que a gmpbiblioteca seja instalada (para que o TIO não funcione). Usa a mesma abordagem que muitas das respostas acima, mas trava em uma entrada de 1, porque factorize(1)retorna um vetor vazio de classe bigz, que trava unique, infelizmente.

Na verdade , 2 bytes

yπ

Experimente online!

Explicação:

yπ
y   prime divisors
 π  product

Pari / GP , 28 bytes

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

Experimente online!

Pyt , 3 bytes

←ϼΠ

Explicação:

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