32

Scrivi il codice più breve possibile che restituirà vero se i due valori interi indicati sono uguali o se la loro somma o differenza assoluta è 5.

Esempi di 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

Il più breve che ho potuto inventare in python2 è lungo 56 caratteri:

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

-9, grazie @ElPedro. Richiede input in 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

benvenuto in PPCG! Questa è una buona prima sfida: la sfida è chiaramente definita, ha ampi casi di test e utilizza il nostro I / O predefinito! Se rimani per un po 'e continui a pensare a sfide interessanti, ti consiglio di usare The Sandbox per ottenere feedback prima di pubblicarle su questo sito. Spero che ti piaccia il tempo che passi qui!

— Giuseppe,

22

Python 2 , 30 byte

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

Provalo online!

_{Un byte salvato da Arnauld}

_{Tre byte salvati da alephalpha}

— Arbo
fonte

Questo è incredibilmente conciso, grazie

— Vikrant Biswas il

Lo stesso può essere fatto in Octave / MATLAB in 29 byte ( provalo online! ).

— Tom Carpenter il

17

JavaScript (ES6), 28 byte

Accetta input come (a)(b). Restituisce o . $0$ $1$

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

Provalo online!

— Arnauld
fonte

1

Accidenti, mi ci è voluto molto tempo per capire come questo gestisse la parte differenza. :)

— Vikrant Biswas il

9

Dyalog APL , 9 byte

=∨5∊+,∘|-

Provalo online!

Spiegato:

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

— dzaima
fonte

8

codice macchina x86, 39 byte

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

montaggio

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

Provalo online!

— Logern
fonte

5

J , 12 11 byte

1 byte salvato grazie ad Adám

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

Provalo online!

Spiegazione

Ciò equivale a:

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

Questo può essere diviso nella seguente catena della forcella:

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

Oppure, visualizzato usando 5!:4<'f':

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

commentata:

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

Salvare un byte cone.

— Adám il

@ Adám Come? L'approccio più breve che ho avuto è e.stato =+.5 e.|@-,+. Forse dimentichi che 5e.un token non valido in J?

— Conor O'Brien,

1

Dal momento che due numeri interi non possono ++.

— sommarsi

@ Adám Ah, vedo, grazie.

— Conor O'Brien,

5

R , 40 byte (o 34)

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

Provalo online!

Per utenti non R:

-1:1*5 si espande a [-5, 0, 5]
l' %in%operatore prende gli elementi da sinistra e verifica (dal punto di vista degli elementi) se esistono nel vettore a destra

Una porta diretta della soluzione di @ ArBo ha 35 34 byte, quindi vota questa risposta se ti piace:

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

— ngm
fonte

Il 34 byte può essere ridotto di 1 confunction(x,y)x%in%c(y--1:1*5,5-y)

— MickyT

Può scendere a 30 byte spostando la sottrazione: function(x,y)(x-y)%in%(-1:1*5)e rilasciarlo ulteriormente a 24 byte rilasciando la notazione della funzione da scan()inserire: diff(scan())%in%(-1:1*5) provala online! . Tuttavia, è sempre lo stesso metodo.

— CriminallyVulgar

1

@CriminallyVulgar rappresenta la somma 5?

— ArBo

@ArBo Hah, l'ho perso nelle specifiche e non c'era un caso di prova nel TIO, quindi l'ho appena visto!

— CriminalmenteVolgar

Le modifiche minori che è possibile apportare a entrambi sono da utilizzare pryr::f, che funziona in entrambi i casi. Il fatto che sia in grado di rilevare correttamente gli argomenti è del tutto in qualche modo sbagliato, ma sembra inchiodare queste due funzioni. es. pryr::f(x%in%c(y--1:1*5,5-y)) provalo online! . Ti porta rispettivamente a 36 e 29 byte.

— CriminalmenteVolgar

5

Python 2 , 29 31 byte

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

Provalo online!

Dal momento che non sono riuscito a leggere attentamente l'attività la prima volta, al fine di risolverlo, ho dovuto elaborare un approccio completamente diverso, che purtroppo non è così conciso.

— Kirill L.
fonte

5

8086 codice macchina, 22 20 byte

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

Immettere i numeri in AX e BX e restituisce Zero Flag (ZF = 1) se il risultato è vero. Se lo si desidera, è anche possibile determinare quale condizione era vera con quanto segue:

ZF = 1 e DX = 5; la somma è 5
ZF = 1 e AX = 5; diff è 5
ZF = 1 e AX = 0; pari
ZF = 0; risultato falso

Se la differenza tra i numeri è 0, sappiamo che sono uguali. Altrimenti se il risultato è negativo, prima negalo e poi controlla 5. Se non è ancora vero, aggiungi e controlla 5.

Esempio di programma di test DOS per PC. Scaricalo qui ( 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

Uscita del programma di 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

— 640KB
fonte

4

Gelatina , 7 byte

+,ạ5eo=

Provalo online!

Come funziona

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

-2 byte grazie a @DjMcMayhem

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

Provalo online!

— fənɛtɪk
fonte

Il tuo TIO è in realtà di 42 byte ma puoi risolverlo eliminando gli spazi tra la 5s e la ors

— ElPedro

3

In realtà, il collegamento TIO potrebbe essere di 38 byte

— DJMcMayhem

@ElPedro la funzione stessa era 40 byte, ma ho usato f = per poterla chiamare

— fəˈnɛtɪk

1

@DJMcMayhem Normalmente non gioco a golf in Python. L'ho fatto solo perché la domanda che domandava usa python per il loro esempio

— f 16nɛtɪk

4

Java (JDK) , 30 byte

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

Provalo online!

— Olivier Grégoire
fonte

4

Wolfram Language (Mathematica) , 22 byte

Accetta input come [a][b].

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

Provalo online!

— alephalpha
fonte

4

PowerShell , 48 44 40 byte

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

Provalo online! oppure Verifica tutti i casi di test

Accetta input $ae $b. Controlla se $bè -inil gruppo ( $a-5, 5-$a 5+$ao $a), che controlla tutte le possibili combinazioni di $a, $be 5.

-4 byte grazie a mazzy.
-4 byte grazie a KGlasier.

— AdmBorkBork
fonte

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

— mazzy il

@mazzy Ooo, bella chiamata.

— AdmBorkBork,

Se si cambia 5e $bintorno è possibile tagliare un paio di byte (cioè param($a,$b)$b-in($a-5),(5-$a),($a+5),$a) Provalo qui

— KGlasier

1

@KGlasier Ottimo suggerimento. Ho dovuto scambiarlo $a+5per 5+$afarlo lanciare in modo appropriato quando si prende l'input dalla riga di comando, ma per il resto è fantastico. Grazie!

— AdmBorkBork,

4

Pascal (FPC) ,26 70 byte

Modifica: + variabili di input.

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

Provalo online!

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

Provalo online!

Spero che la mia risposta sia conforme a tutte le regole del code-golf. Comunque è stato divertente.

— Dessy Stoeva
fonte

2

Ciao e benvenuto in PPCG! Normalmente, devi prendere l'input, invece di supporre che sia già in variabili. Non conosco Pascal, ma penso che questo sia ciò che sta facendo questo codice.

— NoOneIsHere

Ciao, NoOneIsHere e grazie per l'osservazione. Potrebbe anche interessare - dovrei includere l'inizializzazione delle variabili. Osservando diverse altre soluzioni, come ad esempio Java, in cui la definizione della funzione con parametri è stata esclusa dalla lunghezza totale della soluzione, ho deciso di non includere ReadLn.

— Dessy Stoeva, il

Tutto apposto. Benvenuti in PPCG!

— NoOneIsHere il

L'invio di Java è un lambda anonimo che accetta due parametri. Questo sembra usare variabili predefinite, che non è un metodo di input valido.

— Jo King,

1

Nessun problema, cambierò la mia richiesta.

— Dessy Stoeva,

3

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

EDIT: ho provato a usare% e apparentemente ho dimenticato come%. Grazie ad Arnauld per averlo sottolineato!

EDIT2: AdmBorkBork con un golf da -1 byte riorganizzando le parentesi per sedersi accanto al ritorno, quindi non è necessario spazio aggiuntivo!

EDIT3: Grazie a dana per -14 byte golf per la scorciatoia di ritorno a una riga e curry della funzione (Ty Embodiment of Ignorance per il collegamento a TIO).

C # (.NET Core) , 33 byte

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

Provalo online!

— Destroigo
fonte

Bah. Cercando di evitare System.Math. Di nuovo ad esso! Grazie per

— averlo

1

Puoi ottenere fino a 33 byte applicando i suggerimenti di dana

— Incarnazione dell'ignoranza il

3

C (gcc) , 33 byte

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

Provalo online!

Ho provato un approccio che non ho visto nessun altro provare a utilizzare. L'espressione return è equivalente a a+b==5||((-6<a-b||a-b<6)&&(a-b)%5==0).

— attinat
fonte

3

Scala, 43 byte

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

Provalo online!

— Xavier Guihot
fonte

Non è possibile il golf la ||a |? So che è possibile in Java, C #, Python o JavaScript, ma non sono sicuro di Scala.

— Kevin Cruijssen il

Attualmente si! grazie

— Xavier Guihot il

3

Perl 6 , 24 byte

-1 byte grazie a Grimy

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

Provalo online!

Questo utilizza Any Junction ma tecnicamente ^potrebbe funzionare anche.

Spiegazione:

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

— Jo King
fonte

1

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

— Grimmy il

2

C (gcc) , 41 34 byte

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

Provalo online!

— cleblanc
fonte

1

Perché fritorna a? Solo un comportamento indefinito?

— Tyilo,

@Tyilo Sì, è specifico per l'implementazione. Quindi accade che il primo parametro sia memorizzato nello stesso registro del valore restituito.

— Cleblanc,

30 byte Provalo online!

— Logern

@Logern non funziona per f (6,1)

— cleblanc

@ceilingcat Non funziona per f (6,1)

— cleblanc

2

05AB1E , 13 12 byte

ÐO5Qs`α5QrËO

Provalo online!

Accetta l'input come un elenco di numeri interi, salvando un byte. Grazie @ Wisław!

Risposta alternativa a 12 byte

Q¹²α5Q¹²+5QO

Provalo online!

Questo prende input su righe separate.

— Cowabunghole
fonte

1

Dato che non è specificato in modo molto chiaro, non puoi supporre che l'input sia un elenco di numeri interi, eliminando così l'iniziale |?

— Wisław,

@ Wisław Un buon punto, ho aggiornato la mia risposta. Grazie!

— Cowabunghole,

Ho trovato un 11 byte alternativa: OI`αª5¢IË~Ā. L'input è un elenco di numeri interi.

— Wisław,

1

OIÆÄ)5QIËMè 10.

— Magic Octopus Urn

1

@MagicOctopusUrn Non sono sicuro esattamente quali siano le regole, ma penso che la tua soluzione sia abbastanza diversa dalla mia per inviare la tua risposta, no? Inoltre, non correlato ma ho visto il tuo nome utente su questo sito per molto tempo ma solo dopo averlo digitato mi sono reso conto che è "Urn", non "Um" :)

— Cowabunghole

2

05AB1E , 10 byte

OIÆ‚Ä50SåZ

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

Ho provato a farlo usando operazioni di solo stack, ma è stato più lungo.

— Urna di polpo magico
fonte

1

Questo purtroppo tornerà vero se la somma è 0tale per[5, -5]

— Emigna il

1

L'altra soluzione da 10 byte che hai lasciato come commento ( OIÆÄ‚5QIËM) è corretta [5,-5].

— Kevin Cruijssen il

Un'altra soluzione a 10 byte che mi è venuta in mente è OsÆÄ‚5åsË~. Sembra quasi identico al tuo. Provalo online!

— Wisław,

2

Rubino , 34 byte

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

Online Eval - Grazie @ Solo ASCII

— Jatin Dhankhar
fonte

controlli se sono uguali però ...

— ASCII il

Oops, ho dimenticato di aggiungere quel controllo. Grazie @ ASCII-only per aver segnalato l'errore.

— Jatin Dhankhar,

1

Sarei carino se potessi collegarti a questo

— ASCII, solo il

questo potrebbe essere valido? non del tutto sicuro, però, potresti voler verificare con qualcun altro

— ASCII, solo il

Funzionerà ma richiede un .nil?controllo per fornire l'output nel formato richiesto. ->(a,b){[a+5,a-5,5-a,a].index(b).nil?}, questo è più lungo di quello attuale.

— Jatin Dhankhar,

1

Tcl , 53 byte

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

Provalo online!

— sergiol
fonte

1

Japt , 14 13 byte

¥VªaU ¥5ª5¥Nx

Provalo online!

— Oliver
fonte

1

Lotto, 81 byte

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

Accetta input come argomenti della riga di comando e output 1 in caso di successo, nulla in caso di errore. Batch non può facilmente fare disgiunzioni, quindi uso le leggi di De Morgan per trasformarlo in una congiunzione.

— Neil
fonte

1

Carbone , 18 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Porta della soluzione Python 2 di @ ArBo.

— Neil
fonte

1

Japt, 13 12 byte

x ¥5|50ìøUra

Provalo o esegui tutti i casi di 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

— ispido
fonte

Non riesce [-5,5](dovrebbe essere falso)

— Kevin Cruijssen il

Grazie, @KevinCruijssen. Ripristinato alla versione precedente.

— Shaggy

1

Lisp comune, 48 byte

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

— coredump
fonte

1

Brachylog , 8 byte

=|+5|-ȧ5

Prende l'input come un elenco di due numeri (usare _per negativi). Provalo online!

Spiegazione

Praticamente una traduzione diretta delle specifiche:

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

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

Provalo online! Il link include casi di test. Spiegazione: Le prime due righe convertono gli input in unari. La riga finale controlla quindi una qualsiasi delle partite consentite:

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

Girato dall'ultima colonna otteniamo:

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

Uguale, somma o differenza!

Python 2 , 30 byte

JavaScript (ES6), 28 byte

Dyalog APL , 9 byte

codice macchina x86, 39 byte

montaggio

J , 12 11 byte

Spiegazione

R , 40 byte (o 34)

Python 2 , 29 31 byte

8086 codice macchina, 22 20 byte

Gelatina , 7 byte

Come funziona

Python 2, 38 byte

Java (JDK) , 30 byte

Wolfram Language (Mathematica) , 22 byte

PowerShell , 48 44 40 byte

Pascal (FPC) ,26 70 byte

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

C # (.NET Core) , 33 byte

C (gcc) , 33 byte

Scala, 43 byte

Perl 6 , 24 byte

Spiegazione:

C (gcc) , 41 34 byte

05AB1E , 13 12 byte

Risposta alternativa a 12 byte

05AB1E , 10 byte

Rubino , 34 byte

Tcl , 53 byte

Japt , 14 13 byte

Lotto, 81 byte

Carbone , 18 byte

Japt, 13 12 byte

Lisp comune, 48 byte

Brachylog , 8 byte

Spiegazione

Retina 0.8.2 , 82 byte