Définitions

• Un carré parfait est un entier qui peut être exprimé comme le carré d'un autre entier. Par exemple, 36est un carré parfait parce que 6^2 = 36.
• Un nombre sans carrés est un entier qui n'est divisible par aucun carré parfait, sauf par 1. Par exemple, 10est un numéro sans carré. Cependant, ce 12n’est pas un nombre sans carrés, car 12est divisible par 4et 4est un carré parfait.

Tâche

nSi le nombre entier est positif , indiquez le plus grand nombre carré qui se divise n.

Testcases

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

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Les failles standard s'appliquent.

Référence

• OEIS A007947

05AB1E , 2 octets

fP

Essayez-le en ligne!

Comment ça marche

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

Brachylog , 3 octets

ḋd×

Essayez-le en ligne!

Une réponse très originale ...

Explication

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

JavaScript (ES6), 55 54 50 46 octets

Citant OEIS :
a (n) est le plus petit diviseur u de n tel que n se divise u ^ n

Mise en oeuvre mise à jour:
a (n) est le plus petit diviseur u de n entier entier u tel que n se divise 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 octets

2 octets enregistrés avec l'aide de @LeakyNun

Yfup

Essayez-le en ligne!

Explication

Considérez l'entrée 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

Gelée , 4 octets

ÆfQP

Essayez-le en ligne!

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

rimf_&:*

^{Pourquoi chaque opération dans ce programme doit être de 2 octets -_-}

Essayez-le en ligne!

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 octets

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

Entrée et sortie en unaire .

Essayez-le en ligne! (Inclut un en-tête et un pied de page pour la conversion décimale <-> unaire et l'exécution simultanée de plusieurs scénarios de test.)

Explication

L'idée est de faire correspondre l'entrée avec un carré multiplié par un facteur. La regex de base pour faire correspondre un carré utilise une référence en avant pour faire correspondre les sommes d'entiers impairs consécutifs:

(^1|11\1)+$

Puisque nous ne voulons pas faire correspondre les carrés parfaits, mais les nombres qui sont divisibles par un carré, nous le remplaçons 1par une référence arrière:

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

Alors maintenant, le groupe extérieur 1sera utilisé n fois, où n ² est le plus grand carré qui divise l’entrée et le groupe 2stocke le facteur restant. Ce que nous voulons, c'est diviser l'entier par n pour supprimer le carré. Le résultat peut être exprimé comme le nombre d'itérations de groupe 1fois 2, mais c'est un peu difficile à faire. Retina $*sera probablement bientôt amélioré pour prendre un jeton sans caractère comme argument de droite, auquel cas nous pourrions simplement le remplacer par$#1$*$2 , mais cela ne fonctionne pas encore.

Au lieu de cela, nous décomposons les nombres impairs différemment. Revenons à l'exemple plus simple d'associer des carrés parfaits à (^1|11\1)+$. Au lieu d'avoir un compteur \1initialisé à 1 et incrémenté de 2 à chaque itération, nous aurons deux compteurs. L'un est initialisé à 0 et l'autre à 1 , et ils sont tous deux incrémentés de 1 à chaque itération. Nous avons donc décomposé les nombres impairs 2n + 1 en (n) + (n + 1) . L'avantage est que nous allons nous retrouver avec n dans l'un des groupes. Dans sa forme la plus simple, cela ressemble à ceci:

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

Où \2est n et \3est n + 1 . Cependant, nous pouvons le faire un peu plus efficacement en remarquant que le n + 1 d'une itération est égal au n de la prochaine itération, nous pouvons donc économiser sur un 1ici:

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

Nous devons maintenant revenir à l’utilisation d’un facteur initial au lieu de 1faire correspondre les entrées divisées par un carré parfait:

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

Il ne nous reste plus qu'à remplacer tout cela $3à la fin, qui stocke le facteur initial multiplié par le nombre d'étapes, ce qui supprime un facteur du carré de l'entrée.

Cela se fait de manière répétée +au tout début du programme, pour prendre en compte les entrées qui contiennent des puissances plus élevées que les carrés.

Octave, 27 octets

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

Approche similaire aux autres réponses. La différence est la suivante: les fonctions ont des noms beaucoup plus longs. Je crois que le code s’explique vraiment: prend prodla uniquepremière place factord’un nombre.

Wolfram Language, 29 28 octets

-1 Merci à @Martin Ender ♦

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

Explication:

           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 octets

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

Essayez-le en ligne!

Le plus grand diviseur de carrés nest le plus petit nombre ravec tous nles facteurs premiers de. Nous pouvons vérifier cela comme r**n%n==0, puisque r**nfaire des ncopies de chaque facteur premier de r, et est divisible par nseulement si chacun des nfacteurs premiers de est représenté.

Le 1>>r**n%nest équivalent à int(r**n%n==0). Si Truepeut être utilisé la sortie 1, il est 2 octets plus court à faire.

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

Mathématiques , 40 octets

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

Essayez-le en ligne!

Alice , 4 octets

iDo@

Essayez-le en ligne!

Entrée et sortie sont donnés comme le point de code d'un caractère (fonctionne pour tous les points de code Unicode valides).

Explication

Eh bien, Alice a une Ddéfinition intégrée dont la définition est "Facteurs premiers dédupliqués". En d’autres termes, tant qu’une valeur est divisible par une partie de p ² pour un nombre premier p , divisez cette valeur par p . Cela se trouve être exactement la fonction requise dans ce défi. Le reste ne fait qu'entrer, sortir, terminer le programme.

La raison pour laquelle cela a été ajouté à Alice n'a en réalité rien à voir avec cette séquence entière. J'essayais de coller à un thème d'association de diviseurs avec des sous-chaînes et de facteurs premiers avec des caractères. Et j'avais besoin d'une fonction qui va avec "caractères de déduplication" (ce qui est beaucoup plus utile en général, car cela vous permet de traiter les chaînes comme des ensembles, en particulier lorsqu'elles sont utilisées avec les différents opérateurs multisets).

Haskell , 31 octets

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

Essayez-le en ligne!

Pyke , 3 octets

P}B

Essayez-le en ligne!

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

Prolog (SWI) , 84 39 octets

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

Essayez-le en ligne!

Adaptation de l'idée de la réponse Haskell de @ xnor à Prolog.

PHP, 70 octets

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

Essayez-le en ligne!

Pyth, 8 à 6 octets

*F+1{P

* -2 octets grâce à @LeakyNun

Serait 3 si Pyth avait un construit pour les produits de listes ...

Essayez le!

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

Merci à @ Ørjan Johansen d’avoir supprimé le besoin de r. Grâce à cela et à d'autres trucs sales, j'ai pu supprimer 15 octets!

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

whileest parti et remplacé par un ||index. <=aurait du être< tout au long.

<=tourné à <en déplaçant l'incrément à obtenir n%(++d*d)(doit être bien défini en raison de la priorité de l'opérateur).

Code d'origine:

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

Axiome, 89 octets

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

test et résultats

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

c'est la fonction non-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)

mais ce n'est que 125 octets

R, 52 octets

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

lit nde stdin. Nécessite l' gmpinstallation de la bibliothèque (pour que TIO ne fonctionne pas). Utilise la même approche que beaucoup des réponses ci-dessus, mais il se bloque sur une entrée de 1, car factorize(1)renvoie un vecteur vide de classe bigz, ce qui bloque unique, hélas.

En fait , 2 octets

yπ

Essayez-le en ligne!

Explication:

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