任务

给定整数，x并且y它们都至少是2，找到y-次幂可被整除的最小正数x。

例

给定x=96和y=2，输出应该是24因为24是最小的正n满足n^2 is divisible by 96。

测试用例

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

计分

这是代码高尔夫球。字节数最少的解决方案获胜。

参考文献

• 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字节

感谢@LeakyNun，节省了2个字节。

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

在线尝试！

说明

               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

果冻，6 个字节

ÆE÷ĊÆẸ

在线尝试！或验证所有测试用例。

怎么运行的

Æ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个字节

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

果冻，6 个字节

R*%⁸i0

在线尝试！或验证所有测试用例。

怎么运行的

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个字节

感谢@LeakyNun和@ Sp3000的帮助

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

一个通过参数获取输入并返回输出的函数。

怎么运行的

该函数使用递归来重复检查以i开头的整数，i=1直到找到一个满足所需条件的整数（此处i**y%x<1为）。这是通过将or条件的逻辑和表达式的结果进行i+1递增来实现的，此处为-~f(x,y,i+1)。该表达式持续求值，False直到j找到满意的值为止，在该点上求值True并递归停止。由于这些分别相当于0和1在Python中，并且函数已1通过递增部分反复添加，因此该函数返回(j-1)*False + True + (j-1)*1 = (j-1)*0 + 1 + (j-1)*1 = 1 + j-1 = j根据需要。

在Ideone上尝试

Haskell，31个字节

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

用法示例：96#2-> 24。

直接实现：尝试所有整数n，保留符合条件的整数，然后选择第一个整数。

05AB1E（10个字节）

>GN²m¹ÖiNq

在线尝试

• > 读取第一个参数，对其进行递增，然后将其压入堆栈
• G弹出堆栈（a）并启动一个循环，该循环包含该程序的其余部分，并N采用该值1, 2, ... a - 1。
• N²mN从输入历史记录中推入和输入第二个条目，然后将它们都弹出，并将第一个推入第二个的幂。
• ¹ 将输入历史记录中的第一个条目压入堆栈。
• Ö 弹出前两个堆栈条目，然后按入 a % b == 0入堆栈。
• i从堆栈中弹出。如果为true，它将执行程序的其余部分；否则为false。否则，循环将继续。
• N 推 N入堆栈。
• q 终止程序。

程序终止时，将打印堆栈的最高值。

MATL，9字节

y:w^w\&X<

在线尝试！

说明

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

事实上，12 11个字节

非常感谢Leaky Nun的许多建议。欢迎打高尔夫球。在线尝试！

;)R♀ⁿ♀%0@íu

原始的12字节方法。在线尝试！

1WX│1╖╜ⁿ%WX╜

另一种12字节方法。在线尝试！

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

13字节的方法。在线尝试！

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

开球：

第一种算法

       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.

原始算法

       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.

第三算法

       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.

第四算法

     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字节，39字节，37字节，34字节

我仍然是R编程的新手，事实证明这是我在R（Yay！）中创建的第一个函数，因此我相信仍有改进的空间。

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

在线测试可以在这里进行：RStudio on rollApp。

主要进展：

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

which.max之所以起作用，是因为它返回向量中的最大值，如果有多个，它将​​返回第一个。在这种情况下，我们有一个包含许多FALSE（为0）和一些TRUE（为1）的向量，因此它将返回第一个TRUE。

另一个进展：

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

最后，它使用Python击败了两个字节。 :)

另一个进展：（再次！）

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

非常感谢Axeman和user5957401的帮助。

直流电 23 22字节

感谢Delioth关于输入法的技巧，节省了一个字节

sysxz[zdlylx|0<F]dsFxp

使用堆栈深度运算符z直接在堆栈上增加测试用例，并使用模块化指数运算符|进行模块化幂运算。重复测试，直到余数不大于零。

05AB1E，8个字节

Lsm¹%0k>

说明

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

在线尝试

Perl 6，  26  25个字节

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

说明：

# 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个字节

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

Dyalog APL，11 个字节

这个的翻译。

0⍳⍨⊣|(⍳⊣)*⊢

0⍳⍨
⊣|当x将
(⍳⊣)*整数1 除以x并提高到y的幂时，在除法余数中找到第一个零
⊢

在线尝试APL！

PowerShell v2 +，48字节

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

接受输入$x和$y。构造一个从1到的范围$x，然后用于Where-Object过滤这些数字。过滤器将字符串"$_*"（即带星号的当前数字）作为字符串，并使用字符串乘法来连接这些$y时间，然后1在末尾加大头，然后将其传递给iex（缩写Invoke-Expression和类似eval）。[math]::Pow($_,$y)由于PowerShell没有幂运算符，并且短了两个字节，因此它代替了。这将%通过$x- 馈入模运算符，因此，如果可以将其整除，则将其取整。因此，如果将其整除，它将包含在此过滤器中，所有其他数字都将被排除。0，因此我们将其封装在parens中，并采用Boolean-not!(...)

最后，我们将结果数字封装在括号中(...)并获取[0]索引。由于输入的范围已排序1..$x，因此它将是最小的。剩下的就在管道上，打印是隐式的。

测试用例

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字节

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

Perl，29个 26字节

包括+3 -p（因为代码包含，所以不能为+1 '）

使用STDIN上的输入运行

power.pl <<< "96 2"

power.pl：

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

Pyth，9个字节

AQf!%^THG

一个程序，该程序[x, y]在STDIN上输入表单列表并打印结果。

在线尝试

怎么运行的

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字节

抱歉，但是我无法通过手机进行测试。:)

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

打高尔夫球

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