Dato 3 interi positivi a, be n(i cui valori massimi sono il valore massimo intero rappresentabile nella tua lingua), in uscita un valore truthy se a ≡ b (mod n), e Falsey altrimenti. Per chi non ha familiarità con le relazioni di congruenza, a ≡ b (mod n)è vero iff a mod n = b mod n(o, equivalentemente, (a - b) mod n = 0).

restrizioni

• I metodi di test di congruenza integrati sono vietati
• Sono vietate le operazioni integrate nel modulo (questo include operazioni come la divmodfunzione di Python , che restituiscono sia il quoziente che il resto, nonché le funzioni di divisibilità, funzioni di sistema dei residui e simili)

Casi test

(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

Questo è code-golf , quindi vince il codice più breve (in byte), con la prima presentazione come tiebreaker.

Gelatina, 5 byte

_ÆD⁵e

È consentito l' uso intensivo di qualsiasi altra cosa non vietata.

Provalo online!

Come funziona

_Æ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 byte

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

Verifica se si a-btratta di un multiplo ndividendo per n, che automaticamente si pavimenta, e vedendo se moltiplicare indietro per ndà lo stesso risultato.

Julia, 24 byte

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

Questa è una funzione che accetta tre numeri interi e restituisce un valore booleano.

Testiamo semplicemente se il numero intero a - b diviso per n è uguale al float a - b diviso per n . Questo sarà vero quando non ci sono residui dalla divisione, cioè a - b | n , il che implica che a - b (mod n ) = 0.

Pyth, 7 byte

!@UQ-FE

Utilizza l'indicizzazione ciclica di Pyth.

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

Haskell, 23 byte

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

Esempio di utilizzo: (28#78)5-> True.

Stesso metodo della risposta di @ xnor .

Minkolang 0,15 , 14 11 byte

nn-n$d:*=N.

Provalo qui! L'input è previsto come a b n.

Spiegazione:

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 byte

Sdt:i*0hm

Il formato di input è

[a b]
n

Provalo online!

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

Retina , 20

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

L'input è dato in unario, separato dallo spazio, in ordine n a b. Uscita 1 per verità e 0 per falsità.

Provalo online.

Se si preferisce un input decimale, è possibile farlo:

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

Provalo online.

APL, 15 byte

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

Questa è una funzione che accetta diadica n sulla sinistra e un e b come una matrice a destra.

L'approccio qui è sostanzialmente lo stesso della mia risposta Julia . Testiamo se a - b / n è uguale al piano di se stesso, il che sarà vero quando a - b (mod n ) = 0.

JavaScript (ES6), 27 byte

@ CᴏɴᴏʀO'Bʀɪᴇɴ ha pubblicato una versione che non funziona; ecco l'algoritmo comune che le persone usano in una forma che "funziona":

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

La parola "funziona" è racchiusa tra virgolette perché il collegamento che stiamo utilizzando per Math.floor()troncare implicitamente un numero compreso nell'intervallo con segno a 32 bit, quindi questo non può gestire l'intero spazio a 52 bit o qualunque numero di numeri interi che JavaScript può descrivere.

CJam, 7 byte

l~-\,=!

L'ordine di input è n a b.

Provalo qui.

Spiegazione

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 byte

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

pow(x,y,n)calcola (x**y)%n, quindi questo è giusto (a-b)**1%n.

ES6, 28 byte

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

Funziona cercando un punto decimale in (ab) / n che spero sia permesso.

Scherzi a parte, 10 byte

,,,-A│\)/=

Prende l'input come N\nA\nB\n(lettere maiuscole utilizzate per distinguere dalle nuove righe).

Provalo online

Questo utilizza lo stesso metodo della risposta di @ AlexA

Spiegazione (lettere maiuscole utilizzate come nomi di variabili a fini esplicativi):

,,,-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 byte

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

Implementa lo stesso controllo della risposta di @ xnor .