รับ 3 จำนวนเต็มบวกa, bและn(ที่มีค่าสูงสุดเป็นค่าจำนวนเต็มสูงสุดซึ่งแสดงในภาษาของคุณ) การส่งออกมีมูลค่า truthy ถ้าa ≡ b (mod n)และ falsey มิฉะนั้น สำหรับผู้ที่ไม่คุ้นเคยกับความสัมพันธ์ที่สอดคล้องกันนั้นa ≡ b (mod n)เป็นเรื่องจริง iff a mod n = b mod n(หรือเท่ากัน(a - b) mod n = 0)

ข้อ จำกัด

• ไม่อนุญาตให้ใช้วิธีการทดสอบความสอดคล้องในตัว
• การดำเนินการแบบโมดูโลในตัวเป็นสิ่งต้องห้าม (รวมถึงการดำเนินงานเช่นdivmodฟังก์ชั่นของ Python ซึ่งส่งกลับทั้งความฉลาดทางและส่วนที่เหลือรวมถึงฟังก์ชั่นการหารฟังก์ชันการทำงานของระบบตกค้างและสิ่งอื่น ๆ )

กรณีทดสอบ

(1, 2, 3) -> False
(2, 4, 2) -> True
(3, 9, 10) -> False
(25, 45, 20) -> True
(4, 5, 1) -> True
(83, 73, 59) -> False
(70, 79, 29) -> False
(16, 44, 86) -> False
(28, 78, 5) -> True
(73, 31, 14) -> True
(9, 9, 88) -> True
(20, 7, 82) -> False

นี่คือcode-golfดังนั้นจึงเป็นรหัสสั้นที่สุด (เป็นไบต์) โดยมีการส่งที่เร็วที่สุดเป็น tiebreaker

เยลลี่ 5 ไบต์

_ÆD⁵e

อนุญาตให้ใช้สิ่งอื่นใดที่ไม่ได้รับอนุญาตเป็นจำนวนมากได้

ลองออนไลน์!

มันทำงานอย่างไร

_ÆD⁵e  Main link. Left input: a. Right input: b. Additional input: n

_      Subtract b from a.
 ÆD    Compute all divisors of the difference.
   ⁵e  Test if n is among the divisors.

Python 2, 27 ไบต์

lambda a,b,n:(a-b)/n*n==a-b

ตรวจสอบว่าa-bเป็นผลคูณของnหารด้วยnหรือไม่ซึ่งจะทำการปูพื้นโดยอัตโนมัติและดูว่าการคูณกลับด้วยการnให้ผลลัพธ์แบบเดียวกันหรือไม่

จูเลีย 24 ไบต์

f(a,b,n,t=a-b)=t÷n==t/n

นี่คือฟังก์ชั่นที่รับจำนวนเต็มสามจำนวนและส่งกลับค่าบูลีน

เราก็ทดสอบว่า- ขจำนวนเต็ม divded โดยnเท่ากับ- ขลอยหารด้วยn สิ่งนี้จะเป็นจริงเมื่อไม่มีการเหลือจากการหารนั่นคือa - b | nซึ่งหมายความว่าa - b (mod n ) = 0

Pyth, 7 ไบต์

!@UQ-FE

ใช้การจัดทำดัชนีแบบวงกลมของ Pyth

  UQ         range(first line). [0,...,Q-1]
    -FE      Fold subtraction over the second line.
 @           Cyclic index UQ at -FE
!            Logical NOT

Haskell, 23 ไบต์

(a#b)n=div(a-b)n*n==a-b

ตัวอย่างการใช้งาน: ->(28#78)5 True

วิธีการเช่นเดียวกับในคำตอบของ @ XNOR

Minkolang 0.15 , 14 11 ไบต์

nn-n$d:*=N.

ลองที่นี่! a b nการป้อนข้อมูลที่คาดว่าจะเป็น

คำอธิบาย:

n              Take number from input -> a
 n             Take number from input -> a, b
  -            Subtract               -> a-b
   n           Take number from input -> a-b, n
    $d         Duplicate stack        -> a-b, n, a-b, n
      :        Integer division       -> a-b, n, (a-b)//n
       *       Multiply               -> a-b, (a-b)//n*n
        =      1 if equal, 0 otherwise
         N.    Output as number and stop.

MATL , 9 ไบต์

Sdt:i*0hm

รูปแบบอินพุตคือ

[a b]
n

ลองออนไลน์!

S     % implicitly input [a, b]. Sort this array
d     % compute difference. Gives abs(a-b)
t:    % duplicate and generate vector [1,2,...,abs(a-b)]; or [] if a==b
i*    % input n and multiply to obtain [n,2*n,...,abs(a-b)*n]; or []
0h    % concatenate element 0
m     % ismember function. Implicitly display

เรติน่า 20

^(1+) \1*(1*) \1*\2$

มีการป้อนข้อมูลในใบสั่งตามลำดับแยกออกจากกันพร้อมกัน n a bกัน เอาท์พุท 1 สำหรับความจริงและ 0 สำหรับความเท็จ

ลองออนไลน์

ถ้าคุณชอบการป้อนทศนิยมคุณสามารถทำสิ่งนี้:

\d+
$&$*1
^(1+) \1*(1*) \1*\2$

ลองออนไลน์

APL, 15 ไบต์

{(⌊d)=d←⍺÷⍨-/⍵}

นี่คือฟังก์ชัน dyadic ที่รับnทางซ้ายและaและbเป็นอาร์เรย์ทางด้านขวา

วิธีการที่นี่เป็นพื้นเช่นเดียวกับในจูเลียของฉันคำตอบ เราทดสอบว่าa - b / nเท่ากับพื้นของตัวเองหรือไม่ซึ่งจะเป็นจริงเมื่อa - b (mod n ) = 0

JavaScript (ES6), 27 ไบต์

@ CᴏɴᴏʀO'Bʀɪᴇɴโพสต์เวอร์ชันที่ใช้งานไม่ได้ นี่คือ "อัลกอริทึมทั่วไป" ที่ผู้คนใช้ในรูปแบบที่ "ใช้งาน":

(a,b,n)=>n*(0|(a-b)/n)==a-b

คำว่า "ทำงาน" อยู่ในเครื่องหมายคำพูดที่ทำให้ตกใจเพราะทางลัดที่เราใช้สำหรับMath.floor()ตัดทอนหมายเลขให้อยู่ในช่วง 32 บิตที่ได้รับการรับรองดังนั้นสิ่งนี้จึงไม่สามารถจัดการกับจำนวนเต็ม 52 บิตหรืออะไรก็ได้ที่ JavaScript สามารถทำได้ อธิบาย.

CJam, 7 ไบต์

l~-\,=!

n a bเพื่อป้อนข้อมูลเป็น

ทดสอบที่นี่

คำอธิบาย

l~  e# Read input and evaluate to push n, a and b onto the stack.
-   e# Subtract b from a.
\,  e# Swap with n and turn into range [0 1 ... n-1].
=   e# Get (a-b)th element from that range, which uses cyclic indexing. This is
    e# equivalent to modulo, and as opposed to the built-in % it also works correctly
    e# for negative (a-b).
!   e# Negate, because a 0 result from the previous computation means they are congruent.

Python 3, 27 ไบต์

lambda a,b,n:pow(a-b,1,n)<1

pow(x,y,n)คำนวณดังนั้นนี้เป็นเพียง(x**y)%n(a-b)**1%n

ES6, 28 ไบต์

(a,b,n)=>!/\./.test((a-b)/n)

ทำงานโดยการค้นหาจุดทศนิยมใน (ab) / n ซึ่งฉันหวังว่าจะได้รับอนุญาต

อย่างจริงจัง 10 ไบต์

,,,-A│\)/=

ใช้อินพุตเป็นN\nA\nB\n(ตัวพิมพ์ใหญ่ที่ใช้เพื่อแยกความแตกต่างจากบรรทัดใหม่)

ลองออนไลน์

วิธีนี้ใช้วิธีเดียวกับคำตอบของ @ AlexA

คำอธิบาย (อักษรตัวใหญ่ที่ใช้เป็นชื่อตัวแปรเพื่อวัตถุประสงค์ในการอธิบาย):

,,,-A│\)/=
,,,         push N, A, B
   -A       push C = abs(A-B)
     │      duplicate entire stack (result is [N, C, N, C])
      \)/=  1 if C//N == C/N (floored division equals float division)

F #, 24 ไบต์

fun a b n->(a-b)/n*n=a-b

ดำเนินการตรวจสอบเช่นเดียวกับคำตอบของ @ XNOR