Écrivez le code le plus court possible qui retournera vrai si les deux valeurs entières données sont égales ou si leur somme ou différence absolue est 5.

Exemples de cas de test:

4 1 => True
10 10 => True
1 3 => False
6 2 => False
1 6 => True
-256 -251 => True
6 1 => True
-5 5 => False

Le plus court que j'ai pu trouver en python2 est de 56 caractères:

x=input();y=input();print all([x-y,x+y-5,abs(x-y)-5])<1

-9, merci @ElPedro. Il prend une entrée au format x, y:

x,y=input();print all([x-y,x+y-5,abs(x-y)-5])<1

Python 2 , 30 octets

lambda a,b:a in(b,5-b,b-5,b+5)

Essayez-le en ligne!

_{Un octet enregistré par Arnauld}

_{Trois octets enregistrés par l'alephalpha}

JavaScript (ES6), 28 octets

Prend les entrées en tant que (a)(b). Renvoie $0$ ou $1$ .

a=>b=>a+b==5|!(a-=b)|a*a==25

Essayez-le en ligne!

Dyalog APL , 9 octets

=∨5∊+,∘|-

Essayez-le en ligne!

Énoncée:

  =   ∨  5      ∊                +   , ∘    |            -
equal or 5 found in an array of sum and absolute of difference.

code machine x86, 39 octets

00000000: 6a01 5e6a 055f 5251 31c0 39d1 0f44 c601  j.^j._RQ1.9..D..
00000010: d139 cf0f 44c6 595a 29d1 83f9 050f 44c6  .9..D.YZ).....D.
00000020: 83f9 fb0f 44c6 c3                        ....D..

Assemblée

section .text
	global func
func:					;inputs int32_t ecx and edx
	push 0x1
	pop esi
	push 0x5
	pop edi
	push edx
	push ecx
	xor eax, eax

	;ecx==edx?
	cmp ecx, edx
	cmove eax, esi

	;ecx+edx==5?
	add ecx, edx
	cmp edi, ecx
	cmove eax, esi
	
	;ecx-edx==5?
	pop ecx
	pop edx
	sub ecx, edx
	cmp ecx, 5
	
	;ecx-edx==-5?
	cmove eax, esi
	cmp ecx, -5
	cmove eax, esi

	ret

Essayez-le en ligne!

J , 12 11 octets

1 octet économisé grâce à Adám

1#.=+5=|@-,+

Essayez-le en ligne!

Explication

Cela équivaut à:

1 #. = + 5 = |@- , +

Cela peut être divisé dans la chaîne de fourche suivante:

(= + (5 e. (|@- , +)))

Ou, visualisé en utilisant 5!:4<'f':

  ┌─ =               
  ├─ +               
──┤   ┌─ 5           
  │   ├─ e.          
  └───┤          ┌─ |
      │    ┌─ @ ─┴─ -
      └────┼─ ,      
           └─ +      

Annoté:

  ┌─ =                                     equality
  ├─ +                                     added to (boolean or)
──┤   ┌─ 5                                   noun 5
  │   ├─ e.                                  is an element of
  └───┤          ┌─ |  absolute value         |
      │    ┌─ @ ─┴─ -  (of) subtraction       |
      └────┼─ ,        paired with            |
           └─ +        addition               | any of these?

R , 40 octets (ou 34)

function(x,y)any((-1:1*5)%in%c(x+y,x-y))

Essayez-le en ligne!

Pour les utilisateurs non-R:

• -1:1*5 s'étend à [-5, 0, 5]
• l' %in%opérateur prend les éléments de gauche et vérifie (par élément) s'ils existent dans le vecteur de droite

Un port direct de la solution @ ArBo a 35 34 octets, alors votez pour cette réponse si vous l'aimez:

function(x,y)x%in%c(y--1:1*5,5-y)

Python 2 , 29 31 octets

lambda a,b:a+b==5or`a-b`in"0-5"

Essayez-le en ligne!

Comme je n'ai pas réussi à lire attentivement la tâche la première fois, pour y remédier, j'ai dû trouver une approche complètement différente, qui n'est malheureusement pas aussi concise.

8086 code machine, 22 20 octets

8bd0 2bc3 740e 7902 f7d8 3d0500 7405 03d3 83fa05

Ungolfed:

ESD  MACRO
    LOCAL SUB_POS, DONE
    MOV  DX, AX     ; Save AX to DX
    SUB  AX, BX     ; AX = AX - BX
    JZ   DONE       ; if 0, then they are equal, ZF=1
    JNS  SUB_POS    ; if positive, go to SUB_POS
    NEG  AX         ; otherwise negate the result
SUB_POS:
    CMP  AX, 5      ; if result is 5, ZF=1
    JZ   DONE
    ADD  DX, BX     ; DX = DX + BX
    CMP  DX, 5      ; if 5, ZF=1
DONE:
    ENDM

Entrez les nombres dans AX et BX et retourne le drapeau zéro (ZF = 1) si le résultat est vrai. Si vous le souhaitez, vous pouvez également déterminer quelle condition était vraie avec les éléments suivants:

• ZF = 1 et DX = 5; la somme est 5
• ZF = 1 et AX = 5; diff est 5
• ZF = 1 et AX = 0; égal
• ZF = 0; résultat faux

Si la différence entre les nombres est 0, nous savons qu'ils sont égaux. Sinon, si le résultat est négatif, niez-le d'abord, puis vérifiez 5. Si ce n'est toujours pas vrai, ajoutez et vérifiez 5.

Exemple de programme de test PC DOS. Téléchargez-le ici ( ESD.COM ).

START:
    CALL INDEC      ; input first number into AX
    MOV  BX, AX     ; move to BX
    CALL INDEC      ; input second number into BX
    ESD             ; run "Equal, sum or difference" routine
    JZ   TRUE       ; if ZF=1, result is true
FALSE:
    MOV  DX, OFFSET FALSY   ; load Falsy string
    JMP  DONE
TRUE:
    MOV  DX, OFFSET TRUTHY  ; load Truthy string
DONE:
    MOV  AH, 9      ; DOS display string
    INT  21H        ; execute
    MOV  AX, 4C00H  ; DOS terminate
    INT  21H        ; execute

TRUTHY   DB 'Truthy$'
FALSY    DB 'Falsy$'

INCLUDE INDEC.ASM   ; generic decimal input prompt routine

Sortie du programme de test:

A>ESD.COM
: 4
: 1
Truthy

A>ESD.COM
: 10
: 10
Truthy

A>ESD.COM
: 1
: 3
Falsy

A>ESD.COM
: 6
: 2
Falsy

A>ESD.COM
: 1
: 6
Truthy

A>ESD.COM
: -256
: -251
Truthy

A>ESD.COM
: 6
: 1
Truthy

A>ESD.COM
: 9999999999
: 9999999994
Truthy

Gelée , 7 octets

+,ạ5eo=

Essayez-le en ligne!

Comment ça marche

+,ạ5eo=  Main link. Arguments: x, y (integers)

+        Yield x+y.
  ạ      Yield |x-y|.
 ,       Pair; yield (x+y, |x-y|).
   5e    Test fi 5 exists in the pair.
      =  Test x and y for equality.
     o   Logical OR.

Python 2, 38 octets

-2 octets grâce à @DjMcMayhem

lambda a,b:a+b==5or abs(a-b)==5or a==b

Essayez-le en ligne!

Java (JDK) , 30 octets

a->b->a+b==5|a==b|(b-=a)*b==25

Essayez-le en ligne!

Wolfram Language (Mathematica) , 22 octets

Prend les entrées en tant que [a][b].

MatchQ[#|5-#|#-5|#+5]&

Essayez-le en ligne!

PowerShell , 48 44 40 octets

param($a,$b)$b-in($a-5),(5-$a),(5+$a),$a

Essayez-le en ligne! ou vérifier tous les cas de test

Prend entrée $aet $b. Vérifie si $best -inle groupe ( $a-5, 5-$a 5+$aou $a), qui vérifie toutes les combinaisons possibles de $a, $bet 5.

-4 octets grâce à mazzy.
-4 octets grâce à KGlasier.

Pascal (FPC) ,26 70 octets

Modifier: + variables d'entrée.

Procedure z(a,b:integer);begin Writeln((abs(a-b)in[0,5])or(a+b=5))end;

Essayez-le en ligne!

(abs(a-b)in[0,5])or(a+b=5)

Essayez-le en ligne!

J'espère que ma réponse est conforme à toutes les règles du code-golf. C'était amusant de toute façon.

C # (.NET Core) , 43 , 48 , 47 , 33 octets

EDIT: J'ai essayé d'utiliser% et j'ai apparemment oublié comment%. Merci à Arnauld de l'avoir signalé!

EDIT2: AdmBorkBork avec un golf de -1 octet réorganisant les parenthèses pour s'asseoir à côté du retour, donc aucun espace supplémentaire n'est nécessaire!

EDIT3: Merci à dana pour le golf de -14 octets pour le raccourci de retour sur une ligne et le curry de la fonction (Ty Embodiment of Ignorance pour la liaison avec TIO).

C # (.NET Core) , 33 octets

a=>b=>a==b|a+b==5|(a-b)*(a-b)==25

Essayez-le en ligne!

C (gcc) , 33 octets

f(a,b){a=!(a+b-5&&(a-=b)/6|a%5);}

Essayez-le en ligne!

J'ai essayé une approche que je n'ai vu personne d'autre essayer d'utiliser. L'expression de retour est équivalente à a+b==5||((-6<a-b||a-b<6)&&(a-b)%5==0).

Scala, 43 octets

def f(a:Int,b:Int)=a+b==5|(a-b).abs==5|a==b

Essayez-le en ligne!

Perl 6 , 24 octets

-1 octet grâce à Grimy

{$^a-$^b==5|0|-5|5-2*$b}

Essayez-le en ligne!

Cela utilise Any Junction mais techniquement, cela ^pourrait aussi fonctionner.

Explication:

{                      }  # Anonymous code block
 $^a-$^b==                # Is the difference equal to
           | |  |        # Any of
          0 
            5
              -5
                 5-2*$b

C (gcc) , 41 34 octets

f(a,b){a=5==abs(a-b)|a+b==5|a==b;}

Essayez-le en ligne!

05AB1E , 13 12 octets

ÐO5Qs`α5QrËO

Essayez-le en ligne!

Prend l'entrée comme une liste d'entiers, économisant un octet. Merci @ Wisław!

Réponse alternative de 12 octets

Q¹²α5Q¹²+5QO

Essayez-le en ligne!

Celui-ci prend l'entrée sur des lignes distinctes.

05AB1E , 10 octets

OIÆ‚Ä50SåZ

Essayez-le en ligne!

O           # Sum the input.
 IÆ         # Reduced subtraction of the input.
   ‚        # Wrap [sum,reduced_subtraction]
    Ä       # abs[sum,red_sub]
     50S    # [5,0]
        å   # [5,0] in abs[sum,red_sub]?
         Z  # Max of result, 0 is false, 1 is true.

J'ai essayé de le faire en utilisant des opérations de pile uniquement, mais c'était plus long.

Rubis , 34 octets

->(a,b){[a+5,a-5,5-a,a].include?b}

Eval en ligne - Merci @ ASCII uniquement

Tcl , 53 octets

proc P a\ b {expr abs($a-$b)==5|$a==$b|abs($a+$b)==5}

Essayez-le en ligne!

Japt , 14 13 octets

¥VªaU ¥5ª5¥Nx

Essayez-le en ligne!

Lot, 81 octets

@set/as=%1+%2,d=%1-%2
@if %d% neq 0 if %d:-=% neq 5 if %s% neq 5 exit/b
@echo 1

Prend l'entrée comme arguments de ligne de commande et renvoie 1 en cas de succès, rien en cas d'échec. Batch ne peut pas facilement faire de disjonctions, donc j'utilise les lois de De Morgan pour le transformer en conjonction.

Charbon de bois , 18 octets

Ｎθ¿№⟦θ⁺⁵θ⁻⁵θ⁻θ⁵⟧Ｎ1

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Port de la solution Python 2 de @ ArBo.

Japt, 13 12 octets

x ¥5|50ìøUra

Essayez-le ou lancez tous les cas de test

x ¥5|50ìøUra
                 :Implicit input of array U
x                :Reduce by addition
  ¥5             :Equal to 5?
    |            :Bitwise OR
     50ì         :Split 50 to an array of digits
        ø        :Contains?
         Ur      :  Reduce U
           a     :    By absolute difference

Lisp commun, 48 octets

(lambda(a b)(find 5(list(abs(- b a))a(+ a b)b)))

Brachylog , 8 octets

=|+5|-ȧ5

Prend la saisie sous forme de liste de deux nombres (à utiliser _pour les négatifs). Essayez-le en ligne!

Explication

Une traduction directe de la spécification:

=          The two numbers are equal
 |         or
  +        The sum of the two numbers
   5       is 5
    |      or
     -     The difference of the two numbers
      ȧ    absolute value
       5   is 5

Retina 0.8.2 , 82 octets

\d+
$*
^(-?1*) \1$|^(-?1*)1{5} -?\2$|^-?(-?1*) (\3)1{5}$|^-?(1 ?){5}$|^(1 ?-?){5}$

Essayez-le en ligne! Le lien inclut des cas de test. Explication: Les deux premières lignes convertissent les entrées en unaire. La dernière ligne vérifie ensuite les correspondances autorisées:

^(-?1*) \1$                              x==y
^(-?1*)1{5} -?\2$   x>=0 y>=0 x=5+y i.e. x-y=5
                    x>=0 y<=0 x=5-y i.e. x+y=5
                    x<=0 y<=0 x=y-5 i.e. y-x=5
^-?(-?1*) (\3)1{5}$ x<=0 y<=0 y=x-5 i.e. x-y=5
                    x<=0 y>=0 y=5-x i.e. x+y=5
                    x>=0 y>=0 y=5+x i.e. y-x=5
^-?(1 ?){5}$        x>=0 y>=0 y=5-x i.e. x+y=5
                    x<=0 y>=0 y=5+x i.e. y-x=5
^(1 ?-?){5}$        x>=0 y>=0 x=5-y i.e. x+y=5
                    x>=0 y<=0 x=5+y i.e. x-y=5

Pivoté par la dernière colonne, nous obtenons:

x==y            ^(-?1*) \1$
x+y=5 x>=0 y>=0 ^-?(1 ?){5}$
      x>=0 y>=0 ^(1 ?-?){5}$
      x>=0 y<=0 ^(-?1*)1{5} -?\2$
      x<=0 y>=0 ^-?(-?1*) (\3)1{5}$
      x<=0 y<=0 (impossible)       
x-y=5 x>=0 y>=0 ^(-?1*)1{5} -?\2$
      x>=0 y<=0 ^(1 ?-?){5}$
      x<=0 y>=0 (impossible)
      x<=0 y<=0 ^-?(-?1*) (\3)1{5}$
y-x=5 x>=0 y>=0 ^-?(-?1*) (\3)1{5}$
      x>=0 y<=0 (impossible)
      x<=0 y>=0 ^-?(1 ?){5}$
      x<=0 y<=0 ^(-?1*)1{5} -?\2$