Compte tenu de 3 nombres entiers positifs a, bet n(dont les valeurs maximales sont la valeur entière maximum représentable dans votre langue), la sortie d' une valeur si truthy a ≡ b (mod n)et Falsey autrement. Pour ceux qui ne connaissent pas les relations de congruence, a ≡ b (mod n)c'est vrai ssi a mod n = b mod n(ou, de manière équivalente (a - b) mod n = 0).

Restrictions

• Les méthodes de test de congruence intégrées sont interdites
• Les opérations modulo intégrées sont interdites (cela inclut les opérations telles que la divmodfonction de Python , qui renvoient à la fois le quotient et le reste, ainsi que les fonctions de divisibilité, les fonctions du système de résidus, etc.)

Cas de 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

Il s'agit de code-golf , donc le code le plus court (en octets) l'emporte, avec la première soumission en tant que bris d'égalité.

Gelée, 5 octets

_ÆD⁵e

L'utilisation intensive de tout ce qui n'est pas interdit est autorisée.

Essayez-le en ligne!

Comment ça fonctionne

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

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

Vérifie si a-best un multiple de nen divisant par n, ce qui automatiquement les planchers, et voir si multiplier par ndonne le même résultat.

Julia, 24 octets

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

Il s'agit d'une fonction qui accepte trois entiers et renvoie un booléen.

Nous testons simplement si a - b entier divisé par n est égal à a - b float divisé par n . Cela sera vrai lorsqu'il n'y aura pas de reste de division, c'est -à- dire a - b | n , ce qui implique que a - b (mod n ) = 0.

Pyth, 7 octets

!@UQ-FE

Utilise l'indexation cyclique 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 octets

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

Exemple d'utilisation: (28#78)5-> True.

Même méthode que dans la réponse de @ xnor .

Minkolang 0,15 , 14 11 octets

nn-n$d:*=N.

Essayez-le ici! L'entrée est attendue comme a b n.

Explication:

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 octets

Sdt:i*0hm

Le format d'entrée est

[a b]
n

Essayez-le en ligne!

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

Rétine , 20

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

L'entrée est donnée en unaire, séparés par des espaces, dans l'ordre n a b . Sortie 1 pour truey et 0 pour falsey.

Essayez-le en ligne.

Si vous préférez la saisie décimale, vous pouvez le faire:

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

Essayez-le en ligne.

APL, 15 octets

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

Il s'agit d'une fonction dyadique qui accepte n à gauche et a et b comme tableau à droite.

L'approche ici est fondamentalement la même que dans ma réponse Julia . Nous testons si a - b / n est égal au plancher de lui-même, ce qui sera vrai lorsque a - b (mod n ) = 0.

JavaScript (ES6), 27 octets

@ CᴏɴᴏʀO'Bʀɪᴇɴ a publié une version qui ne fonctionne pas; voici "l'algorithme commun" que les gens utilisent sous une forme qui "fonctionne":

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

Le mot «fonctionne» est entre guillemets, car le raccourci que nous utilisons pour Math.floor()tronque implicitement un nombre pour qu'il soit dans la plage de 32 bits signée. décris.

CJam, 7 octets

l~-\,=!

L'ordre d'entrée est n a b.

Testez-le ici.

Explication

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 octets

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

pow(x,y,n)calcule (x**y)%n, donc c'est juste (a-b)**1%n.

ES6, 28 octets

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

Fonctionne en recherchant un point décimal dans (ab) / n qui, je l'espère, est autorisé.

Sérieusement, 10 octets

,,,-A│\)/=

Prend l'entrée comme N\nA\nB\n(majuscules utilisées pour distinguer les retours à la ligne).

Essayez-le en ligne

Cela utilise la même méthode que la réponse de @ AlexA

Explication (lettres majuscules utilisées comme noms de variables à des fins explicatives):

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

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

Implémente la même vérification que la réponse @ xnor .