3 개의 양의 정수 A, B, C가 A <B이고 관계를 만족하는 코 프라임 인 경우 ABC- 트리플입니다 : A + B = C

예 :

• 1, 8, 9 coprime이므로 ABC-triple입니다. 1 <8 및 1 + 8 = 9
• 6, 8, 14 그들이 coprime이 아니기 때문에 아닙니다
• 7, 5, 12 7> 5가 아니기 때문에

당신은 이것을 볼 수 있습니다 ABC 트리플에 대한 자세한 내용 Frits Beukers 2005 프레젠테이션 을 참조하십시오.

입출력

3 개의 정수, 10 진수로 작성되었습니다. 값 또는 목록을 구분할 수 있습니다. 세 정수가 ABC- 트리플인지 여부에 대한 결과는 진실 / 거짓 값이어야합니다.

참고 : 목록에서 정수 순서를 존중하는 것이 중요합니다. 예를 들면 다음 1, 8, 9과 같습니다.9, 1, 8 또는 다른 조합 . 첫 번째는 ABC- 트리플이고 두 번째는 그렇지 않습니다.

따라서 A는 목록의 첫 번째 요소이고 B는 두 번째이고 C는 세 번째입니다.

테스트 사례

다음 각 목록은 정확한 값을 출력해야합니다

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

다음 각 목록은 잘못된 값을 출력해야합니다.

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

젤리 , 10 9 바이트

Ṫ=S×</=g/

온라인으로 사용해보십시오!

작동 원리

Ṫ=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).

하스켈 , 48 38 29 바이트

^{TFeld 의 gcd트릭 으로 인해 -10 바이트 !}

^{공동 우선 순위 테스트를 개선하고 불필요한 공간을 발견 한 HPWiz 덕분에 -7 바이트 !}

^{infix-operator를 제안한 nimi 덕분에 -2 바이트 !}

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

온라인으로 사용해보십시오!

설명

처음 두 상태 a < b와 a + b == c저, 세번째 용도 상당히 명백하다 $\gcd(a,b) = \gcd(a,c) = \gcd(b,c)$ :

Bézout의 아이덴티티를 사용하여 $\gcd(a,c) = U \cdot a + V \cdot c$ 을 쓰고 c = a + b로 대체 하면 다음과 같습니다.$c = a + b$

이후 GCD은 그 신원 최소 양의 용액 인 것이 그 다음 GCD ( , B ) = GCD ( , C를 ) . 다른 경우는 대칭입니다. $\gcd$$\gcd(a,b) = \gcd(a,c)$

펄 6 , 33 32 바이트

nwellnhof 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

세 개의 숫자 목록을 가져와 True 또는 False를 반환하는 익명 코드 블록입니다.

설명

{                              }  # 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 바이트

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

bash, 61 바이트

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

온라인으로 사용해보십시오!

명령 행 인수로 입력하고 종료 코드로 출력합니다 (stdout에서 부작용으로 출력을 생성하지만 무시할 수 있음).

에서 시작하는 두 번째 부분 &&((은 꽤 표준이지만 재미있는 부분은 코 프라임 테스트입니다.

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

자바 10, 65 64 바이트

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

@Shaggy 에게 -1 바이트 감사합니다 .

온라인으로 사용해보십시오.

설명:

(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 바이트

Kevin Cruijssen 덕분에 1 바이트 절약

ÂÆ_*`\‹*¿Θ

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

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

파이썬 2 , 69 67 63 62 55 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 58 51 바이트

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

온라인으로 사용해보십시오!

_{H.PWiz 덕분에 -7 바이트}

Japt , 16 14 13 11 바이트

<V¥yU «NÔr-

시도 해봐

                :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

Thanks to @Shaggy for pointing out that we don't need to compute $\gcd(a,c)$. Saved 11 bytes by rewriting the code accordingly.

Takes input as 3 separate integers. Returns $true$ for an ABC-triple, or either $0$ or $false$ otherwise.

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

Try it online!

Wolfram Language 24 30 28 26 bytes

With 2 bytes shaved by Doorknob. A further 2 bytes shaved off by @jaeyong sung

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

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

Runs for numbers up to 1e8, takes about 35 seconds on my machine. Instead of calculating the gcd like others, the function just instantiate a huge array and filter the indexes that aren't divisors of a or b, and check how many elements are left. Next it check if element one plus element two equals element three. Lastly, it checks if the first element is less than the second.

Try it online!

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

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

Try it online!

ECMAScript Regex, 34 bytes

Input is in unary, in the domain ^x*,x*,x*$ (repeated xs delimited by ,).

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

Try it online! (.NET regex engine)
Try it 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.

The question does say "Three integers, decimal written", so this might not qualify (as it takes input in unary), but it makes for such an elegant pure regex that I hope it will at least be appreciated.

However, note that if the phrasing is to be literally interpreted, lambda and function submissions that take integer arguments are to be disqualified too, as to strictly adhere to the question's specification they would need to take the input in the form of a string.

J, 27 bytes

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

Try it online!

Inspired by Jo King's Perl solution

C# (.NET Core), 68 bytes

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

Try it online!

Stax, 12 bytes

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

Run and debug it

Clean, 43 bytes

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

Try it online!

Similar to basically everything else because the direct test is the same.

Pari/GP, 30 bytes

Saved 2 bytes thanks to @Shaggy.

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

Try it online!

Befunge-98 (FBBI), 83 bytes

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

Try it online!

The input which is a triple of integers [A,B,C] is feeded into Befunge as space-separated integers C B A.

Mathematica 35 bytes

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

if order is important:

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

or...

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

Retina 0.8.2, 42 41 bytes

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

Try it online! Link includes test cases. Edit: Saved 1 byte thanks to @Deadcode. Explanation:

\d+
$*

Convert to unary.

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

Check that A and B have no common factor.

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

Check that A < B and A + B = C.

Common Lisp, 51 bytes

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

Try it online!