Görev

Tamsayılar göz önüne alındığında xve yher ikisi de en azından 2, y-gücü ikiye bölünebilen en küçük pozitif sayıyı bulun x.

Misal

Verilen x=96ve y=2çıkış olmalı, 24çünkü 24en küçük pozitif ntatmin n^2 is divisible by 96.

testcases

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

puanlama

Bu kod golfü . En düşük bayt sayısına sahip çözüm kazanır.

Referanslar

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

@LeakyNun sayesinde 2 bayt kaydedildi.

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

Çevrimiçi deneyin!

açıklama

               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

Jöle , 6 bayt

ÆE÷ĊÆẸ

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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

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

Jöle , 6 bayt

R*%⁸i0

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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 bayt

Yardım için @LeakyNun ve @ Sp3000'e teşekkürler

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

Bağımsız değişken üzerinden girdi alan ve çıktıyı döndüren bir işlev.

Nasıl çalışır

Fonksiyon kullanımları tekrarlama defalarca tamsayılar kontrol etmek i, başlayarak i=1gerekli koşulunu sağlayan biri kadar, burada i**y%x<1, bulunur. Bu, artışın orifadesinin koşulunun mantığı ve sonucunun alınmasıyla elde edilir i+1, burada -~f(x,y,i+1). Bu ifade False, tatmin edici bir değer bulunana kadar sürekli olarak değerlendirilir; jbu noktada değerlendirir Trueve özyineleme durur. Bunlar sırasıyla Python'a 0ve 1Python'a eşdeğer olduğundan ve işlev art arda 1gelen kısım aracılığıyla tekrar tekrar eklendiğinden , işlev geri döner(j-1)*False + True + (j-1)*1 = (j-1)*0 + 1 + (j-1)*1 = 1 + j-1 = j gerektiği gibi .

Ideone üzerinde deneyin

Haskell, 31 bayt

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

Kullanım örneği: 96#2 -> 24.

Doğrudan uygulama: tüm tam sayıları deneyin n, koşulu karşılayanları koruyun ve ilkini seçin.

05AB1E (10 bayt)

>GN²m¹ÖiNq

Çevrimiçi deneyin

• > İlk argümanı okur, artırır ve yığının üzerine iter
• Gyığını ( a) açar ve programın geri kalanını içeren Nve değeri alan bir döngü başlatır1, 2, ... a - 1 .
• N²mNgiriş geçmişinden ikinci girişi iter , sonra ikisini birden açar ve ilk girişi ikincisinin gücüne iter.
• ¹ ilk girişi giriş geçmişinden yığına iter.
• Öönceki iki yığın girdisini açar, ardından a % b == 0yığını iter .
• iyığınından çıkar. Doğruysa, programın geri kalanını yürütür; aksi takdirde döngü devam eder.
• NNyığını iter .
• q programı sonlandırır.

Program sona erdiğinde, yığının en yüksek değeri yazdırılır.

MATL , 9 bayt

y:w^w\&X<

Çevrimiçi deneyin!

açıklama

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

Aslında , 12 11 bayt

Leaky Nun'e önerileri için çok teşekkürler. Golf önerileri hoş geldiniz. Çevrimiçi deneyin!

;)R♀ⁿ♀%0@íu

Orijinal 12 baytlık yaklaşım. Çevrimiçi deneyin!

1WX│1╖╜ⁿ%WX╜

Başka bir 12 baytlık yaklaşım. Çevrimiçi deneyin!

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

13 baytlık bir yaklaşım. Çevrimiçi deneyin!

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

Ungolfing:

İlk algoritma

       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.

Orijinal algoritma

       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.

Üçüncü algoritma

       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.

Dördüncü algoritma

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

Ben hala R programlamasında yeniyim ve bu benim R'de oluşturduğum ilk işlevim ( Yay! ) ' Da için hala iyileştirme için yer olduğuna inanıyorum.

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

Online test burada yapılabilir: RStudio on rollApp .

Büyük ilerleme:

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

which.maxçünkü bir vektördeki en yüksek değeri döndürür ve birden fazla varsa ilk değeri döndürür. Bu durumda, birçok YANLIŞ (0s) ve birkaç TRUE (1s) olan bir vektörünüz vardır, bu nedenle ilk TRUE değerini döndürür.

Başka bir gelişme:

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

Son olarak, Python kullanarak cevabı iki baytla yener. :)

Başka bir gelişme: (Tekrar!)

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

Birçok sayesinde Baltacı ve user5957401 yardım için.

dC, 23 22 bayt

Giriş yöntemleri hakkındaki ipucu için Delioth'a teşekkürler, bir bayt tasarrufu

sysxz[zdlylx|0<F]dsFxp

zTest vakasını doğrudan istif üzerinde artırmak için yığın derinliği operatörünü ve |kuyu modüler üs alma için modüler üs alma operatörünü kullanır. Kalan sıfırdan büyük olmayana kadar testi tekrarlayın.

05AB1E , 8 bayt

Lsm¹%0k>

açıklama

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

Çevrimiçi deneyin

Perl 6 ,  26  25 bayt

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

Açıklama:

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

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

Dyalog APL , 11 bayt

Çevrilmesi bu .

0⍳⍨⊣|(⍳⊣)*⊢

0⍳⍨ilk sıfır bulmak
⊣|bölme kalanlar zaman x bölme
(⍳⊣)*tamsayılardır boyunca bir x gücüne yükseltilmiş,
⊢ y

TryAPL çevrimiçi!

PowerShell v2 +, 48 bayt

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

Girdi alır $xve $y. İle arasında bir aralık 1oluşturur $x, ardından Where-Objectbu sayıları filtrelemek için kullanır . Filtre, dizeyi alır "$_*"(yani, bir yıldız işaretiyle geçerli sayı) ve bu $yzamanları birleştirmek için dize çarpımını kullanır , daha sonra 1sonunda bir finali bitirir , sonra bunu iex(kısaltması Invoke-Expressionve benzerleri eval) yapar. [math]::Pow($_,$y)PowerShell'in bir üstelleştirme operatörü olmadığından ve iki bayt daha kısa olduğu için bu yer alır . Bu modül operatör beslenmiştir var %olan $xbu bölünebilir ise bu nedenle, bu olacak -0 biz Pars o içlerine alırlar ve Boole-değil almak yüzden,!(...)içerir. Böylece, bölünebilirse, bu filtreye dahil edilir ve diğer tüm sayılar hariç tutulur.

Son olarak, elde edilen sayıları parenler içine (...)alır ve [0]dizini alırız . Girilen aralık sıralandığından 1..$x, bu en küçük olacaktır. Boru hattında kalan ve baskı örtük.

Test senaryoları

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 bayt

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

Perl, 29 26 bayt

İçin +3 içerir -p(kod içerdiğinden +1 değil ')

STDIN üzerindeki giriş ile çalıştırın

power.pl <<< "96 2"

power.pl:

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

Pyth, 9 bayt

AQf!%^THG

[x, y]STDIN'deki formun bir listesini alan ve sonucu basan bir program .

Çevrimiçi deneyin

Nasıl çalışır

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 bayt

Üzgünüm, ama bunu cep telefonumdan test edemiyorum. :)

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

golfed

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