Dado 3 inteiros positivos a, be n(cujos valores máximos são o valor máximo inteiro representável na sua língua), saída de um valor truthy se a ≡ b (mod n)e Falsey contrário. Para aqueles que não estão familiarizados com as relações de congruência, a ≡ b (mod n)é verdadeiro se a mod n = b mod n(ou, equivalentemente (a - b) mod n = 0).

Restrições

• Métodos de teste de congruência incorporados são proibidos
• As operações internas do módulo são proibidas (isso inclui operações como a divmodfunção do Python , que retorna o quociente e o restante, bem como funções de divisibilidade, funções do sistema de resíduos e similares)

Casos de teste

(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

Esse é o código-golfe , pelo que o código mais curto (em bytes) vence, com o envio mais antigo como desempate.

Gelatina, 5 bytes

_ÆD⁵e

Fazer uso pesado de qualquer outra coisa que não seja proibida é permitido.

Experimente online!

Como funciona

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

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

Verifica se a-bé um múltiplo de n, dividindo por n, que é automaticamente nivelado e ver se a multiplicação de volta por ndá o mesmo resultado.

Julia, 24 bytes

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

Esta é uma função que aceita três números inteiros e retorna um booleano.

Nós simplesmente testar se a - b inteiro divded por n é igual a um - b flutuante dividido por n . Isso será verdade quando não houver resto da divisão, ou seja, a - b | n , o que implica que a - b (mod n ) = 0.

Pitão, 7 bytes

!@UQ-FE

Usa a indexação cíclica de Pyth.

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

Haskell, 23 bytes

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

Exemplo de uso: (28#78)5-> True.

O mesmo método da resposta do @ xnor .

Referência 0.15 , 14 11 bytes

nn-n$d:*=N.

Experimente aqui! A entrada é esperada como a b n.

Explicação:

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 bytes

Sdt:i*0hm

O formato de entrada é

[a b]
n

Experimente 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$

A entrada é fornecida em ordem unária, separada por espaço n a b. Saída 1 para verdade e 0 para falsey.

Experimente online.

Se você preferir a entrada decimal, poderá fazer o seguinte:

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

Experimente online.

APL, 15 bytes

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

Esta é uma função que aceita dyadic n do lado esquerdo e um e b como uma matriz no lado direito.

A abordagem aqui é basicamente a mesma que na minha resposta Julia . Testamos se a - b / n é igual ao próprio piso, o que será verdadeiro quando a - b (mod n ) = 0.

JavaScript (ES6), 27 bytes

@ CᴏɴᴏʀO'Bʀɪᴇɴ postou uma versão que não funciona; aqui está o "algoritmo comum" que as pessoas estão usando de uma forma que "funciona":

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

A palavra "funciona" está entre aspas, porque o atalho que estamos usando para Math.floor()trunca implicitamente um número no intervalo assinado de 32 bits, portanto, não é possível lidar com o espaço total de 52 bits ou qualquer outro que o JavaScript possa descrever.

CJam, 7 bytes

l~-\,=!

A ordem de entrada é n a b.

Teste aqui.

Explicação

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 bytes

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

pow(x,y,n)calcula (x**y)%n, então isso é justo (a-b)**1%n.

ES6, 28 bytes

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

Funciona procurando um ponto decimal em (ab) / n que, espero, seja permitido.

Sério, 10 bytes

,,,-A│\)/=

Recebe a entrada como N\nA\nB\n(letras maiúsculas usadas para distinguir das novas linhas).

Experimente online

Utiliza o mesmo método da resposta da @ AlexA

Explicação (letras maiúsculas usadas como nomes de variáveis ​​para fins explicativos):

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

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

Implementa a mesma verificação que a resposta do @ xnor .