Tres enteros positivos A, B, C son ABC-triples si son coprimos, con A <B y satisfaciendo la relación: A + B = C

Ejemplos:

• 1, 8, 9 es un ABC-triple ya que son coprimos, 1 <8 y 1 + 8 = 9
• 6, 8, 14 no es porque no son coprimos
• 7, 5, 12 no es porque 7> 5

Puede ver esta presentación de Frits Beukers 2005 para obtener más detalles sobre ABC-triples.

De entrada y salida

Tres enteros, decimal escrito. Se pueden separar los valores o la lista. La salida tenía que ser un valor verdadero / falso si los tres enteros son un triple ABC.

Nota: Es importante respetar el orden de los enteros en la lista, por ejemplo: 1, 8, 9no se considera como la misma lista 9, 1, 8o cualquier otra combinación. Entonces, el primero es un ABC-triple y el segundo no.

Así, A es el primer elemento de la lista, B el segundo y C el tercero.

Casos de prueba

Cada una de las siguientes listas debe generar un valor verdadero

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

Cada una de las siguientes listas debe generar un valor falsey

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

Jalea , 10 9 bytes

Ṫ=S×</=g/

Pruébalo en línea!

Cómo 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 debido a TFeld 's gcdtruco!}

^{-7 bytes gracias a HPWiz por mejorar la prueba de co-primalidad y detectar un espacio superfluo.}

^{-2 bytes gracias a nimi por sugerir un operador infijo!}

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

Pruébalo en línea!

Explicación

Las dos primeras condiciones a < by a + b == cson bastante obvias, la tercera usos que $\gcd(a,b) = \gcd(a,c) = \gcd(b,c)$ :

Escribir $\gcd(a,c) = U \cdot a + V \cdot c$ usando la identidad de Bézout y sustituyendo $c = a + b$ da:

Dado que el $\gcd$ es la solución positiva mínima para esa identidad, se deduce que $\gcd(a,b) = \gcd(a,c)$ . El otro caso es simétrico.

Perl 6 , 33 32 bytes

-1 byte gracias a nwellnhof

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

Pruébalo en línea!

Bloque de código anónimo que toma una lista de tres números y devuelve Verdadero o Falso.

Explicación

{                              }  # 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))

Pruébalo en línea!

Ingrese como argumentos de línea de comando, elabore en el código de salida (también produce resultados en stdout como efecto secundario, pero esto puede ignorarse)

La segunda parte (a partir de &&(() es bastante estándar, pero lo interesante es la prueba 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 gracias a @Shaggy .

Pruébalo en línea.

Explicación:

(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 gracias a Kevin Cruijssen

ÂÆ_*`\‹*¿Θ

Pruébalo en línea! o como un conjunto de pruebas

Explicación

ÂÆ           # 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*

Pruébalo en línea!

Python 3 , 58 51 bytes

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

Pruébalo en línea!

_{-7 bytes, gracias a H.PWiz}

Japt , 16 14 13 11 bytes

<V¥yU «NÔr-

Intentalo

                :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

Pruébalo en línea!

Wolfram Language 24 30 28 26 bytes

Con 2 bytes afeitados por Doorknob. @Jaeyong sung eliminó otros 2 bytes

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

C # (compilador interactivo de 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]

Corre para números de hasta 1e8, toma alrededor de 35 segundos en mi máquina. En lugar de calcular el mcd como otros, la función solo crea una instancia de una gran matriz y filtra los índices que no son divisores de aob, y comprueba cuántos elementos quedan. Luego verifique si el elemento uno más el elemento dos es igual al elemento tres. Por último, comprueba si el primer elemento es menor que el segundo.

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 59 bytes

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

Pruébalo en línea!

ECMAScript Regex, 34 bytes

La entrada está en unario, en el dominio ^x*,x*,x*$(repetido xs delimitado por ,).

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

Pruébalo en línea! (.NET regex engine) ¡
Pruébelo en línea! (Motor de expresiones regulares 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.

La pregunta dice "Tres enteros, decimales escrito", por lo que esto podría no calificar (ya que toma la entrada en unario), pero hace una expresión regular pura tan elegante que espero que al menos sea apreciada.

Sin embargo, tenga en cuenta que si la redacción se interpreta literalmente, las presentaciones lambda y de función que toman argumentos enteros también deben ser descalificadas, para cumplir estrictamente con la especificación de la pregunta, tendrían que tomar la entrada en forma de una cadena.

J , 27 bytes

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

Pruébalo en línea!

Inspirado en la solución Perl de Jo King

C # (.NET Core) , 68 bytes

Sin 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;};

Pruébalo en línea!

Stax , 12 bytes

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

Ejecutar y depurarlo

Limpio , 43 bytes

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

Pruébalo en línea!

Básicamente similar a todo lo demás porque la prueba directa es la misma.

Pari / GP , 30 bytes

Guardado 2 bytes gracias a @Shaggy .

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

Pruébalo en línea!

Befunge-98 (FBBI) , 83 bytes

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

Pruébalo en línea!

La entrada, que es un triple de enteros, [A,B,C]se introduce en Befunge como enteros separados por espacios C B A.

Mathematica 35 bytes

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

si el orden es importante:

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

o...

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

Retina 0.8.2 , 42 41 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Editar: guardado 1 byte gracias a @Deadcode. Explicación:

\d+
$*

Convierte a unario.

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

Verifique que A y B no tengan un factor común.

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

Verifique que A <B y A + B = C.

Lisp común, 51 bytes

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

Pruébalo en línea!