Drei positive ganze Zahlen A, B, C sind ABC-Tripel, wenn sie Koprime sind, mit A <B und erfüllen die Beziehung: A + B = C

Beispiele:

• 1, 8, 9 ist ein ABC-Tripel, da sie Koprime sind, 1 <8 und 1 + 8 = 9
• 6, 8, 14 liegt nicht daran, dass sie nicht mitschuldig sind
• 7, 5, 12 liegt nicht an 7> 5

In dieser Präsentation von Frits Beukers 2005 erfahren Sie mehr über ABC-Tripel.

Input-Output

Drei Ganzzahlen, dezimal geschrieben. Kann getrennte Werte oder Listen sein. Die Ausgabe musste ein wahrer / falscher Wert sein, ob die drei Ganzzahlen ein ABC-Tripel sind.

Hinweis: Es ist wichtig, die Reihenfolge ganzer Zahlen in der Liste zu 1, 8, 9beachten. Beispiel: Wird nicht als dieselbe Liste 9, 1, 8oder als eine andere Kombination angesehen. Also ist erstens ein ABC-Tripel und zweitens nicht.

Somit ist A das erste Element der Liste, B das zweite und C das dritte.

Testfälle

Jede der folgenden Listen sollte einen Wahrheitswert ausgeben

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

Jede der folgenden Listen sollte einen falschen Wert ausgeben

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

Gelee , 10 9 Bytes

Ṫ=S×</=g/

Probieren Sie es online!

Wie es funktioniert

Ṫ=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 aufgrund TFeld ‚s gcdTrick!}

^{-7 Byte dank HPWiz für die Verbesserung des Co-Primality-Tests und das Erkennen eines überflüssigen Speicherplatzes!}

^{-2 Bytes danke an nimi für den Hinweis auf einen Infix-Operator!}

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

Probieren Sie es online!

Erläuterung

Die ersten zwei Bedingungen a < bund a + b == csind ziemlich offensichtlich, die dritten Verwendungen dass :$\gcd(a,b) = \gcd(a,c) = \gcd(b,c)$

Das Schreiben von Verwendung von Bézouts Identität und das Ersetzen von ergibt:$\gcd(a,c) = U \cdot a + V \cdot c$$c = a + b$

Da die zu dieser Identität die minimale positive Lösung ist , folgt daraus , dass . Der andere Fall ist symmetrisch.$\gcd$$\gcd(a,b) = \gcd(a,c)$

Perl 6 , 33 32 Bytes

-1 byte dank nwellnhof

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

Probieren Sie es online!

Anonymer Codeblock, der eine Liste mit drei Zahlen aufnimmt und Wahr oder Falsch zurückgibt.

Erläuterung

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

Probieren Sie es online!

Eingabe als Kommandozeilenargumente, Ausgabe im Exit-Code (erzeugt auch Ausgabe auf stdout als Nebeneffekt, dies kann jedoch ignoriert werden).

Der zweite Teil (ab &&(() ist ziemlich normal, aber das Interessante ist der Coprime-Test:

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 danke an @Shaggy .

Probieren Sie es online aus.

Erläuterung:

(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

Dank Kevin Cruijssen 1 Byte gespeichert

ÂÆ_*`\‹*¿Θ

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Probieren Sie es online!

Python 3 , 58 51 Bytes

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

Probieren Sie es online!

_{-7 Bytes, danke an H.PWiz}

Japt , 16 14 13 11 Bytes

<V¥yU «NÔr-

Versuch es

                :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

Vielen Dank an @Shaggy für den Hinweis, dass wir nicht berechnen müssen . Spart 11 Bytes, indem der Code entsprechend umgeschrieben wird.$\gcd(a,c)$

Nimmt die Eingabe als 3 separate Ganzzahlen. Gibt für ein ABC-Tripel oder entweder oder andernfalls .$true$$0$$false$

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

Probieren Sie es online!

Wolfram Language 24 30 28 26 Bytes

Mit 2 Bytes von Doorknob rasiert. Weitere 2 Bytes, die @jaeyong gesungen hat

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

C # (Visual C # Interactive Compiler) , 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]

Läuft für Nummern bis 1e8, dauert auf meinem Rechner ca. 35 Sekunden. Anstatt den gcd wie andere zu berechnen, instanziiert die Funktion einfach ein großes Array und filtert die Indizes, die keine Teiler von a oder b sind, und überprüft, wie viele Elemente übrig sind. Als nächstes wird geprüft, ob Element eins plus Element zwei gleich Element drei ist. Zuletzt wird geprüft, ob das erste Element kleiner als das zweite ist.

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 59 Byte

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

Probieren Sie es online!

ECMAScript Regex, 34 Bytes

Die Eingabe ist in der Domäne unär ^x*,x*,x*$(wiederholt xdurch ,).

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

Probieren Sie es online! (.NET Regex Engine)
Probieren Sie es online! (SpiderMonkey Regex Engine)

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

Die Frage lautet "Drei Ganzzahlen, dezimal geschrieben", sodass dies möglicherweise nicht qualifiziert ist (da Eingaben unärgerlich sind), aber es ergibt eine so elegante, reine Regex, dass ich hoffe, dass es zumindest geschätzt wird.

Beachten Sie jedoch, dass bei einer wörtlichen Interpretation der Phrasierung auch Lambda-Übermittlungen und Funktionsübermittlungen, die Ganzzahlargumente enthalten, zu disqualifizieren sind, da sie sich strikt an die Spezifikation der Frage halten und die Eingabe in Form einer Zeichenfolge vornehmen müssen.

J , 27 Bytes

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

Probieren Sie es online!

Inspiriert von Jo Kings Perl-Lösung

C # (.NET Core) , 68 Byte

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

Probieren Sie es online!

Stax , 12 Bytes

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

Führen Sie es aus und debuggen Sie es

Sauber , 43 Bytes

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

Probieren Sie es online!

Ähnlich wie im Grunde alles andere, da der direkte Test der gleiche ist.

Pari / GP , 30 Bytes

2 Bytes dank @Shaggy gespart .

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

Probieren Sie es online!

Befunge-98 (FBBI) , 83 Bytes

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

Probieren Sie es online!

Die Eingabe, bei der es sich um ein Dreifach von Ganzzahlen [A,B,C]handelt, wird als durch Leerzeichen getrennte Ganzzahlen in Befunge eingespeist C B A.

Mathematica 35 Bytes

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

wenn die Reihenfolge wichtig ist:

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

oder...

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

Retina 0.8.2 , 42 41 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: 1 Byte dank @Deadcode gespeichert. Erläuterung:

\d+
$*

In Unary konvertieren.

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

Stellen Sie sicher, dass A und B keinen gemeinsamen Faktor haben.

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

Überprüfen Sie, dass A <B und A + B = C.

Common Lisp, 51 Bytes

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

Probieren Sie es online!