ให้nและbจะ integers 1บวกขนาดใหญ่กว่า
ขาออกห่างจากอำนาจต่อไปของnb
สำหรับn=5และb=3อำนาจต่อไปของการ3จาก5เป็น9( 3^2 = 9) 9 - 5 = 4เพื่อส่งออกเป็น
สำหรับn=8และb=2อำนาจต่อไปของการ2จาก8เป็น16( 2^4 = 16) 16 - 8 = 8เพื่อส่งออกเป็น โปรดทราบว่าnเป็นพลังของ2ในตัวอย่างนี้
Testcases:
n b output
212 2 44
563 5 62
491 5 134
424 3 305
469 8 43
343 7 2058
592 7 1809
289 5 336
694 3 35
324 5 301
2 5 3
นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์ ช่องโหว่มาตรฐานใช้
คำตอบ:
ạæċ
ลิงค์ dyadic จะnอยู่ทางซ้ายและbทางขวาและส่งคืนผลลัพธ์
ạæċ - Link: number n, number b | n,b ∈ ℕ
æċ - ceiling n to the next power of b
ạ - absolute difference between n and that
;)
æċ!" แทนที่จะ "เป็น
æċ_⁸
วิธีการทำซ้ำ (แต่ svelte!) ที่ไม่มีประสิทธิภาพ (โดยให้เครดิตกับ @Neil สำหรับแรงบันดาลใจ):
HowFarAway PROC
6A 01 push 1
58 pop rax ; temp = 1
Loop:
0F AF C2 imul eax, edx ; temp *= b
39 C8 cmp eax, ecx
72 F9 jb Loop ; keep looping (jump) if temp < n
29 C8 sub eax, ecx ; temp -= n
C3 ret ; return temp
HowFarAway ENDP
ฟังก์ชั่นข้างต้นใช้สองพารามิเตอร์จำนวนเต็มn(ผ่านในการECXลงทะเบียน) และb(ผ่านในการEDXลงทะเบียน) และส่งกลับผลจำนวนเต็มเดียว (ในการEAXลงทะเบียน) ในการโทรจาก C คุณจะต้องใช้ต้นแบบต่อไปนี้:
unsigned HowFarAway(unsigned n, unsigned b);
สิ่งนี้ จำกัด อยู่ในช่วงของจำนวนเต็ม 32 บิต สามารถแก้ไขได้อย่างง่ายดายเพื่อรองรับจำนวนเต็ม 64- บิตโดยใช้การลงทะเบียนแบบยาว แต่จะเสียค่าใช้จ่ายมากขึ้นเมื่อต้องเข้ารหัสไบต์คำแนะนำเหล่านั้น :-)
push 1+ ได้pop raxใน 3 ไบต์เท่านั้น แต่ ... jmpแล้วคุณจะได้ไม่ต้องข้ามคูณเพื่อที่จะยังคงมีเงินออมที่เหมาะสมเพราะคุณสามารถวาง
f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}บันทึก 5 ไบต์และสนับสนุนโดย gcc
b-=nล่ะ
b-=nถ้าคุณสลับคำสั่งของbและn?
บันทึก 2 ไบต์ด้วย @ZacharyT
⊢-⍨⊣*1+∘⌊⍟
รับnอาร์กิวเมนต์ที่ถูกต้องและbอาร์กิวเมนต์ซ้าย
คำนวณb⌊logbn + 1⌋ - n
⊣-⍨⊢*1+∘⌊⍟⍨.
⊢-⍨⊣*1+∘⌊⍟10 ไบต์ แต่มีการสลับสับเปลี่ยนดังนั้นนั่นnคืออาร์กิวเมนต์ที่ถูกต้องและbเป็นอาร์กิวเมนต์ซ้าย ฉันใช้กลอุบายของ ZacharyT ใน1+∘⌊การทำให้มันลงไปไกลขนาดนี้
pryr::f({a=b^(0:n)-n;min(a[a>0])})ฟังก์ชั่นไม่ระบุชื่อ เก็บค่าทั้งหมดของ b ไปที่กำลังของทุกอย่างในช่วง [0, n], ลบ n จากแต่ละส่วนย่อยในค่าบวกและส่งคืนค่า min
TIO มีรุ่นที่ไม่ใช่ pryr เรียกว่าf(n,b); รุ่นนี้จะต้องมีการเรียกว่าf(b,n)รุ่นนี้จะต้องเรียกว่าเป็น
บันทึกไปแล้ว 4 ไบต์ขอบคุณ Jarko Dubbeldam ซึ่งทำให้ฉันแย่กว่า
pryr::f({a=b^(0:n)-n;min(a[a>0])})สั้นลงไม่กี่ไบต์
pryr::fเมื่อฉันกำหนดตัวแปรใหม่ในฟังก์ชั่น; ดูเหมือนว่ามันทำงานที่นี่
sapply(x, sum)ๆ หรืออะไรก็ตามที่มันเพิ่มsumเข้ากับข้อโต้แย้ง
-4 ไบต์ขอบคุณ MickyT
Pwp.I|-.;)^0@O?|uq;<
อ่านในการป้อนข้อมูลเช่น n,b
พอดีกับก้อน 2x2x2:
P w
p .
I | - . ; ) ^ 0
@ O ? | u q ; <
. .
. .
I|I0 : อ่านอินพุตกด 0 (ตัวนับ) ไปที่สแต็ก
^w วาง IP ให้ถูกที่สำหรับลูป:
Pp-: คำนวณb^(counter)เลื่อนnไปด้านบนสุดของสแต็กคำนวณb^(counter) - n? : เลี้ยวซ้ายถ้าเป็นลบตรงถ้า 0 ถูกต้องถ้าเป็นบวก
O@เอาท์พุทด้านบนของสแต็ค (ระยะทาง) และออก|?ดำเนินการต่อราวกับว่าส่วนบนของสแต็กเป็นศูนย์<;qu;): ชี้ IP ไปในทิศทางที่ถูกต้องปรากฏที่ด้านบนสุดของสแต็ค (หมายเลขลบ / ศูนย์) เลื่อนnไปที่ด้านล่างของสแต็กกลับไปที่ป๊อปอัพด้านบนของสแต็ก (b^(counter) ) และเพิ่มตัวนับ^wและโปรแกรมดำเนินการต่อPwp.I|-.;)^0@O?|uq;<
sLmʒ‹}α¬
คำอธิบาย
s # swap order of the inputs
L # range [1 ... n]
m # raise b to each power
ʒ‹} # filter, keep only the elements greater than n
α # calculate absolute difference with n for each
¬ # get the first (smallest)
ć ¬
nโดยนัยทั้งในการเปรียบเทียบตัวกรองและการคำนวณผลต่างแน่นอน
ขึ้นอยู่กับ@ GovindParmar คำตอบของ
n->b->{for(int o=b;n>=b;b*=o);return b-n;}yy:YAn^w-
พิจารณาอินพุต694และ3เป็นตัวอย่าง
y % Implicitly take two inputs. Duplicate from below
% STACK: 694, 3, 694
y % Duplicate from below
% STACK: 694, 3, 694, 3
: % Range
% STACK: 694, 3, 694, [1 2 3]
YA % Base conversion (of 694 with "digits" given by [1 2 3]
% STACK: 694, 3, [3 3 2 3 1 2]
n % Number of elements
% STACK: 694, 3, 6
^ % Power
% 694, 729
w % Swap
% STACK: 729, 694
- % Subtract. Implicitly display
^ % 35
คล้ายกับแนวทางของ Rickแต่โพสต์เมื่อได้รับอนุญาตจากเขา (และบางคนช่วยประหยัด byte)
n=>b=>g=(x=b)=>x>n?x-n:g(x*b)
f=
n=>b=>g=(x=b)=>x>n?x-n:g(x*b)
oninput=_=>o.value=f(+i.value)(+j.value)()
o.value=f(i.value=324)(j.value=5)()*{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}<label for=i>n: </label><input id=i type=number><label for=j>b: </label><input id=j type=number><label for=o>= </label><input id=o>#2^⌊1/#~Log~#2⌋#2-#&
ขอบคุณมาร์ติน
I / O
[343, 7]
2058
1/Log@## #2~Log~#หรือดียิ่งขึ้นสลับคำสั่งของปัจจัยการผลิตและLog@##การใช้งาน
#^Floor[...]# #^(Floor[...]+1)และมีผู้ให้บริการ Unicode ด้วยFloorเช่นกัน
Log@##! ที่จริงถ้าคุณสลับลำดับอาร์กิวเมนต์#^⌊Log@##⌋#-#2&ควรเป็นไปได้ที่ -5 ไบต์ (ฉันคิดว่า)!
ขอบคุณ commenter @Steadybox สำหรับคำแนะนำ
o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}
forแทนการwhileบันทึกสองไบต์:o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}
n/bแทนn>=b
pryr::f(b^floor(log(n,b)+1)-n)
ประเมินฟังก์ชั่น
function (b, n)
b^floor(log(n, b) + 1) - n
ซึ่งใช้พลังงานครั้งแรกมากกว่าหรือเท่ากับ n, and then substracts n from that value.
Changed ceiling(power) to floor(power+1) to ensure that if n is a power of b, we take the next power.
n and b or just n), because that saves you from having to pass n recursively.
n=>g=(b,p=b)=>p>n?p-n:g(b,p*b) and n=>b=>(g=p=>p>n?p-n:g(p*b))(b).
f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i) work for 30 bytes? It would need to be called like so: f(324,5)(). EDIT: Ah, @Neil beat me to it.
Two different approaches:
->(n,b){p b**(Math.log(n,b).to_i+1)-n}->(n,b){p b**(0..n).find{|x|b**x>n}-n}->\n,\b{(b,b* *...*>n).tail -n}->\n,\b{b**(log(n,b).Int+1)-n}{$^b**(log($^a,$b).Int+1)-$a}{($^b,$b* *...*>$^a).tail-$a}f(n,b)=b^logint(b*n,b)-n
_q}a@nVpX
_ q}a@ nVpX
Z{Zq}aX{UnVpX} // Ungolfed
// Implicit: U, V = input integers
aX{ } // For each integer X in [0...1e9), take
VpX // V to the power of X
Un // minus U,
Z{ } // and return the first one Z where
Zq // Math.sqrt(Z) is truthy.
// Math.sqrt returns NaN for negative inputs, and 0 is falsy, so this is
// truthy iff Z is positive. Therefore, this returns the first positive
// value of V**X - U.
// Implicit: output result of last expression
f=lambda a,b,v=1:(a<v)*(v-a)or f(a,b,v*b)A recursive function which, starting with v=1, repeatedly multiplies by b until it strictly exceeds a and then returns the difference.
Note: The result will never be zero so a>=v and f(a,b,v*b)or v-a may be replaced with (a<v)*(v-a)or f(a,b,v*b) without causing recursion errors.
Using an idea of rici's...
f=lambda n,b:(n<b)*(b-n)or b*f(n/b,b)which uses floating point arithmetic (hence results may stray from their true distance),
try that here.
b-n never being zero at the same time as n<b is true).
^ʰ↙X>₁-
Takes input as a list [b, n].
>₁ n is strictly less than
^ ↙X some power of
ʰ b,
- and their difference is
the output.
A straight forward solution, I'm using 10 bytes to ensure that the arguments are treated as numbers, and not strings. Outputs to STDIN.
Edit: forgot to remove the space in w=1 n=n+0, saves one byte
n,b=...b=b+0p=b w=1n=n+0while p<=n do p=math.pow(b,w)w=w+1 end print(p-n)n,b=... -- unpack the argument into the variable n and b
b=b+0 -- set b's type to number
n=n+0 -- set n's type to number
p=b -- set a variable to track the current value of the powered b
w=1 -- set the nth power
while p<=n -- iterate untill the current power is greater or equals to n
do
p=math.pow(b,w) -- raise b to the power w
w=w+1 -- increment w
end
print(p-n) -- outputs p minus the following power of b1 and end needed?
1end would start to be interpreted as the number 1e then throw an error because 1en isn't a valid hexadecimal value. This only occure when the letter following the number is [abcdef] as other letters can't be interpreted as hexadecimal value -> w=1while doesn't throw an error.
{p=:^q~p>:|_xp-b|\q=q+1
Takes parameter b first, then n.
{ DO
p=:^q SET p to input b (read as 'a' by QBIC fromt he cmd line) ** q (starts as 1)
~p>: IF p exceeds 'n' (read as 'b' by QBIC fromt he cmd line)
|_xp-b| THEN QUIT, printing p minus b
\q=q+1 ELSE increase q, re-run
Full program without recursion or bit twiddling:
i=1;n,b=input()
while n>=i:i*=b
print i-nInput format: n, b.
Thanks to EriktheOutgolfer for saving 2 bytes!
lambda n,b:b**-~int(math.log(n,b))-n
import mathPython doesn't have any fancy log or ceiling builtins, so I just went with the obvious approach with a little bit of golfing flair.
import math;lambda n,b:b**-~int(math.log(n,b))-n saves two bytes and is allowed per meta consensus.
ceil would not work.
ceil because it doesn't work for powers of b, but as @Uriel pointed out importing before still saves a byte.
import after the lambda, and add f= in the header.
(defun f(n b)(setq a b)(loop(when(> b n)(return(- b n)))(setq b(* b a))))