Ba số nguyên dương A, B, C là ABC-triple nếu chúng là nguyên tố cùng nhau, với A <B và thỏa mãn mối quan hệ: A + B = C

Ví dụ:

• 1, 8, 9 là bộ ba ABC vì chúng là nguyên tố cùng nhau, 1 <8 và 1 + 8 = 9
• 6, 8, 14 không phải vì họ không hợp tác
• 7, 5, 12 không phải vì 7> 5

Bạn có thể xem bài thuyết trình Frits Beukers 2005 này để biết thêm chi tiết về bộ ba ABC.

Đầu ra đầu vào

Ba số nguyên, viết thập phân. Có thể được tách giá trị hoặc danh sách. Đầu ra phải là một giá trị trung thực / sai lệch cho dù ba số nguyên là một bộ ba ABC.

Lưu ý: Điều quan trọng là phải tôn trọng thứ tự số nguyên trong danh sách, ví dụ: 1, 8, 9không được coi là cùng danh sách với 9, 1, 8hoặc bất kỳ kết hợp nào khác. Vì vậy, thứ nhất là một ABC-triple và thứ hai là không.

Do đó A là phần tử đầu tiên của danh sách, B thứ hai và C là thứ ba.

Các trường hợp thử nghiệm

Mỗi danh sách sau đây sẽ xuất ra một giá trị trung thực

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

Mỗi danh sách sau đây sẽ xuất ra giá trị falsey

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

Thạch , 10 9 byte

Ṫ=S×</=g/

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṫ=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 do mánh khóe của TFeldgcd !}

^{-7 byte nhờ HPWiz đã cải thiện bài kiểm tra tính nguyên thủy và phát hiện ra một không gian thừa!}

^{-2 byte nhờ nimi đã gợi ý toán tử infix!}

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

Hãy thử trực tuyến!

Giải trình

Hai điều kiện đầu tiên a < bvà a + b == ckhá rõ ràng, điều kiện thứ ba sử dụng :$\gcd(a,b) = \gcd(a,c) = \gcd(b,c)$

Viết bằng cách sử dụng danh tính của Bézout và thay thế sẽ cho:$\gcd(a,c) = U \cdot a + V \cdot c$c = a + b$c = a + b$

Kể từ khi các là giải pháp tích cực tối thiểu để nhận dạng mà nó sau đó . Các trường hợp khác là đối xứng.$\gcd$$\gcd(a,b) = \gcd(a,c)$

Perl 6 , 33 32 byte

-1 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Khối mã ẩn danh nhận danh sách gồm ba số và trả về Đúng hoặc Sai.

Giải trình

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

Hãy thử trực tuyến!

Nhập dưới dạng đối số dòng lệnh, đầu ra trong mã thoát (cũng tạo đầu ra trên thiết bị xuất chuẩn dưới dạng hiệu ứng phụ, nhưng điều này có thể bị bỏ qua).

Phần thứ hai (bắt đầu từ &&(() khá chuẩn, nhưng điều thú vị là thử nghiệm đồng thời:

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 cảm ơn @Shaggy .

Hãy thử trực tuyến.

Giải trình:

(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

Đã lưu 1 byte nhờ Kevin Cruijssen

ÂÆ_*`\‹*¿Θ

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

Hãy thử trực tuyến!

Python 3 , 58 51 byte

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

Hãy thử trực tuyến!

_{-7 byte, nhờ H.PWiz}

Japt , 16 14 13 11 byte

<V¥yU «NÔr-

Thử nó

                :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

$\gcd(a,c)$

$true$$0$$false$

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram 24 30 28 26 byte

Với 2 byte được cạo bởi Doorknob. Thêm 2 byte bị loại bỏ bởi @jaeyong sung

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

C # (Trình biên dịch tương tác 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]

Chạy cho các số lên tới 1e8, mất khoảng 35 giây trên máy của tôi. Thay vì tính toán gcd như những người khác, hàm chỉ khởi tạo một mảng lớn và lọc các chỉ mục không phải là ước của a hoặc b, và kiểm tra xem còn lại bao nhiêu phần tử. Tiếp theo nó kiểm tra xem phần tử một cộng với phần tử hai có bằng phần tử ba không. Cuối cùng, nó kiểm tra xem phần tử thứ nhất nhỏ hơn phần tử thứ hai.

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 59 byte

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

Hãy thử trực tuyến!

Regex ECMAScript, 34 byte

Đầu vào là đơn nhất, trong miền ^x*,x*,x*$(lặp lại xs được phân tách bởi ,).

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

Hãy thử trực tuyến! (.NET regex engine)
Hãy thử trực tuyến! (Công cụ 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.

Câu hỏi có câu "Ba số nguyên, số thập phân được viết", do đó, điều này có thể không đủ điều kiện (vì nó có đầu vào là unary), nhưng nó tạo ra một biểu thức thuần túy thanh lịch như vậy mà tôi hy vọng nó ít nhất sẽ được đánh giá cao.

Tuy nhiên, lưu ý rằng nếu cụm từ được hiểu theo nghĩa đen, lambda và các đệ trình hàm có đối số nguyên cũng sẽ bị loại, vì tuân thủ nghiêm ngặt các đặc điểm kỹ thuật của câu hỏi, chúng sẽ cần phải nhập dữ liệu dưới dạng chuỗi.

J , 27 byte

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

Hãy thử trực tuyến!

Lấy cảm hứng từ giải pháp Jo King Perl

C # (.NET Core) , 68 byte

Không có 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;};

Hãy thử trực tuyến!

Stax , 12 byte

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

Chạy và gỡ lỗi nó

Sạch , 43 byte

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

Hãy thử trực tuyến!

Tương tự như về cơ bản mọi thứ khác vì kiểm tra trực tiếp là như nhau.

Pari / GP , 30 byte

Đã lưu 2 byte nhờ @Shaggy .

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

Hãy thử trực tuyến!

Befunge-98 (FBBI) , 83 byte

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

Hãy thử trực tuyến!

Đầu vào là một bộ ba số nguyên [A,B,C]được đưa vào Befunge dưới dạng số nguyên được phân tách bằng dấu cách C B A.

Toán học 35 byte

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

nếu thứ tự là quan trọng:

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

hoặc là...

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

Võng mạc 0.8.2 , 42 41 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 1 byte nhờ @Deadcode. Giải trình:

\d+
$*

Chuyển đổi sang unary.

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

Kiểm tra xem A và B không có yếu tố chung.

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

Kiểm tra xem A <B và A + B = C.

Lisp thông thường, 51 byte

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

Hãy thử trực tuyến!