Três inteiros positivos A, B, C são triplo ABC se forem coprimes, com A <B e satisfazendo a relação: A + B = C

Exemplos :

• 1, 8, 9 é um triplo ABC, pois são coprime, 1 <8 e 1 + 8 = 9
• 6, 8, 14 não é porque eles não são coprime
• 7, 5, 12 não é porque 7> 5

Você pode ver esta apresentação do Frits Beukers 2005 para obter mais detalhes sobre o triplo do ABC.

Entrada / Saída

Três inteiros, decimais escritos. Podem ser valores ou lista separados. A saída tinha que ser um valor verdadeiro / falso, se os três números inteiros são um triplo ABC.

Nota: É importante respeitar a ordem dos números inteiros na lista, por exemplo: 1, 8, 9não é considerada a mesma lista que 9, 1, 8nem qualquer outra combinação. Então, primeiro é um triplo ABC e o segundo não.

Assim, A é o primeiro elemento da lista, B o segundo e C o terceiro.

Casos de teste

Cada uma das listas a seguir deve gerar um valor de verdade

[1, 8, 9]
[2, 3, 5]
[2, 6436341, 6436343]
[4, 121, 125]
[121, 48234375, 48234496]

Cada uma das seguintes listas deve gerar um valor de falsey

[1, 1, 2]
[1, 2, 5]
[1, 9, 8]
[4, 12872682, 12872686]
[6, 8, 14]
[7, 5, 12]

Geléia , 10 9 bytes

Ṫ=S×</=g/

Experimente online!

Como funciona

Ṫ=S×</=g/  Main link. Argument: [a, b, c] (positive integers)

Ṫ          Tail; pop and yield c.
  S        Take the sum of [a, b], yielding (a + b).
 =         Yield t := (c == a + b).
    </     Reduce by less than, yielding (a < b).
   ×       Multiply, yielding t(a < b).
       g/  Reduce by GCD, yielding gcd(a, b).
      =    Check if t(a < b) == gcd(a, b).

Haskell , 48 38 29 bytes

^{-10 bytes devido a TFeld 's gcdtruque!}

^{-7 bytes graças ao HPWiz por melhorar o teste de co-primalidade e detectar um espaço supérfluo!}

^{-2 bytes graças a nimi por sugerir um operador de infix!}

(a!b)c=a<b&&a+b==c&&gcd a b<2

Experimente online!

Explicação

As duas primeiras condições a < be a + b == csão bastante óbvias, a terceira usa que $\gcd(a,b) = \gcd(a,c) = \gcd(b,c)$ :

Escrever $\gcd(a,c) = U \cdot a + V \cdot c$ usando a identidade de Bézout e substituir $c = a + b$ fornece:

Como o $\gcd$ é a solução positiva mínima para essa identidade, segue-se que $\gcd(a,b) = \gcd(a,c)$ . O outro caso é simétrico.

Perl 6 , 33 32 bytes

-1 byte graças a nwellnhof

{(.sum/.[2]/2*[<] $_)==[gcd] $_}

Experimente online!

Bloco de código anônimo que pega uma lista de três números e retorna Verdadeiro ou Falso.

Explicação

{                              }  # Anonymous code block
                       [gcd] $_   # Is the gcd of all the numbers
 (                  )==           # Equal to
  .sum        # Whether the sum of numbes
      /       # Is equal to
       .[2]/2 # The last element doubled
             *[<] $_   # And elements are in ascending order

Excel, 33 bytes

=AND(A1+B1=C1,GCD(A1:C1)=1,A1<B1)

bash, 61 bytes

factor $@|grep -vzP '( .+\b).*\n.*\1\b'&&(($1<$2&&$1+$2==$3))

Experimente online!

Entrada como argumentos da linha de comando, saída no código de saída (também produz saída no stdout como efeito colateral, mas isso pode ser ignorado).

A segunda parte (a partir de &&(() é bastante padrão, mas o interessante é o teste de coprime:

factor $@      # produces output of the form "6: 2 3\n8: 2 2 2\n14: 2 7\n"
|grep -        # regex search on the result
v              # invert the match (return truthy for strings that don't match)
z              # zero-terminated, allowing us to match newlines
P              # perl (extended) regex
'( .+\b)'      # match one or more full factors
'.*\n.*'       # and somewhere on the next line...
'\1\b'         # find the same full factors

Java 10, 65 64 bytes

(a,b,c)->{var r=a<b&a+b==c;for(;b>0;a=b,b=c)c=a%b;return r&a<2;}

-1 byte obrigado a @Shaggy .

Experimente online.

Explicação:

(a,b,c)->{        // Method with three integer parameters and boolean return-type
  var r=          //  Result-boolean, starting at:
        a<b       //   Check if `a` is smaller than `b`
        &a+b==c;  //   And if `a+b` is equal to `c`
  for(;b>0        //  Then loop as long as `b` is not 0 yet
      ;           //    After every iteration:
       a=b,       //     Set `a` to the current `b`
       b=c)       //     And set `b` to the temp value `c`
    c=a%b;        //   Set the temp value `c` to `a` modulo-`b`
                  //   (we no longer need `c` at this point)
  return r        //  Return if the boolean-result is true
         &a<2;}   //  And `a` is now smaller than 2

05AB1E , 12 11 10 bytes

Guardado 1 byte graças a Kevin Cruijssen

ÂÆ_*`\‹*¿Θ

Experimente online! ou como um conjunto de testes

Explicação

ÂÆ           # reduce a reversed copy of the input by subtraction
  _          # logically negate
   *         # multiply with input
    `        # push the values of the resulting list separately to stack
     \       # remove the top (last) value
      ‹      # is a < b ?
       *     # multiply by the input list
        ¿    # calculate the gcd of the result
         Θ   # is it true ?

Python 2 , 69 67 63 62 55 bytes

lambda a,b,c:(c-b==a<b)/gcd(a,b)
from fractions import*

Experimente online!

Python 3 , 58 51 bytes

lambda a,b,c:(c-b==a<b)==gcd(a,b)
from math import*

Experimente online!

_{-7 bytes, graças a H.PWiz}

Japt , 16 14 13 11 bytes

<V¥yU «NÔr-

Tente

                :Implicit input of integers U=A, V=B & W=C
<V              :Is U less than V?
  ¥             :Test that for equality with
   yU           :The GCD of V & U
      «         :Logical AND with the negation of
       N        :The array of inputs
        Ô       :Reversed
         r-     :Reduced by subtraction

JavaScript (ES6),  54 43 42  40 bytes

$\gcd(a,c)$

$true$$0$$false$

f=(a,b,c)=>c&&a/b|a+b-c?0:b?f(b,a%b):a<2

Experimente online!

Wolfram Language 24 30 28 26 bytes

Com 2 bytes raspados pela maçaneta da porta. Mais 2 bytes eliminados por @jaeyong sung

#<#2&&GCD@##==1&&#+#2==#3&

C # (compilador interativo do Visual C #) , 90 bytes

n=>new int[(int)1e8].Where((_,b)=>n[0]%++b<1&n[1]%b<1).Count()<2&n[0]+n[1]==n[2]&n[0]<n[1]

É executado para números de até 1e8, leva cerca de 35 segundos na minha máquina. Em vez de calcular o gcd como outros, a função apenas instancia uma matriz enorme e filtra os índices que não são divisores de a ou b e verifica quantos elementos restam. Em seguida, verifique se o elemento um mais o elemento dois é igual ao elemento três. Por fim, verifica se o primeiro elemento é menor que o segundo.

Experimente online!

C # (compilador interativo do Visual C #) , 59 bytes

(a,b,c)=>Enumerable.Range(2,a).All(i=>a%i+b%i>0)&a<b&a+b==c

Experimente online!

ECMAScript Regex, 34 bytes

A entrada é unária, no domínio ^x*,x*,x*$( xs repetidos delimitados por ,).

^(?!(xx+)\1*,\1+,)(x*)(,\2x+)\3\2$

Experimente online! (Mecanismo regex .NET)
Experimente online! (Mecanismo de regex SpiderMonkey)

# see /codegolf/178303/find-if-a-list-is-an-abc-triple
^
(?!                # Verify that A and B are coprime. We don't need to include C in the
                   # test, because the requirement that A+B=C implies that A,B,C are
                   # mutually comprime if and only if A and B are coprime.
    (xx+)\1*,\1+,  # If this matches, A and B have a common factor \1 and aren't coprime.
)
(x*)(,\2x+)\3\2$   # Verify that A<B and A+B=C. The first comma is captured in \3 and
                   # reused to match the second comma, saving one byte.

A pergunta diz "Três números inteiros, decimais escritos", portanto, isso pode não se qualificar (já que é necessário inserir unário), mas cria um regex puro tão elegante que espero que seja pelo menos apreciado.

No entanto, observe que, para que o fraseado seja literalmente interpretado, os envios de lambda e de função que usam argumentos inteiros também devem ser desqualificados, pois para aderir estritamente à especificação da pergunta, eles precisam receber a entrada na forma de uma string.

J , 27 bytes

(+/=2*{:)*({.<1{])*1=+./ .*

Experimente online!

Inspirado na solução Perl de Jo King

C # (.NET Core) , 68 bytes

Sem Linq.

(a,b,c)=>{var t=a<b&a+b==c;while(b>0){c=b;b=a%b;a=c;}return t&a<2;};

Experimente online!

Stax , 12 bytes

ü╡v╕7+Pü°╔|g

Execute e depure

Limpo , 43 bytes

import StdEnv
$a b c=a<b&&a+b==c&&gcd a b<2

Experimente online!

Semelhante a basicamente tudo o mais, porque o teste direto é o mesmo.

Pari / GP , 30 bytes

Economizou 2 bytes graças a @Shaggy .

(a,b,c)->a<b==gcd(a,b)&&a+b==c

Experimente online!

Befunge-98 (FBBI) , 83 bytes

&:&:03p&:04pw>03g04g\:v_1w03g04g+w1.@
00:    7j@.0[^j7      _^;>0.@;j7;>0.@;:%g00\p

Experimente online!

A entrada que é um triplo de números inteiros [A,B,C]é alimentada no Befunge como números inteiros separados por espaço C B A.

Mathematica 35 bytes

CoprimeQ @@ # && #[[1]] + #[[2]] == #[[3]] & 

se a ordem é importante:

CoprimeQ @@ # && Sort[#]==# && #[[1]] + #[[2]] == #[[3]] & 

ou...

And[CoprimeQ @@ #, Sort@# == #, #[[1]] + #[[2]] == #[[3]]] &

Retina 0.8.2 , 42 41 bytes

\d+
$*
A`^(11+)\1*,\1+,
^(1+)(,1+\1)\2\1$

Experimente online! O link inclui casos de teste. Editar: salvou 1 byte graças a @Deadcode. Explicação:

\d+
$*

Converta para unário.

A`^(11+)\1*,\1+,

Verifique se A e B não têm fator comum.

^(1+)(,1+\1)\2\1$

Verifique se A <B e A + B = C.

Lisp comum, 51 bytes

(lambda(a b c)(and(< a b)(=(+ a b)c)(=(gcd a c)1)))

Experimente online!