งาน

ได้รับจำนวนเต็มxและyซึ่งมีทั้งที่อย่างน้อย2หาจำนวนบวกที่เล็กที่สุดที่มีyอำนาจ -th xหารด้วย

ตัวอย่าง

ได้รับx=96และy=2การส่งออกที่ควรจะเป็น24ตั้งแต่24เป็นบวกที่เล็กที่สุดที่น่าพอใจnn^2 is divisible by 96

Testcases

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 ไบต์

บันทึก 2 ไบต์ด้วย @LeakyNun

:[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#224

การใช้งานโดยตรง: ลองใช้จำนวนเต็มทั้งหมดnรักษาค่าที่ตรงกับเงื่อนไขและเลือกค่าแรก

05AB1E (10 ไบต์)

>GN²m¹ÖiNq

ลองออนไลน์

• > อ่านอาร์กิวเมนต์แรกเพิ่มขึ้นและส่งไปที่สแต็ก
• Gดึง stack ( a) และเริ่มการวนซ้ำที่มีส่วนที่เหลือของโปรแกรมที่Nรับค่า1, 2, ... a - 1จะใช้เวลาในค่า
• N²mพุชNและรายการที่สองจากประวัติอินพุตจากนั้นป็อปทั้งสองและผลักดันรายการแรกสู่พลังของวินาที
• ¹ ดันรายการแรกจากประวัติอินพุตไปยังสแต็ก
• Ö แสดงรายการสแต็กสองรายการก่อนหน้าจากนั้นกด a % b == 0สแต็ก
• iปรากฏที่จากสแต็ก หากเป็นจริงจะดำเนินการส่วนที่เหลือของโปรแกรม มิฉะนั้นการวนซ้ำจะดำเนินต่อไป
• 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

Ungolfing:

ขั้นตอนวิธีแรก

       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 บน rollApp

ความคืบหน้าสำคัญ:

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

which.maxใช้งานได้เพราะมันคืนค่าสูงสุดในเวกเตอร์และหากมีหลายค่ามันจะคืนค่าแรก ในกรณีนี้เรามีเวกเตอร์ของ FALSE จำนวนมาก (ซึ่งคือ 0s) และ TRUEs สองสามอัน (ซึ่งคือ 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หาร
(⍳⊣)*จำนวนเต็มหนึ่งถึงxยกกำลังของ
⊢ y

ลองใช้ออนไลน์!

PowerShell v2 +, 48 ไบต์

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

จะเข้าและ$x $yสร้างช่วงจาก1ถึง$xจากนั้นใช้Where-Objectเพื่อกรองตัวเลขเหล่านั้น ตัวกรองจะใช้สตริง"$_*"(เช่นหมายเลขปัจจุบันที่มีเครื่องหมายดอกจัน) และใช้การคูณสตริงเพื่อต่อ$yเวลาเหล่านั้นจากนั้น tacks ที่สุดท้าย1ในตอนท้ายจากนั้นไปป์ที่iex(สั้นInvoke-Expressionและคล้ายกับeval) สิ่งนี้เกิดขึ้น[math]::Pow($_,$y)เนื่องจาก PowerShell ไม่มีตัวดำเนินการการยกกำลังและสั้นลงสองไบต์ นั่นถูกป้อนเข้าสู่โอเปอเรเตอร์ของโมดูโล%ด้วย$x- ดังนั้นถ้ามันหารได้นี่จะเป็น0ดังนั้นเราจึงสรุปแค็ปซูลใน parens และใช้บูลีน!(...)มันได้ ดังนั้นหากแบ่งได้ตัวกรองนี้จะรวมอยู่ในตัวกรองนี้และหมายเลขอื่น ๆ ทั้งหมดจะถูกยกเว้น

สุดท้ายเราสรุปแค็ปซูลตัวเลขผลลัพธ์ใน parens (...)และนำ[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;}