Aufgabe

Gegeben ganze Zahlen xund ydie beide zumindest sind 2, finden Sie die kleinste positive Zahl , deren y-te Leistung teilbar durch x.

Beispiel

Vorausgesetzt x=96und y=2, die Ausgabe sollte 24da sein, 24ist das kleinste positive nErgebnis zufriedenstellend n^2 is divisible by 96.

Testfälle

x  y output
26 2 26
96 2 24
32 3 4
64 9 2
27 3 3

Wertung

Das ist Code-Golf . Lösung mit der niedrigsten Byteanzahl gewinnt.

Verweise

• y=2: OEIS A019554
• y=3: OEIS A019555
• y=4: OEIS A053166
• y=5: OEIS A015052
• y=6: OEIS A015054

Brachylog , 19 17 16 15 12 Bytes

2 Bytes gespart dank @LeakyNun.

:[I:1]*$r=#>

Probieren Sie es online!

Erläuterung

               Input = [X, Y]
:[I:1]*        Get a list [X*I, Y] (I being any integer at this point)
       $r=     Get the first integer which is the Yth root of X*I
          #>   This integer must be strictly positive
               This integer is the Output

Gelee , 6 Bytes

ÆE÷ĊÆẸ

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

ÆE÷ĊÆẸ  Main link. Arguments: x, y

ÆE      Yield the exponents of x's prime factorization.
  ÷     Divide them by y.
   Ċ    Ceil; round the quotients up to the nearest integer.
    ÆẸ  Return the integer with that exponents in its prime factorization.

JavaScript (ES7), 32 Byte

f=(x,y,i=1)=>i**y%x?f(x,y,i+1):i

Gelee , 6 Bytes

R*%⁸i0

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

R*%⁸i0  Main link. Arguments: x, y

R       Yield range from 1 to x inclusive.
 *      Raise each to power y.
  %⁸    Take modulo of each with base x.
    i0  Find the 1-based index of the first
        occurence of zero, returns.

Python 3, 60 43 39 Bytes

Vielen Dank an @LeakyNun und @ Sp3000 für die Hilfe

f=lambda x,y,i=1:i**y%x<1or-~f(x,y,i+1)

Eine Funktion, die Eingaben über Argumente entgegennimmt und die Ausgabe zurückgibt.

Wie es funktioniert

Die Funktion verwendet die Rekursion, um wiederholt Ganzzahlen zu überprüfen i, beginnend mit i=1, bis eine gefunden wird, die die erforderliche Bedingung erfüllt i**y%x<1. Dies wird erreicht, indem die Logik order Bedingung und das Ergebnis des Ausdrucks für " i+1inkrementiert" herangezogen werden, was hier der Fall ist -~f(x,y,i+1). Dieser Ausdruck wird so lange fortlaufend ausgewertet, Falsebis ein zufriedenstellender Wert jgefunden wurde. An diesem Punkt wird er ausgewertet Trueund die Rekursion wird beendet. Da diese zu 0und 1in Python äquivalent sind und die Funktion wiederholt 1über den inkrementierenden Teil hinzugefügt wurde , kehrt die Funktion nach (j-1)*False + True + (j-1)*1 = (j-1)*0 + 1 + (j-1)*1 = 1 + j-1 = jBedarf zurück.

Probieren Sie es auf Ideone

Haskell, 31 Bytes

x#y=[n|n<-[1..],mod(n^y)x<1]!!0

Anwendungsbeispiel: 96#2-> 24.

Direkte Implementierung: Probieren Sie alle ganzen Zahlen aus n, behalten Sie die Bedingungen bei und wählen Sie die erste aus.

05AB1E (10 Byte)

>GN²m¹ÖiNq

Probieren Sie es online aus

• > Liest das erste Argument, erhöht es und legt es auf dem Stapel ab
• Göffnet den stack ( a) und startet eine Schleife, die den Rest des Programms enthält, in der Nder Wert übernommen wird 1, 2, ... a - 1.
• N²mDrückt Nund der zweite Eintrag aus dem Eingabeverlauf, dann werden beide geknackt und der erste wird zur Potenz des zweiten.
• ¹ schiebt den ersten Eintrag aus dem Eingabeverlauf auf den Stapel.
• ÖÖffnet die beiden vorherigen Stapeleinträge und drückt dann a % b == 0auf den Stapel.
• iKnallt das vom Stapel. Wenn true, wird der Rest des Programms ausgeführt. Andernfalls wird die Schleife fortgesetzt.
• Ndrückt Nauf den Stapel.
• q Beendet das Programm.

Wenn das Programm beendet wird, wird der oberste Wert des Stapels gedruckt.

MATL , 9 Bytes

y:w^w\&X<

Probieren Sie es online!

Erläuterung

y       % Take x and y implicitly. Push x again
        % STACK: x, y, x
:       % Range from 1 to x
        % STACK: x, y, [1, 2, ..., x]
w       % Swap
        % STACK: x, [1, 2, ..., x], y
^       % Power, element-wise
        % STACK: x, [1^y,  2^y, ..., x^y]
w       % Swap
        % STACK: [1^y, 2^y, ..., x^y], x
\       % Modulo, element-wise
        % STACK: [mod(1^y,x), mod(2^y,x), ..., mod(x^y,x)]
        % A 0 at the k-th entry indicates that x^y is divisible by x. The last entry
        % is guaranteed to be 0
&X<     % Arg min: get (1-based) index of the first minimum (the first zero), say n
        % STACK: n
        % Implicitly display

Tatsächlich , 12 11 Bytes

Vielen Dank an Leaky Nun für seine vielen Vorschläge. Golfvorschläge sind willkommen.Probieren Sie es online!

;)R♀ⁿ♀%0@íu

Ursprünglicher 12-Byte-Ansatz. Probieren Sie es online!

1WX│1╖╜ⁿ%WX╜

Ein weiterer 12-Byte-Ansatz. Probieren Sie es online!

w┬i)♀/♂K@♀ⁿπ

Ein 13-Byte-Ansatz. Probieren Sie es online!

k╗2`╜iaⁿ%Y`╓N

Ungolfing:

Erster Algorithmus

       Implicitly pushes y, then x.
;      Duplicate x.
)      Rotate duplicate x to bottom of the stack.
R      Range [1, x] (inclusive).
♀ⁿ     Map a**y over the range.
♀%     Map a**y%x over the range.
0@í    new_list.index(0)
u      Increment and print implicitly at the end of the program.

Ursprünglicher Algorithmus

       Implicitly pushes x, then y.
1WX    Pushes a truthy value to be immediately discarded 
         (in future loops, we discard a**y%x)
|      Duplicates entire stack.
         Stack: [y x y x]
1╖     Increment register 0.
╜      Push register 0. Call it a.
ⁿ      Take a to the y-th power.
%      Take a**y mod x.
W      If a**y%x == 0, end loop.
X      Discard the modulus.
╜      Push register 0 as output.

Dritter Algorithmus

       Implicitly pushes y, then x.
w      Pushes the full prime factorization of x.
┬      Transposes the factorization (separating primes from exponents)
i      Flatten (into two separate lists of primes and exponents).
)      Rotate primes to the bottom of the stack.
♀/     Map divide over the exponents.
♂K     Map ceil() over all of the divided exponents.
@      Swap primes and modified exponents.
♀ⁿ     Map each prime ** each exponent.
π      Product of that list. Print implicitly at the end of the program.

Vierter Algorithmus

     Implicitly pushes x, then y.
k╗   Turns stack [x y] into a list [x, y] and saves to register 0.
2    Pushes 2.
  `    Starts function with a.
  ╜i   Pushes register 0 and flattens. Stack: [x y a]
  a    Inverts the stack. Stack: [a y x]
  ⁿ%   Gets a**y%x.
  Y    Logical negate (if a**y is divisible by x, then 1, else 0)
  `    End function.
╓    Push first (2) values where f(x) is truthy, starting with f(0).
N    As f(0) is always truthy, get the second value.
     Print implicitly at the end of the program.

R, 61 Bytes , 39 Bytes , 37 Bytes , 34 Bytes

Ich bin immer noch ein Neuling in der R-Programmierung und es stellt sich heraus, dass dies meine erste Funktion ist, die ich in R erstelle ( Yay! ), Also glaube ich, dass es immer noch Raum für Verbesserungen gibt.

function(x,y){for(n in 2:x){if(n^y%%x==0){cat(x,y,n);break}}}

Online-Test kann hier durchgeführt werden: RStudio auf rollApp .

Hauptfortschritt:

function(x,y){which.max((1:x)^y%%x==0)}

which.maxfunktioniert, weil es den höchsten Wert in einem Vektor zurückgibt, und wenn es mehrere gibt, wird der erste zurückgegeben. In diesem Fall haben wir einen Vektor mit vielen FALSEs (die 0s sind) und einigen TRUEs (die 1s sind), sodass der erste TRUE zurückgegeben wird.

Ein weiterer Fortschritt:

function(x,y)which.max((1:x)^y%%x==0)

Schließlich schlägt es die Antwort mit Python um zwei Bytes. :)

Ein weiterer Fortschritt: (Schon wieder!)

function(x,y)which.min((1:x)^y%%x)

Vielen Dank an Axeman und user5957401 für die Hilfe.

dc, 23 22 Bytes

Vielen Dank an Delioth für seinen Tipp zu Eingabemethoden und zum Speichern eines Bytes

sysxz[zdlylx|0<F]dsFxp

Verwendet den Operator zfür die Stapeltiefe zum Inkrementieren des Testfalls direkt auf dem Stapel und den Operator |für die modulare Exponentiation für die modulare Exponentiation. Wiederholen Sie den Test, bis der Rest nicht mehr als Null ist.

05AB1E , 8 Bytes

Lsm¹%0k>

Erläuterung

L         # range(1,x) inclusive
 sm       # each to the power of y
   ¹%     # each mod x
     0k   # find first index of 0 (0-based)
       >  # increment to 1-based

Probieren Sie es online aus

Perl 6 ,  26  25 Bytes

{first * **$^y%%$^x,1..$x}
{first * **$^y%%$^x,1..*}

Erläuterung:

# bare block with two placeholder parameters ｢$^y｣ and ｢$^x｣
{
  # find the first value
  first

  # where when it ｢*｣ is taken to the power
  # of the outer blocks first parameter ｢$^y｣
  * ** $^y
  # is divisible by the outer blocks second parameter ｢$^x｣
  %% $^x,

  # out of the values from 1 to Inf
  1 .. *
}

Mathematica, 36 Bytes

(i=1;While[n=i++;Mod[n^#2,#]!=0];n)&

Dyalog APL , 11 Bytes

Übersetzung davon .

0⍳⍨⊣|(⍳⊣)*⊢

0⍳⍨finde die erste Null in
⊣|den Divisionsresten, wenn x
(⍳⊣)* die Ganzzahlen eins bis x dividiert , die auf die Potenz von
⊢ y

TryAPL online!

PowerShell v2 +, 48 Byte

param($x,$y)(1..$x|?{!(("$_*"*$y+1|iex)%$x)})[0]

Nimmt Eingabe $xund $y. Erstellt einen Bereich von 1bis $xund Where-Objectfiltert dann diese Zahlen. Der Filter nimmt die Zeichenfolge "$_*"(dh die aktuelle Zahl mit einem Sternchen) und verwendet die Zeichenfolgenmultiplikation, um diese $yZeiten zu verketten . Anschliessend setzt er ein Finale 1auf und leitet das zu iex(kurz für Invoke-Expressionund ähnlich zu eval) weiter. Dies tritt an die Stelle von [math]::Pow($_,$y), da PowerShell keinen Exponentiationsoperator hat und zwei Bytes kürzer ist. Das wird in den Modulo-Operator eingespeist . Wenn es also teilbar ist, wird es von diesem Filter eingeschlossen, und alle anderen Zahlen werden ausgeschlossen.% mit$x - wenn es also teilbar ist, wird dies sein 0, also kapseln wir das in Parens und nehmen das Boolesche-Nicht!(...)

Schließlich kapseln wir die resultierenden Zahlen in Parens (...)und nehmen den [0]Index. Da der eingegebene Bereich sortiert ist 1..$x, ist dies der kleinste. Das bleibt in der Pipeline und das Drucken ist implizit.

Testfälle

PS C:\Tools\Scripts\golfing> (26,2),(96,2),(32,3),(64,9),(27,3)|%{($_-join', ')+' -> '+(.\smallest-positive-number-divisor.ps1 $_[0] $_[1])}
26, 2 -> 26
96, 2 -> 24
32, 3 -> 4
64, 9 -> 2
27, 3 -> 3

PHP, 55 33 Bytes

$i=1;while($i**$y%$x)$i++;echo$i;

Perl, 29 26 Bytes

Beinhaltet +3 für -p(nicht +1, da der Code enthält ')

Führen Sie mit der Eingabe auf STDIN

power.pl <<< "96 2"

power.pl:

#!/usr/bin/perl -p
/ /;1while++$\**$'%$`}{

Pyth, 9 Bytes

AQf!%^THG

Ein Programm, das eine Liste des Formulars [x, y]in STDIN eingibt und das Ergebnis druckt.

Probieren Sie es online aus

Wie es funktioniert

AQf!%^THG  Program. Input: Q
AQ         G=Q[0];H=Q[1]
  f        First truthy input T in [1, 2, 3, ...] with function:
     ^TH    T^H
    %   G   %G
   !        Logical not (0 -> True, all other modulus results -> False)
           Implicitly print

PHP 59 Bytes

Entschuldigung, aber ich kann das nicht von meinem Handy aus testen. :)

function blahblah($x,$y){
  for($i=0;1;$i++){
    if(!$i^$y%$x){
      return $i;
    }
  }
}

Golf gespielt

function b($x,$y){for($i=0;1;$i++){if(!$i^$y%$x)return $i;}