Tâche

Étant donné des nombres entiers xet yqui sont tous les deux au moins 2, trouvez le plus petit nombre positif dont la ypuissance -th est divisible par x.

Exemple

Étant donné x=96et y=2, la sortie devrait être 24puisque 24c'est la plus petite nsatisfaction positive n^2 is divisible by 96.

Cas de test

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

Notation

C'est du code-golf . Solution avec le plus petit nombre de victoires d'octets.

Les références

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

2 octets enregistrés grâce à @LeakyNun.

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

Essayez-le en ligne!

Explication

               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

Gelée , 6 octets

ÆE÷ĊÆẸ

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

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

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

Gelée , 6 octets

R*%⁸i0

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

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 octets

Merci à @LeakyNun et @ Sp3000 pour leur aide

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

Une fonction qui prend l'entrée via un argument et renvoie la sortie.

Comment ça fonctionne

La fonction utilise la récursivité pour vérifier à plusieurs reprises les nombres entiers i, en commençant par i=1, jusqu'à ce que celui qui satisfait la condition requise, ici i**y%x<1, soit trouvé. Ceci est réalisé en prenant la logique orde la condition et le résultat de l'expression pour i+1incrémenté, qui est ici -~f(x,y,i+1). Cette expression est évaluée en continu Falsejusqu'à ce qu'une valeur satisfaisante jsoit trouvée, moment auquel elle est évaluée Trueet la récursivité s'arrête. Étant donné que ceux-ci sont respectivement équivalents à 0et 1en Python, et que la fonction a été ajoutée à plusieurs reprises 1via la partie d'incrémentation, la fonction revient (j-1)*False + True + (j-1)*1 = (j-1)*0 + 1 + (j-1)*1 = 1 + j-1 = j, comme requis.

Essayez-le sur Ideone

Haskell, 31 octets

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

Exemple d'utilisation: 96#2 -> 24.

Implémentation directe: essayez tous les entiers n, conservez ceux qui remplissent la condition et choisissez le premier.

05AB1E (10 octets)

>GN²m¹ÖiNq

Essayez-le en ligne

• > Lit le premier argument, l'incrémente et le pousse sur la pile
• Gouvre la pile ( a) et démarre une boucle qui contient le reste du programme où Nprend la valeur1, 2, ... a - 1 .
• N²mpousse Net la deuxième entrée de l'historique d'entrée, puis les fait éclater toutes les deux et pousse la première à la puissance de la seconde.
• ¹ pousse la première entrée de l'historique des entrées dans la pile.
• Ö ouvre les deux entrées de pile précédentes, puis pousse a % b == 0 sur la pile.
• isaute cela de la pile. Si vrai, il exécute le reste du programme; sinon, la boucle continue.
• N pousse N sur la pile.
• q termine le programme.

À la fin du programme, la valeur supérieure de la pile est imprimée.

MATL , 9 octets

y:w^w\&X<

Essayez-le en ligne!

Explication

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

En fait , 12 11 octets

Un grand merci à Leaky Nun pour ses nombreuses suggestions. Suggestions de golf bienvenues. Essayez-le en ligne!

;)R♀ⁿ♀%0@íu

Approche originale sur 12 octets. Essayez-le en ligne!

1WX│1╖╜ⁿ%WX╜

Une autre approche de 12 octets. Essayez-le en ligne!

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

Une approche sur 13 octets. Essayez-le en ligne!

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

Ungolfing:

Premier algorithme

       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.

Algorithme d'origine

       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.

Troisième algorithme

       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.

Quatrième algorithme

     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 octets , 39 octets , 37 octets , 34 octets

Je suis toujours un débutant dans la programmation R et il s'avère que c'est ma première fonction que je crée dans R ( Yay! ) Je pense donc qu'il y a encore place à l'amélioration.

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

Le test en ligne peut être effectué ici: RStudio sur rollApp .

Progrès majeurs:

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

which.maxfonctionne car il renvoie la valeur la plus élevée dans un vecteur et s'il y en a plusieurs, il retournera le premier. Dans ce cas, nous avons un vecteur de nombreux FAUX (qui sont des 0) et quelques VRAIS (qui sont des 1), il retournera donc le premier VRAI.

Un autre progrès:

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

Enfin, il bat la réponse en utilisant Python de deux octets. :)

Un autre progrès: (encore!)

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

Un grand merci à Axeman et user5957401 pour l'aide.

dc, 23 22 octets

Merci à Delioth pour son conseil sur les méthodes de saisie, la sauvegarde d'un octet

sysxz[zdlylx|0<F]dsFxp

Utilise l'opérateur de profondeur de pile zpour incrémenter le cas de test directement sur la pile et l'opérateur d'exponentiation modulaire |pour, eh bien, l'exponentiation modulaire. Répétez les tests jusqu'à ce que le reste ne soit pas supérieur à zéro.

05AB1E , 8 octets

Lsm¹%0k>

Explication

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

Essayez-le en ligne

Perl 6 ,  26  25 octets

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

Explication:

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

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

Dyalog APL , 11 octets

Traduction de ceci .

0⍳⍨⊣|(⍳⊣)*⊢

0⍳⍨trouver le premier zéro dans
⊣|les restes de division lorsque x divise
(⍳⊣)*les entiers un par x , élevé à la puissance de
⊢ y

TryAPL en ligne!

PowerShell v2 +, 48 octets

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

Prend entrée $xet $y. Construit une plage de 1à $x, puis utilise Where-Objectpour filtrer ces nombres. Le filtre prend la chaîne "$_*"(c'est-à-dire le numéro actuel avec un astérisque) et utilise la multiplication de chaîne pour concaténer ces $ytemps, puis claque une finale 1à la fin, puis redirige vers iex(court Invoke-Expressionet similaire à eval). Cela remplace [math]::Pow($_,$y), car PowerShell n'a pas d'opérateur d'exponentiation et est deux octets plus court. Qui est introduit dans l'opérateur modulo% avec $x- donc, s'il est divisible, ce sera le cas . Ainsi, s'il est divisible, il sera inclus par ce filtre et tous les autres nombres seront exclus.0 , donc nous l'encapsulons en parens et prenons le booléen-pas!(...)

Enfin, nous encapsulons les nombres résultants en parens (...)et prenons l' [0]index. Depuis la plage entrée triée1..$x , ce sera la plus petite. Cela reste sur le pipeline et l'impression est implicite.

Cas de test

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 octets

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

Perl, 29 26 octets

Comprend +3 pour -p(pas +1 car le code contient' )

Exécuter avec l'entrée sur STDIN

power.pl <<< "96 2"

power.pl:

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

Pyth, 9 octets

AQf!%^THG

Un programme qui prend en entrée une liste du formulaire [x, y]sur STDIN et imprime le résultat.

Essayez-le en ligne

Comment ça fonctionne

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 octets

Désolé, mais je ne peux pas tester cela depuis mon mobile. :)

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

Golfé

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