Definitionen

• Ein perfektes Quadrat ist eine ganze Zahl, die als Quadrat einer anderen ganzen Zahl ausgedrückt werden kann. Zum Beispiel 36ist ein perfektes Quadrat, weil 6^2 = 36.
• Eine quadratfreie Zahl ist eine ganze Zahl, die mit Ausnahme von durch kein perfektes Quadrat teilbar ist 1. Zum Beispiel 10ist eine quadratische Zahl. Allerdings 12ist keine Zahl quadrat, weil 12teilbar durch 4und 4ist ein perfekter Platz.

Aufgabe

Bei einer positiven Ganzzahl nwird die größte teilende quadratfreie Zahl ausgegeben n.

Testfälle

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

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Es gelten Standardlücken .

Referenz

• OEIS A007947

05AB1E , 2 Bytes

fP

Probieren Sie es online!

Wie es funktioniert

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

Brachylog , 3 Bytes

ḋd×

Probieren Sie es online!

Eine sehr originelle Antwort ...

Erläuterung

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

JavaScript (ES6), 55 54 50 46 Byte

OEIS zitieren :
a (n) ist der kleinste Teiler u von n, so dass n u ^ n teilt

Aktualisierte Implementierung:
a (n) ist der kleinste Teiler u von n positiven ganzen Zahlen u, so dass n u ^ n teilt

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 mit Hilfe von @LeakyNun gespeichert

Yfup

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe 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

Gelee , 4 Bytes

ÆfQP

Probieren Sie es 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_&:*

^{Warum muss jede Operation in diesem Programm aus 2 Bytes bestehen -_-}

Probieren Sie es 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

Ein- und Ausgabe in unary .

Probieren Sie es online! (Beinhaltet eine Kopf- und Fußzeile zur dezimalen <-> unären Konvertierung und zur gleichzeitigen Ausführung mehrerer Testfälle.)

Erläuterung

Die Idee ist, die Eingabe als ein Quadrat mal einen Faktor abzugleichen. Der grundlegende reguläre Ausdruck zum Abgleichen eines Quadrats verwendet eine Vorwärtsreferenz, um Summen aufeinanderfolgender ungerader Ganzzahlen abzugleichen:

(^1|11\1)+$

Da wir perfekte Quadrate nicht passen wollen, aber Zahlen , die durch ein Quadrat teilbar sind, ersetzen wir , dass 1mit einer Rückreferenzierung selbst:

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

Die äußere Gruppe 1wird also n- mal verwendet, wobei n ² das größte Quadrat ist, das die Eingabe teilt, und die Gruppe 2den verbleibenden Faktor speichert. Was wir wollen, ist, die ganze Zahl durch n zu teilen , um das Quadrat zu entfernen. Das Ergebnis kann als die Anzahl der Iterationen von Gruppe zu 1Gruppe ausgedrückt werden 2, dies ist jedoch etwas schwierig. Retina $*wird wahrscheinlich bald verbessert, um ein Nicht-Zeichen-Token als Argument für die rechte Hand zu verwenden. In diesem Fall könnten wir dies einfach ersetzen $#1$*$2, aber das funktioniert noch nicht.

Stattdessen zerlegen wir die ungeraden Zahlen unterschiedlich. Kehren wir zum einfacheren Beispiel des Abgleichs perfekter Quadrate mit zurück (^1|11\1)+$. Anstatt einen Zähler zu haben, \1der bei jeder Iteration auf 1 initialisiert und um 2 erhöht wird , haben wir zwei Zähler. Einer wird auf 0 und einer auf 1 initialisiert , und beide werden bei jeder Iteration um 1 erhöht . Wir haben also die ungeraden Zahlen 2n + 1 in (n) + (n + 1) zerlegt . Der Vorteil ist , dass wir am Ende folgendes haben n in einer der Gruppen. In seiner einfachsten Form sieht das so aus:

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

Wo \2ist n und \3ist n + 1 . Wir können dies jedoch ein wenig effizienter tun, indem wir feststellen, dass das n + 1 einer Iteration gleich dem n der nächsten Iteration ist, sodass wir hier Folgendes einsparen können 1:

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

Jetzt müssen wir nur noch einen Anfangsfaktor verwenden, anstatt 1Eingaben abzugleichen, die durch ein perfektes Quadrat geteilt werden:

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

Jetzt müssen wir nur noch das Ganze durch $3das Ende ersetzen , das den Anfangsfaktor multipliziert mit der Anzahl der Schritte speichert und einen Faktor des Quadrats aus der Eingabe entfernt.

Dies wird +am Anfang des Programms wiederholt durchgeführt, um Eingaben zu berücksichtigen, die höhere Potenzen als Quadrate enthalten.

Oktave, 27 Bytes

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

Ähnliches Vorgehen wie bei den anderen Antworten. Der Unterschied ist: Die Funktionen haben viel längere Namen. Ich glaube, der Code erklärt sich von selbst: Nimmt die prodSumme der uniquePrimzahlen factoreiner Zahl.

Wolfram-Sprache, 29 28 Bytes

-1 Danke an @Martin Ender ♦

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

Erläuterung:

           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)

Probieren Sie es online!

Der größte quadratfreie Teiler von nist die kleinste Zahl rmit allen nPrimfaktoren. Wir können dies als r**n%n==0, da r**nmachen nKopien von jedem Primfaktor rund ist teilbar durch nnur , wenn jeder n‚s Primfaktoren vertreten ist.

Das 1>>r**n%nist gleichbedeutend mit int(r**n%n==0). Wenn TrueAusgang 1 verwendet werden kann, sind es 2 Byte weniger.

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

Mathematik , 40 Bytes

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

Probieren Sie es online!

Alice , 4 Bytes

iDo@

Probieren Sie es online!

Eingabe und Ausgabe werden als Codepunkt eines Zeichens angegeben (funktioniert für alle gültigen Unicode-Codepunkte).

Erläuterung

Nun, Alice hat eine eingebaute, Dderen Definition "Deduplizieren Primfaktoren" ist. Das heißt, solange ein Wert für eine Primzahl p durch etwas p ² teilbar ist , dividiere diesen Wert durch p . Dies ist genau die Funktion, die für diese Herausforderung erforderlich ist. Der Rest ist nur Eingabe, Ausgabe, Programm beenden.

Der Grund, warum dies zu Alice hinzugefügt wurde, hat eigentlich nichts mit dieser Ganzzahlsequenz zu tun. Ich habe versucht, mich an das Thema zu halten, Teiler mit Teilzeichenfolgen und Primfaktoren mit Zeichen zu verknüpfen. Und ich brauchte eine Funktion, die zu "deduplizierten Zeichen" passt (was im Allgemeinen viel nützlicher ist, weil Sie damit Zeichenfolgen als Mengen behandeln können, insbesondere wenn sie zusammen mit den verschiedenen Multiset-Operatoren verwendet werden).

Haskell , 31 Bytes

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

Probieren Sie es online!

Pyke , 3 Bytes

P}B

Probieren Sie es online!

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

Prolog (SWI) , 84 39 Bytes

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

Probieren Sie es online!

Die Idee von @ xnors Haskell-Antwort wurde an Prolog angepasst .

PHP, 70 Bytes

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

Probieren Sie es online!

Pyth, 8 6 Bytes

*F+1{P

* -2 Bytes dank @LeakyNun

Wäre 3, wenn Pyth ein eingebautes Produkt für Listen hätte ...

Versuch es!

*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

Vielen Dank an @ Ørjan Johansen für die Beseitigung der Notwendigkeit für r. Dank dieser und einiger anderer schmutziger Tricks konnte ich 15 Bytes wegpressen!

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

whileist weg und ersetzt mit ||und Index Twiddling. <=sollte die <ganze Zeit gewesen sein.

<=gedreht, <indem Sie das Inkrement bewegen, um zu erhalten n%(++d*d)(sollte aufgrund der Priorität des Operators genau definiert sein).

Originalcode:

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 und Ergebnisse

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

Dies ist die Funktion, bei der factor () nicht verwendet wird

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)

es sind aber nur 125 bytes

R, 52 Bytes

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

liest naus stdin. Erfordert die gmpInstallation der Bibliothek (damit TIO nicht funktioniert). Verwendet den gleichen Ansatz wie viele der obigen Antworten, stürzt jedoch bei der Eingabe von ab 1, da factorize(1)ein leerer Klassenvektor zurückgegeben wird bigz, der uniqueleider abstürzt .

Eigentlich 2 Bytes

yπ

Probieren Sie es online!

Erläuterung:

yπ
y   prime divisors
 π  product

Pari / GP , 28 Bytes

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

Probieren Sie es online!

Pyt , 3 Bytes

←ϼΠ

Erläuterung:

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