32

Escreva o código mais curto possível que retornará true se os dois valores inteiros forem iguais ou se a soma ou diferença absoluta for 5.

Exemplos de casos de teste:

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

O menor que eu pude criar no python2 tem 56 caracteres:

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

-9, obrigado @ElPedro. É necessário entrada no formato x, y:

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

code-golf decision-problem

— Vikrant Biswas
fonte

9

bem-vindo ao PPCG! Esse é um bom primeiro desafio - o desafio está claramente definido, possui amplos casos de teste e usa nossa E / S padrão! Se você ficar por um tempo e continuar pensando em desafios interessantes, eu recomendaria o uso do The Sandbox para obter feedback antes de publicá-los neste site. Espero que você aproveite o tempo que passa aqui!

— Giuseppe

22

Python 2 , 30 bytes

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

Experimente online!

_{Um byte salvo por Arnauld}

_{Três bytes salvos por alephalpha}

— ArBo
fonte

Isso é incrivelmente conciso, obrigado

— Vikrant Biswas 16/01

O mesmo pode ser feito no Octave / MATLAB em 29 bytes ( Experimente online! ).

— Tom Carpenter

17

JavaScript (ES6), 28 bytes

Toma entrada como (a)(b). Retorna $0$ ou $1$ .

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

Experimente online!

— Arnauld
fonte

11

Porra, demorei muito tempo para descobrir como isso lidava com a diferença. :)

— Vikrant Biswas 16/01

9

Dyalog APL , 9 bytes

=∨5∊+,∘|-

Experimente online!

Soletrado:

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

— dzaima
fonte

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

Montagem

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

Experimente online!

— Logern
fonte

5

J , 12 11 bytes

1 byte economizado graças a Adám

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

Experimente online!

Explicação

Isso é equivalente a:

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

Isso pode ser dividido na seguinte cadeia de garfos:

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

Ou 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
fonte

Salvar um byte come.

— Adám 16/01

@ Adám Como assim? A abordagem mais curta que obtive e.foi =+.5 e.|@-,+. Talvez você esqueça que 5e.é um token inválido no J?

— Conor O'Brien

11

Como dois números inteiros não podem somar simultaneamente a 5 e serem iguais, você pode usar em +vez de+.

— Adám

@ Adám Ah, entendo, obrigado.

— Conor O'Brien

5

R , 40 bytes (ou 34)

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

Experimente online!

Para usuários não-R:

-1:1*5 expande para [-5, 0, 5]
o %in%operador pega elementos da esquerda e verifica (em termos de elementos) se eles existem no vetor à direita

Uma porta direta da solução do @ ArBo possui 35 34 bytes, então vote com mais frequência que responder se quiser:

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

— ngm
fonte

O byte de 34 bytes pode ser reduzido em 1 comfunction(x,y)x%in%c(y--1:1*5,5-y)

— MickyT 16/01

Pode cair para 30 bytes movendo a subtração:, function(x,y)(x-y)%in%(-1:1*5)e depois para 24 bytes, largando a notação de função na scan()entrada: diff(scan())%in%(-1:1*5) Experimente online! . Ainda é muito o mesmo método.

— CriminallyVulgar

11

@CriminallyVulgar, isso representa a soma de 5?

— ArBo 17/01

@ArBo Hah, perdi isso nas especificações, e não havia um caso de teste no TIO, então acabei de encaminhá-lo!

— CriminallyVulgar

Pequenas alterações que podem ser feitas em ambos é usar pryr::f, o que acontece nos dois casos. Se ele pode detectar adequadamente os argumentos é inteiramente um tanto imprevisível, mas parece pregar essas duas funções. Por exemplo, pryr::f(x%in%c(y--1:1*5,5-y)) experimente online! . Leva você a 36 e 29 bytes, respectivamente.

— CriminallyVulgar

5

Python 2 , 29 31 bytes

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

Experimente online!

Como não consegui ler a tarefa cuidadosamente da primeira vez, para corrigi-la, tive que criar uma abordagem completamente diferente, que infelizmente não é tão concisa.

— Kirill L.
fonte

5

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

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

Digite os números no AX e no BX e retorne a flag zero (ZF = 1) se o resultado for verdadeiro. Se desejar, você também pode determinar qual condição era verdadeira com o seguinte:

ZF = 1 e DX = 5; soma é 5
ZF = 1 e AX = 5; diff é 5
ZF = 1 e AX = 0; igual
ZF = 0; resultado falso

Se a diferença entre os números for 0, sabemos que eles são iguais. Caso contrário, se o resultado for negativo, primeiro negue-o e verifique se 5. Se ainda não for verdadeiro, adicione e verifique 5.

Exemplo de programa de teste para PC DOS. Faça o download aqui ( 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

Saída do programa de teste:

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

— 640KB
fonte

4

Geléia , 7 bytes

+,ạ5eo=

Experimente online!

Como 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
fonte

4

Python 2, 38 bytes

-2 bytes graças a @DjMcMayhem

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

Experimente online!

— fəˈnɛtɪk
fonte

Seu TIO é realmente de 42 bytes, mas você pode corrigi-lo excluindo os espaços entre os 5eor

— ElPedro 16/01

3

Na verdade, o link do TIO pode ter 38 bytes

— DJMcMayhem

@ElPedro a função em si era de 40 bytes, mas eu usei f = para poder chamá-lo

— fəˈnɛtɪk 16/01

11

@DJMcMayhem Normalmente não jogo golfe em python. Acabei de fazer isso porque o autor da pergunta usava python como exemplo

— fəˈnɛtɪk 16/01

4

Java (JDK) , 30 bytes

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

Experimente online!

— Olivier Grégoire
fonte

4

Wolfram Language (Mathematica) , 22 bytes

Toma entrada como [a][b].

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

Experimente online!

— alefalpha
fonte

4

PowerShell , 48 44 40 bytes

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

Experimente online! ou Verifique todos os casos de teste

Pega entrada $ae $b. Verifica se $bé -ino grupo ( $a-5, 5-$a 5+$a, ou $a), o qual verifica todas as combinações possíveis de $a, $be 5.

-4 bytes graças ao mazzy.
-4 bytes graças ao KGlasier.

— AdmBorkBork
fonte

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

— mazzy 16/01

@mazzy Ooo, boa ligação.

— AdmBorkBork 16/01

Se você alternar 5e $bem torno de você pode cortar um par de bytes (ou seja param($a,$b)$b-in($a-5),(5-$a),($a+5),$a) Experimente aqui

— KGlasier

11

@KGlasier Excelente sugestão. Eu precisava trocar $a+5para 5+$aobter a conversão adequada ao receber a entrada da linha de comando, mas, de outra forma, impressionante. Obrigado!

— AdmBorkBork 17/01

4

Pascal (FPC) ,26 70 bytes

Editar: + variáveis de entrada.

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

Experimente online!

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

Experimente online!

Espero que minha resposta esteja de acordo com todas as regras do código-golfe. Foi divertido de qualquer maneira.

— Dessy Stoeva
fonte

2

Olá, e bem-vindo ao PPCG! Normalmente, você precisa receber informações, em vez de assumir que já está em variáveis. Não conheço Pascal, mas acho que é isso que esse código está fazendo.

— NoOneIsHere 20/01

Olá, NoOneIsHere e obrigado pela observação. Também pode ser preocupante - devo incluir a inicialização das variáveis. Olhando para várias outras soluções, como Java, por exemplo, onde a definição de função com parâmetros foi excluída do comprimento total da solução, decidi não incluir o ReadLn.

— Dessy Stoeva 20/01

Bem. Bem-vindo ao PPCG!

— NoOneIsHere 20/01

A submissão Java é uma lambda anônima que aceita dois parâmetros. Parece usar variáveis predefinidas, o que não é um método válido de entrada.

— Jo King

11

Não tem problema, vou mudar minha inscrição.

— Dessy Stoeva 24/01

3

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

EDIT: Tentei usar% e, aparentemente, esqueceu como%. Obrigado a Arnauld por apontar isso!

EDIT2: AdmBorkBork com um campo de golfe de -1 bytes reorganizando os parênteses para ficar ao lado do retorno, para que não seja necessário espaço adicional!

EDIT3: Agradecimentos a dana pelo golfe de -14 bytes pelo atalho de retorno em uma linha e currying a função (Ty Embodiment of Ignorance por vincular ao TIO).

C # (.NET Core) , 33 bytes

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

Experimente online!

— Destroigo
fonte

Bah. Tentando evitar o System.Math. Voltar para ele! Obrigado por apontar isso: D

— Destroigo

11

Você pode reduzi-lo a 33 bytes aplicando as dicas da dana

— Modalidade de Ignorância

3

C (gcc) , 33 bytes

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

Experimente online!

Tentei uma abordagem que não vi mais ninguém tentar usar. A expressão de retorno é equivalente a a+b==5||((-6<a-b||a-b<6)&&(a-b)%5==0).

— attinat
fonte

3

Scala, 43 bytes

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

Experimente online!

— Xavier Guihot
fonte

Não é possível golf o ||que |? Eu sei que é possível em Java, C #, Python ou JavaScript, mas não tenho certeza sobre o Scala.

— Kevin Cruijssen 17/01

Na verdade sim! obrigado

— Xavier Guihot 17/01

3

Perl 6 , 24 bytes

-1 byte graças ao Grimy

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

Experimente online!

Isso usa o Any Junction, mas tecnicamente, também ^pode funcionar.

Explicação:

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

— Brincadeira
fonte

11

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

— Grimmy 17/01

2

C (gcc) , 41 34 bytes

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

Experimente online!

— cleblanc
fonte

11

Por que fvolta a? Apenas um comportamento indefinido?

— Tyilo 16/01

@ Tyilo Sim, é uma implementação específica. Acontece que o primeiro parâmetro é armazenado no mesmo registro que o valor retornado.

— cleblanc 16/01

30 bytes Experimente online!

— Logern 16/01

@Logern não funciona para f (6,1)

— cleblanc 16/01

@ceilingcat Não funciona para f (6,1)

— cleblanc 16/01

2

05AB1E , 13 12 bytes

ÐO5Qs`α5QrËO

Experimente online!

Recebe a entrada como uma lista de números inteiros, economizando um byte. Obrigado @ Wisław!

Resposta alternativa de 12 bytes

Q¹²α5Q¹²+5QO

Experimente online!

Este recebe entrada em linhas separadas.

— Cowabunghole
fonte

11

Como não está claramente especificado, você não pode assumir que a entrada é uma lista de números inteiros, eliminando a inicial |?

— Wisław 16/01

@ Wisław Bom ponto, eu atualizei minha resposta. Obrigado!

— Cowabunghole 16/01

Eu encontrei um 11 bytes alternativa: OI`αª5¢IË~Ā. Entrada é uma lista de números inteiros.

— Wisław 16/01

11

OIÆÄ)5QIËMé 10.

— Magic Octopus Urn

11

@MagicOctopusUrn Não sei exatamente quais são as regras, mas acho que sua solução é diferente o suficiente da minha para enviar sua própria resposta, não? Além disso, sem relação, mas eu já vi seu nome de usuário neste site há muito tempo, mas somente depois de digitá-lo é que percebi que é "Urna", não "Um" :)

— Cowabunghole 16/01

2

05AB1E , 10 bytes

OIÆ‚Ä50SåZ

Experimente online!

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.

Tentei fazer isso usando operações apenas de pilha, mas foi mais longo.

— Urna de polvo mágico
fonte

11

Infelizmente, isso retornará verdadeiro se a soma for 0como[5, -5]

— Emigna 16/01

11

Sua outra solução de 10 bytes que você deixou como comentário ( OIÆÄ‚5QIËM) está correta [5,-5].

— Kevin Cruijssen 17/01

Outra solução de 10 bytes que eu vim com é OsÆÄ‚5åsË~. Quase idêntico ao seu, parece. Experimente online!

— Wisław 17/01

2

Ruby , 34 bytes

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

Eval Online - Obrigado @ Somente ASCII

— Jatin Dhankhar
fonte

você verifica se eles são iguais ...

— ASCII-only

Opa, esqueci de adicionar essa verificação. Obrigado @ ASCII-only por apontar o erro.

— Jatin Dhankhar 20/01

11

eu seria legal se você pudesse criar um link para isso

— somente ASCII

isso pode ser válido? não completamente certo, porém, você pode querer verificar com outra pessoa

— somente ASCII

Isso funcionará, mas requer .nil?verificação para fornecer a saída no formato necessário. ->(a,b){[a+5,a-5,5-a,a].index(b).nil?}, isso é mais longo que o atual.

— Jatin Dhankhar 28/01

1

Tcl , 53 bytes

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

Experimente online!

— sergiol
fonte

1

Japonês , 14 13 bytes

¥VªaU ¥5ª5¥Nx

Experimente online!

— Oliver
fonte

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

Recebe a entrada como argumentos da linha de comando e gera 1 em caso de êxito, nada em caso de falha. Lote não pode fazer disjunções facilmente, então eu uso as leis de De Morgan para transformá-lo em uma conjunção.

— Neil
fonte

1

Carvão , 18 bytes

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

Experimente online! Link é a versão detalhada do código. Porto da solução Python 2 da @ ArBo.

— Neil
fonte

1

Japonês, 13 12 bytes

x ¥5|50ìøUra

Experimente ou execute todos os casos de teste

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

— Shaggy
fonte

Não consegue [-5,5](deve ser falsey)

— Kevin Cruijssen 17/01

Obrigado, @KevinCruijssen. Revertida para a versão anterior.

— Shaggy

1

Lisp comum, 48 bytes

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

— coredump
fonte

1

Braquilog , 8 bytes

=|+5|-ȧ5

Recebe a entrada como uma lista de dois números (use _para negativos). Experimente online!

Explicação

Praticamente uma tradução direta das especificações:

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

0

Retina 0.8.2 , 82 bytes

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

Experimente online! O link inclui casos de teste. Explicação: As duas primeiras linhas convertem as entradas em unárias. A linha final verifica então qualquer uma das correspondências permitidas:

^(-?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 pela última coluna, obtemos:

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
fonte

Igual, soma ou diferença!

Python 2 , 30 bytes

JavaScript (ES6), 28 bytes

Dyalog APL , 9 bytes

código de máquina x86, 39 bytes

Montagem

J , 12 11 bytes

Explicação

R , 40 bytes (ou 34)

Python 2 , 29 31 bytes

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

Geléia , 7 bytes

Como 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

Explicação:

C (gcc) , 41 34 bytes

05AB1E , 13 12 bytes

Resposta alternativa de 12 bytes

05AB1E , 10 bytes

Ruby , 34 bytes

Tcl , 53 bytes

Japonês , 14 13 bytes

Lote, 81 bytes

Carvão , 18 bytes

Japonês, 13 12 bytes

Lisp comum, 48 bytes

Braquilog , 8 bytes

Explicação

Retina 0.8.2 , 82 bytes