Tre numeri interi positivi A, B, C sono tripli ABC se sono coprimi, con A <B e soddisfacenti la relazione: A + B = C

Esempi:

• 1, 8, 9 è una tripla ABC poiché sono coprimi, 1 <8 e 1 + 8 = 9
• 6, 8, 14 non è perché non sono coprimi
• 7, 5, 12 non è perché 7> 5

Puoi vedere questa presentazione di Frits Beukers 2005 per maggiori dettagli sulle triple di ABC.

Input Output

Tre numeri interi, decimali scritti. Possono essere valori o elenchi separati. L'output doveva essere un valore di verità / falsità se i tre numeri interi sono una tripla ABC.

Nota: è importante rispettare l'ordine dei numeri interi nell'elenco, ad esempio: 1, 8, 9non è considerato come lo stesso elenco 9, 1, 8o qualsiasi altra combinazione. Quindi la prima è una tripla ABC e la seconda no.

Quindi A è il primo elemento dell'elenco, B il secondo e C il terzo.

Casi test

Ognuno dei seguenti elenchi dovrebbe generare un valore di verità

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

Ognuno dei seguenti elenchi dovrebbe generare un valore false

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

Gelatina , 10 9 byte

Ṫ=S×</=g/

Provalo online!

Come funziona

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

^{-10 byte dovuti a del gcdtrucco di TFeld !}

^{-7 byte grazie a HPWiz per migliorare il test di co-primalità e individuare uno spazio superfluo!}

^{-2 byte grazie a nimi per aver suggerito un operatore infix!}

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

Provalo online!

Spiegazione

Le prime due condizioni a < be a + b == csono abbastanza ovvie, la terza usa che $\gcd(a,b) = \gcd(a,c) = \gcd(b,c)$ :

Scrivendo $\gcd(a,c) = U \cdot a + V \cdot c$ usando l'identità di Bézout e sostituendo $c = a + b$ ottiene:

Poiché il $\gcd$ è la soluzione positiva minimo per tale identità ne consegue che $\gcd(a,b) = \gcd(a,c)$ . L'altro caso è simmetrico.

Perl 6 , 33 32 byte

-1 byte grazie a nwellnhof

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

Provalo online!

Blocco di codice anonimo che accetta un elenco di tre numeri e restituisce True o False.

Spiegazione

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

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

bash, 61 byte

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

Provalo online!

Input come argomenti della riga di comando, output nel codice di uscita (produce anche output su stdout come effetto collaterale, ma questo può essere ignorato).

La seconda parte (a partire da &&(() è piuttosto standard, ma la parte interessante è il test 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 byte

(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 grazie a @Shaggy .

Provalo online.

Spiegazione:

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

Salvato 1 byte grazie a Kevin Cruijssen

ÂÆ_*`\‹*¿Θ

Provalo online! o come una suite di test

Spiegazione

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

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

Provalo online!

Python 3 , 58 51 byte

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

Provalo online!

_{-7 byte, grazie a H.PWiz}

Japt , 16 14 13 11 byte

<V¥yU «NÔr-

Provalo

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

Grazie a @Shaggy per aver sottolineato che non abbiamo bisogno di calcolare $\gcd(a,c)$. Salvato 11 byte riscrivendo il codice di conseguenza.

Accetta input come 3 numeri interi separati. ritorna$true$ per una tripla ABC, o uno dei due $0$ o $false$ altrimenti.

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

Provalo online!

Lingua Wolfram 24 30 28 26 byte

Con 2 byte rasati da Doorknob. Altri 2 byte cancellati da @jaeyong cantati

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

C # (compilatore interattivo Visual C #) , 90 byte

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]

Funziona con numeri fino a 1e8, impiega circa 35 secondi sulla mia macchina. Invece di calcolare gcd come gli altri, la funzione crea un'istanza di un array enorme e filtra gli indici che non sono divisori di a o b e controlla quanti elementi rimangono. Quindi controlla se l'elemento uno più l'elemento due sono uguali all'elemento tre. Infine, controlla se il primo elemento è inferiore al secondo.

Provalo online!

C # (compilatore interattivo Visual C #) , 59 byte

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

Provalo online!

ECMAScript Regex, 34 byte

L'input è in unario, nel dominio ^x*,x*,x*$(ripetuto xs delimitato da ,).

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

Provalo online! (Motore regex .NET)
Provalo online! (Motore 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.

La domanda dice "Tre numeri interi, decimale scritto", quindi questo potrebbe non qualificarsi (dato che prende un input in unario), ma crea una regex così elegante e pura che spero che almeno sarà apprezzata.

Tuttavia, si noti che se il fraseggio deve essere interpretato letteralmente, anche le presentazioni lambda e di funzioni che accettano argomenti interi devono essere squalificate, in modo da aderire rigorosamente alle specifiche della domanda che dovrebbero prendere l'input sotto forma di una stringa.

J , 27 byte

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

Provalo online!

Ispirato alla soluzione Perl di Jo King

C # (.NET Core) , 68 byte

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

Provalo online!

Stax , 12 byte

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

Esegui ed esegui il debug

Pulito , 43 byte

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

Provalo online!

Simile praticamente a tutto il resto perché il test diretto è lo stesso.

Pari / GP , 30 byte

Salvato 2 byte grazie a @Shaggy .

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

Provalo online!

Befunge-98 (FBBI) , 83 byte

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

Provalo online!

L'input che è un triplo di numeri interi [A,B,C]viene immesso in Befunge come numeri interi separati da spazio C B A.

Mathematica 35 byte

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

se l'ordine è importante:

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

o...

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

Retina 0.8.2 , 42 41 byte

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

Provalo online! Il link include casi di test. Modifica: salvato 1 byte grazie a @Deadcode. Spiegazione:

\d+
$*

Converti in unario.

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

Verifica che A e B non abbiano un fattore comune.

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

Verificare che A <B e A + B = C.

Lisp comune, 51 byte

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

Provalo online!