Dado 3 enteros positivos a, by n(cuyos valores máximos son el valor entero máximo representable en su idioma), un valor de salida Truthy si a ≡ b (mod n), y Falsey- lo contrario. Para aquellos que no están familiarizados con las relaciones de congruencia, a ≡ b (mod n)es cierto iff a mod n = b mod n(o, equivalentemente (a - b) mod n = 0).

Restricciones

• Los métodos de prueba de congruencia incorporados están prohibidos
• Las operaciones de módulo divmodintegradas están prohibidas (esto incluye operaciones como la función de Python , que devuelve tanto el cociente como el resto, así como las funciones de divisibilidad, funciones del sistema de residuos y similares)

Casos de prueba

(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

Este es el código de golf , por lo que gana el código más corto (en bytes), con el envío más temprano como desempate.

Jalea, 5 bytes

_ÆD⁵e

Se permite hacer un uso intensivo de cualquier otra cosa que no esté prohibida.

Pruébalo en línea!

Cómo 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

Comprueba si a-bes un múltiplo de ndividiendo entre n, lo que automáticamente hace pisos, y viendo si multiplicar de nuevo por nda el mismo resultado.

Julia, 24 bytes

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

Esta es una función que acepta tres enteros y devuelve un valor booleano.

Simplemente probamos si a - b entero dividido por n es igual a a - b flotante dividido por n . Esto será cierto cuando no haya resto de la división, es decir, a - b | n , lo que implica que a - b (mod n ) = 0.

Pyth, 7 bytes

!@UQ-FE

Utiliza la indexación 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

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

El mismo método que en la respuesta de @ xnor .

Minkolang 0.15 , 14 11 bytes

nn-n$d:*=N.

Pruébalo aquí! La entrada se espera como a b n.

Explicació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 bytes

Sdt:i*0hm

El formato de entrada es

[a b]
n

Pruébalo en línea!

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$

La entrada se da en unario, separados por espacios, en orden n a b. Salida 1 para la verdad y 0 para falsey.

Pruébalo en línea.

Si prefiere la entrada decimal, puede hacer esto:

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

Pruébalo en línea.

APL, 15 bytes

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

Esta es una función diádica que acepta n a la izquierda y a y b como una matriz a la derecha.

El enfoque aquí es básicamente el mismo que en mi respuesta de Julia . Probamos si a - b / n es igual al piso de sí mismo, lo que será cierto cuando a - b (mod n ) = 0.

JavaScript (ES6), 27 bytes

@ CᴏɴᴏʀO'Bʀɪᴇɴ publicó una versión que no funciona; Aquí está el "algoritmo común" que las personas están usando en una forma que "funciona":

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

La palabra "funciona" está entre comillas porque el atajo que estamos usando para Math.floor()truncar implícitamente un número para estar en el rango de 32 bits con signo, por lo que esto no puede manejar el espacio completo de enteros de 52 bits o lo que sea que JavaScript pueda describir.

CJam, 7 bytes

l~-\,=!

El orden de entrada es n a b.

Pruébalo aquí.

Explicación

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, así que esto es justo (a-b)**1%n.

ES6, 28 bytes

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

Funciona buscando un punto decimal en (ab) / n que espero esté permitido.

En serio, 10 bytes

,,,-A│\)/=

Toma entrada como N\nA\nB\n(letras mayúsculas usadas para distinguir de las nuevas líneas).

Pruébalo en línea

Utiliza el mismo método que la respuesta de @AlexA

Explicación (letras mayúsculas usadas como nombres de variables con fines 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 la misma verificación que la respuesta de @ xnor .