Égal, somme ou différence!

32

É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
code-golf  decision-problem 
— Vikrant Biswas
source
9
bienvenue chez PPCG! C'est un bon premier défi - le défi est clairement défini, il a de nombreux cas de test et utilise nos E / S par défaut! Si vous restez un moment et continuez à penser à des défis intéressants, je recommanderais d'utiliser The Sandbox pour obtenir des commentaires avant de les publier sur ce site. J'espère que vous apprécierez le temps que vous passez ici!
— Giuseppe

Réponses:

17

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!

— Arnauld
source
1
Merde, il m'a fallu beaucoup de temps pour comprendre comment cela gérait la différence. :)
— Vikrant Biswas
8

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!

— Logern
source
5

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?
— Conor O'Brien
source
Enregistrer un octet avece.
— Adám
@ Adám Comment ça? L'approche la plus courte que j'ai eue e.était =+.5 e.|@-,+. Peut-être que vous oubliez qu'il 5e.s'agit d'un jeton invalide en J?
— Conor O'Brien
1
Étant donné que deux entiers ne peuvent pas additionner simultanément à 5 et être égaux, vous pouvez utiliser à la +place de+.
— Adám
@ Adám Ah, je vois, merci.
— Conor O'Brien
5

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)
— ngm
source
Le 34 octets peut être réduit de 1 avecfunction(x,y)x%in%c(y--1:1*5,5-y)
— MickyT
Peut passer à 30 octets en déplaçant la soustraction:, function(x,y)(x-y)%in%(-1:1*5)et la faire descendre à 24 octets en supprimant la notation de fonction à scan()saisir: diff(scan())%in%(-1:1*5) Essayez-la en ligne! . Toujours à peu près la même méthode.
— CriminallyVulgar
1
@CriminallyVulgar, cela représente-t-il la somme de 5?
— ArBo
@ArBo Hah, ça a manqué ça dans la spécification, et il n'y avait pas de cas de test dans le TIO donc je l'ai juste passé sous silence!
— CriminallyVulgar
Un changement mineur qui peut être apporté aux deux est d'utiliser pryr::f, ce qui se produit dans les deux cas. S'il peut détecter correctement les arguments est tout à fait aléatoire, mais il semble clouer ces deux fonctions. par exemple pryr::f(x%in%c(y--1:1*5,5-y)) Essayez-le en ligne! . Vous donne respectivement 36 et 29 octets.
— CriminallyVulgar
5

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.

— Kirill L.
source
5

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
— 640 Ko
source
4

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.
— Dennis
source
4

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!

— fəˈnɛtɪk
source
Votre TIO est en fait de 42 octets mais vous pouvez le corriger en supprimant les espaces entre le 5s et le ors
— ElPedro
3
En fait, le lien TIO pourrait être de 38 octets
— DJMcMayhem
@ElPedro la fonction elle-même était de 40 octets mais j'ai utilisé f = pour pouvoir l'appeler
— fəˈnɛtɪk
1
@DJMcMayhem Je ne joue pas au golf normalement en python. Je viens de le faire parce que le demandeur de questions a utilisé python pour son exemple
— fəˈnɛtɪk
4

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.

— AdmBorkBork
source
($a-$b)est -$x:)
— mazzy
@mazzy Ooo, bon appel.
— AdmBorkBork
Si vous changez de place 5et que $bvous pouvez couper quelques octets (c.-à-d. param($a,$b)$b-in($a-5),(5-$a),($a+5),$a) Essayez-le ici
— KGlasier
1
@KGlasier Excellente suggestion. J'avais besoin de permuter $a+5pour 5+$aobtenir un cast approprié lors de la prise de ligne de commande, mais sinon génial. Merci!
— AdmBorkBork
4

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.

— Dessy Stoeva
source
2
Bonjour et bienvenue chez PPCG! Normalement, vous devez prendre une entrée, au lieu de supposer qu'elle est déjà dans des variables. Je ne connais pas Pascal, mais je pense que c'est ce que fait ce code.
— NoOneIsHere
Bonjour, NoOneIsHere et merci pour la remarque. C'était peut-être aussi une préoccupation - dois-je inclure l'initialisation des variables. En regardant plusieurs autres solutions, comme Java par exemple, où la définition de fonction avec des paramètres a été exclue de la longueur totale de la solution, j'ai décidé de ne pas inclure ReadLn.
— Dessy Stoeva
Bien. Bienvenue chez PPCG!
— NoOneIsHere
La soumission Java est un lambda anonyme qui prend deux paramètres. Cela semble utiliser des variables prédéfinies, ce qui n'est pas une méthode d'entrée valide.
— Jo King le
1
Pas de problème, je vais changer ma soumission.
— Dessy Stoeva
3

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!

— Destroigo
source
Bah. Essayer d'éviter System.Math. Revenons-y! Merci de l'avoir signalé: D
— Destroigo
1
Vous pouvez le réduire à 33 octets en appliquant les conseils de Dana
— Embodiment of Ignorance
3

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).

— attinat
source
3

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
— Jo King
source
1
-1 octet avec{$^a-$^b==5|0|-5|5-2*$b}
— Grimmy
2

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.

— Cowabunghole
source
1
Puisqu'il n'est pas très clairement spécifié, ne pouvez-vous pas supposer que l'entrée est une liste d'entiers, éliminant ainsi l'initiale |?
— Wisław
@ Wisław Bon point, j'ai mis à jour ma réponse. Merci!
— Cowabunghole
J'ai trouvé un autre 11 octets: OI`αª5¢IË~Ā. L'entrée est une liste d'entiers.
— Wisław
1
OIÆÄ)5QIËMest de 10.
— Urne de poulpe magique
1
@MagicOctopusUrn Je ne sais pas exactement quelles sont les règles mais je pense que votre solution est suffisamment différente de la mienne pour soumettre votre propre réponse, non? En outre, sans rapport avec mais j'ai vu votre nom d'utilisateur sur ce site depuis longtemps, mais ce n'est qu'après l'avoir tapé que j'ai réalisé que c'était "Urn", pas "Um" :)
— Cowabunghole
2

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.

— Urne Magique De Pieuvre
source
1
Cela reviendra malheureusement vrai si la somme est 0telle que pour[5, -5]
— Emigna
1
Votre autre solution de 10 octets que vous avez laissée en tant que commentaire ( OIÆÄ‚5QIËM) est correcte [5,-5].
— Kevin Cruijssen
Une autre solution de 10 octets que j'ai trouvée est OsÆÄ‚5åsË~. Il semble presque identique au vôtre. Essayez-le en ligne!
— Wisław
2

Rubis , 34 octets

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

Eval en ligne - Merci @ ASCII uniquement

— Jatin Dhankhar
source
vérifiez-vous si elles sont égales si ...
— ASCII uniquement
Oups, j'ai oublié d'ajouter ce chèque. Merci @ ASCII uniquement pour avoir signalé l'erreur.
— Jatin Dhankhar
1
je serais bien si vous pouviez créer un lien vers cela
— ASCII uniquement le
cela pourrait être valable? pas complètement sûr cependant, vous voudrez peut-être vérifier avec quelqu'un d'autre
— ASCII uniquement
Cela fonctionnera mais il faudra .nil?vérifier pour donner la sortie dans le format requis. ->(a,b){[a+5,a-5,5-a,a].index(b).nil?}, c'est plus long que l'actuel.
— Jatin Dhankhar
1

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.

— Neil
source
1

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
— Hirsute
source
Échoue pour [-5,5](devrait être Falsey)
— Kevin Cruijssen
Merci, @KevinCruijssen. Revient à la version précédente.
— Shaggy
1

Lisp commun, 48 octets

(lambda(a b)(find 5(list(abs(- b a))a(+ a b)b)))
— coredump
source
1

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
— DLosc
source
0

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$
— Neil
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.