32

Escriba el código más corto posible que devuelva verdadero si los dos valores enteros dados son iguales o su suma o diferencia absoluta es 5.

Ejemplos de casos de prueba:

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

Lo más corto que se me ocurrió en python2 es de 56 caracteres:

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

-9, gracias @ElPedro. Toma entrada en formato x, y:

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

code-golf decision-problem

— Vikrant Biswas
fuente

99

bienvenido a PPCG! Este es un buen primer desafío: el desafío está claramente definido, tiene muchos casos de prueba y utiliza nuestra E / S predeterminada. Si te quedas un rato y sigues pensando en desafíos interesantes, te recomendaría usar The Sandbox para obtener comentarios antes de publicarlos en este sitio. ¡Espero que disfrutes el tiempo que pasas aquí!

— Giuseppe

22

Python 2 , 30 bytes

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

Pruébalo en línea!

_{Un byte salvado por Arnauld}

_{Tres bytes guardados por alephalpha}

— ArBo
fuente

Esto es increíblemente conciso, gracias

— Vikrant Biswas

Lo mismo se puede hacer en Octave / MATLAB en 29 bytes (¡ Pruébelo en línea! ).

— Tom Carpenter

17

JavaScript (ES6), 28 bytes

Toma entrada como (a)(b). Devuelve $0$ o $1$ .

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

Pruébalo en línea!

— Arnauld
fuente

1

Maldición, me llevó mucho, mucho tiempo descubrir cómo esto maneja la diferencia. :)

— Vikrant Biswas

9

Dyalog APL , 9 bytes

=∨5∊+,∘|-

Pruébalo en línea!

Deletreado:

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

— dzaima
fuente

8

código de máquina x86, 39 bytes

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

Montaje

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

Pruébalo en línea!

— Logern
fuente

5

J , 12 11 bytes

1 byte guardado gracias a Adám

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

Pruébalo en línea!

Explicación

Esto es equivalente a:

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

Esto se puede dividir en la siguiente cadena de horquilla:

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

O, visualizado usando 5!:4<'f':

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

Anotado:

  ┌─ =                                     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
fuente

Ahorre un byte cone.

— Adám

@ Adám ¿Cómo es eso? El enfoque más corto que obtuve e.fue =+.5 e.|@-,+. ¿Quizás olvides que 5e.es una ficha no válida en J?

— Conor O'Brien

1

Dado que dos números enteros no pueden sumar simultáneamente 5 y ser iguales, puede usar en +lugar de+.

— Adám

@ Adám Ah, ya veo, gracias.

— Conor O'Brien

5

R , 40 bytes (o 34)

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

Pruébalo en línea!

Para usuarios que no son R:

-1:1*5 se expande a [-5, 0, 5]
el %in%operador toma elementos de la izquierda y verifica (en cuanto a elementos) si existen en el vector de la derecha

Un puerto directo de la solución de @ ArBo tiene 35 34 bytes, así que vota tu respuesta si te gusta:

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

— ngm
fuente

El byte de 34 puede reducirse en 1 confunction(x,y)x%in%c(y--1:1*5,5-y)

— MickyT

Puede bajar a 30 bytes moviendo la resta: function(x,y)(x-y)%in%(-1:1*5)y bajarlo más a 24 bytes bajando la notación de función para scan()ingresar: ¡ diff(scan())%in%(-1:1*5) Pruébelo en línea! . Sin embargo, sigue siendo el mismo método.

— CriminallyVulgar

1

@CriminallyVulgar ¿eso explica que la suma sea 5?

— ArBo

@ArBo Hah, me perdí eso en la especificación, y no había un caso de prueba en el TIO, ¡así que lo ignoré!

— CriminallyVulgar

El cambio menor que se puede hacer en ambos es el uso pryr::f, que funciona en ambos casos. Si puede detectar adecuadamente los argumentos es algo totalmente impredecible, pero parece concretar estas dos funciones. Por ejemplo, pryr::f(x%in%c(y--1:1*5,5-y)) pruébelo en línea. . Te lleva a 36 y 29 bytes respectivamente.

— CriminallyVulgar

5

Python 2 , 29 31 bytes

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

Pruébalo en línea!

Como no pude leer la tarea cuidadosamente la primera vez, para solucionarlo, tuve que idear un enfoque completamente diferente, que desafortunadamente no es tan conciso.

— Kirill L.
fuente

5

Código de máquina 8086, 22 20 bytes

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

Sin golf:

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

Ingrese los números en AX y BX y devuelva el indicador de cero (ZF = 1) si el resultado es verdadero. Si lo desea, también puede determinar qué condición era verdadera con lo siguiente:

ZF = 1 y DX = 5; suma es 5
ZF = 1 y AX = 5; diff es 5
ZF = 1 y AX = 0; igual
ZF = 0; resultado falso

Si la diferencia entre los números es 0, sabemos que son iguales. De lo contrario, si el resultado es negativo, primero niegue y luego verifique 5. Si aún no es cierto, agregue y verifique 5.

Programa de prueba de DOS para PC de muestra. Descárguelo aquí ( 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

Salida del programa de prueba:

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 KB
fuente

4

Jalea , 7 bytes

+,ạ5eo=

Pruébalo en línea!

Cómo funciona

+,ạ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
fuente

4

Python 2, 38 bytes

-2 bytes gracias a @DjMcMayhem

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

Pruébalo en línea!

— fəˈnɛtɪk
fuente

Su TIO es en realidad de 42 bytes, pero puede solucionarlo eliminando los espacios entre 5s y ors

— ElPedro

3

En realidad, el enlace TIO podría ser de 38 bytes

— DJMcMayhem

@ElPedro la función en sí era de 40 bytes, pero usé f = para poder llamarla

— fəˈnɛtɪk

1

@DJMcMayhem No suelo jugar golf en Python. Simplemente lo hice porque el autor de la pregunta usó Python como ejemplo

— f --nɛtɪk

4

Java (JDK) , 30 bytes

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

Pruébalo en línea!

— Olivier Grégoire
fuente

4

Wolfram Language (Mathematica) , 22 bytes

Toma entrada como [a][b].

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

Pruébalo en línea!

— alephalpha
fuente

4

PowerShell , 48 44 40 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba

Toma entrada $ay $b. Comprueba si $bes -inel grupo ( $a-5, 5-$a 5+$ao $a), que comprueba todas las posibles combinaciones de $a, $by 5.

-4 bytes gracias a mazzy.
-4 bytes gracias a KGlasier.

— AdmBorkBork
fuente

($a-$b)es -$x:)

— mazzy

@mazzy Ooo, buena llamada.

— AdmBorkBork

Si cambia 5y $bpuede cortar un par de bytes (es decir param($a,$b)$b-in($a-5),(5-$a),($a+5),$a) Pruébelo aquí

— KGlasier

1

@KGlasier Excelente sugerencia. Necesitaba cambiar $a+5para 5+$aque se lanzara correctamente al tomar la entrada de la línea de comandos, pero por lo demás es increíble. ¡Gracias!

— AdmBorkBork

4

Pascal (FPC) ,26 70 bytes

Editar: + variables de entrada.

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

Pruébalo en línea!

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

Pruébalo en línea!

Espero que mi respuesta esté de acuerdo con todas las reglas del código de golf. Fue divertido de todos modos.

— Dessy Stoeva
fuente

2

Hola y bienvenidos a PPCG! Normalmente, debe tomar la entrada, en lugar de asumir que ya está en las variables. No conozco a Pascal, pero creo que eso es lo que está haciendo este código.

— NoOneIsHere

Hola, NoOneIsHere y gracias por el comentario. También puede ser preocupante, ¿debo incluir la inicialización de las variables? Mirando varias otras soluciones, como Java, por ejemplo, donde la definición de la función con parámetros se excluyó de la longitud total de la solución, decidí no incluir ReadLn.

— Dessy Stoeva

Bien. Bienvenido a PPCG!

— NoOneIsHere

El envío de Java es una lambda anónima que toma dos parámetros. Esto parece usar variables predefinidas, que no es un método de entrada válido.

— Jo King

1

No hay problema, cambiaré mi presentación.

— Dessy Stoeva

3

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

EDITAR: Intenté usar% y aparentemente olvidé cómo%. ¡Gracias a Arnauld por señalar eso!

EDIT2: AdmBorkBork con un campo de golf de -1 byte que reorganiza los paréntesis para sentarse al lado del retorno, por lo que no se necesita espacio adicional.

EDITAR3: Gracias a dana por -14 bytes de golf por el acceso directo de retorno de una línea y curry la función (Ty Realización de la ignorancia por vincular a TIO).

C # (.NET Core) , 33 bytes

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

Pruébalo en línea!

— Destroigo
fuente

Bah. Tratando de evitar System.Math. De vuelta a eso! Gracias por señalarlo: D

— Destroigo

1

Puede reducirlo a 33 bytes aplicando los consejos de dana

— Encarnación de la ignorancia

3

C (gcc) , 33 bytes

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

Pruébalo en línea!

Intenté un enfoque que no vi a nadie más intentar usar. La expresión de retorno es equivalente a a+b==5||((-6<a-b||a-b<6)&&(a-b)%5==0).

— attinat
fuente

3

Scala, 43 bytes

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

Pruébalo en línea!

— Xavier Guihot
fuente

¿No es posible que el campo de ||a |? Sé que es posible en Java, C #, Python o JavaScript, pero no estoy seguro acerca de Scala.

— Kevin Cruijssen

¡Actualmente, si! gracias

— Xavier Guihot

3

Perl 6 , 24 bytes

-1 byte gracias a Grimy

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

Pruébalo en línea!

Esto usa Any Junction pero, técnicamente, ^podría funcionar también.

Explicación:

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

— Jo King
fuente

1

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

— Grimmy

2

C (gcc) , 41 34 bytes

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

Pruébalo en línea!

— cleblanc
fuente

1

¿Por qué fvuelve a? ¿Solo un comportamiento indefinido?

— Tyilo

@Tyilo Sí, es una implementación específica. Entonces sucede que el primer parámetro se almacena en el mismo registro que el valor de retorno.

— cleblanc

30 bytes ¡Pruébelo en línea!

— Logern

@Logern no funciona para f (6,1)

— cleblanc

@ceilingcat no funciona para f (6,1)

— cleblanc

2

05AB1E , 13 12 bytes

ÐO5Qs`α5QrËO

Pruébalo en línea!

Toma la entrada como una lista de enteros, guardando un byte. Gracias @ Wisław!

Respuesta alternativa de 12 bytes

Q¹²α5Q¹²+5QO

Pruébalo en línea!

Este toma entrada en líneas separadas.

— Agujero de vaca
fuente

1

Como no se especifica muy claramente, ¿no puede suponer que la entrada es una lista de enteros, eliminando así la inicial |?

— Wisław

@ Wisław Buen punto, actualicé mi respuesta. ¡Gracias!

— Cowabunghole

Me encontré con un 11 bytes alternativa: OI`αª5¢IË~Ā. La entrada es una lista de enteros.

— Wisław

1

OIÆÄ)5QIËMes 10.

— Urna de pulpo mágico

1

@MagicOctopusUrn No estoy seguro de cuáles son exactamente las reglas, pero creo que su solución es lo suficientemente diferente de la mía como para enviar su propia respuesta, ¿no? Además, no está relacionado, pero he visto su nombre de usuario en este sitio durante mucho tiempo, pero solo después de escribirlo me di cuenta de que es "Urna", no "Um" :)

— Cowabunghole

2

05AB1E , 10 bytes

OIÆ‚Ä50SåZ

Pruébalo en línea!

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.

Intenté hacerlo usando operaciones solo de pila, pero fue más largo.

— Urna de pulpo mágico
fuente

1

Desafortunadamente, esto se volverá cierto si la suma es 0como para[5, -5]

— Emigna

1

Su otra solución de 10 bytes que dejó como comentario ( OIÆÄ‚5QIËM) es correcta [5,-5].

— Kevin Cruijssen

Otra solución de 10 bytes que se me ocurrió es OsÆÄ‚5åsË~. Casi idéntico al tuyo parece. Pruébalo en línea!

— Wisław

2

Rubí , 34 bytes

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

Evaluación en línea : gracias @ solo ASCII

— Jatin Dhankhar
fuente

¿compruebas si son iguales? ...

— ASCII solo el

Vaya, olvidé agregar ese cheque. Gracias @ ASCII-only por señalar el error.

— Jatin Dhankhar

1

Sería bueno que pudieras vincular a esto

— solo ASCII el

esto puede ser valido? sin embargo, no estoy completamente seguro, es posible que desee consultar con alguien más

— solo ASCII el

Esto funcionará pero requiere .nil?verificación para dar salida en el formato requerido. ->(a,b){[a+5,a-5,5-a,a].index(b).nil?}, esto es más largo que el actual.

— Jatin Dhankhar

1

Tcl , 53 bytes

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

Pruébalo en línea!

— sergiol
fuente

1

Japt , 14 13 bytes

¥VªaU ¥5ª5¥Nx

Pruébalo en línea!

— Oliver
fuente

1

Lote, 81 bytes

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

Toma la entrada como argumentos de línea de comando y las salidas 1 en caso de éxito, nada en caso de error. Batch no puede hacer disyunciones fácilmente, así que uso las leyes de De Morgan para convertirlo en una conjunción.

— Neil
fuente

1

Carbón , 18 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Puerto de la solución Python 2 de @ ArBo.

— Neil
fuente

1

Japt, 13 12 bytes

x ¥5|50ìøUra

Pruébalo o ejecuta todos los casos de prueba

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

— Lanudo
fuente

Falla para [-5,5](debería ser falsey)

— Kevin Cruijssen

Gracias, @KevinCruijssen. Retrocedió a la versión anterior.

— Shaggy

1

Lisp común, 48 bytes

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

— volcado de memoria
fuente

1

Brachylog , 8 bytes

=|+5|-ȧ5

Toma la entrada como una lista de dos números (uso _para negativos). Pruébalo en línea!

Explicación

Prácticamente una traducción directa de la especificación:

=          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
fuente

0

Retina 0.8.2 , 82 bytes

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

Pruébalo en línea!El enlace incluye casos de prueba. Explicación: Las dos primeras líneas convierten las entradas en unarias. La línea final verifica si hay alguno de los partidos permitidos:

^(-?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

Pivotado por la última columna obtenemos:

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
fuente

Igual, suma o diferencia!

Python 2 , 30 bytes

JavaScript (ES6), 28 bytes

Dyalog APL , 9 bytes

código de máquina x86, 39 bytes

Montaje

J , 12 11 bytes

Explicación

R , 40 bytes (o 34)

Python 2 , 29 31 bytes

Código de máquina 8086, 22 20 bytes

Jalea , 7 bytes

Cómo funciona

Python 2, 38 bytes

Java (JDK) , 30 bytes

Wolfram Language (Mathematica) , 22 bytes

PowerShell , 48 44 40 bytes

Pascal (FPC) ,26 70 bytes

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

C # (.NET Core) , 33 bytes

C (gcc) , 33 bytes

Scala, 43 bytes

Perl 6 , 24 bytes

Explicación:

C (gcc) , 41 34 bytes

05AB1E , 13 12 bytes

Respuesta alternativa de 12 bytes

05AB1E , 10 bytes

Rubí , 34 bytes

Tcl , 53 bytes

Japt , 14 13 bytes

Lote, 81 bytes

Carbón , 18 bytes

Japt, 13 12 bytes

Lisp común, 48 bytes

Brachylog , 8 bytes

Explicación

Retina 0.8.2 , 82 bytes