如果三个正整数A，B，C是互质的，则它们是ABC三元组，且A <B且满足以下关系：A + B = C

例子：

1, 8, 9 是ABC三元组，因为它们是互质的，1 <8和1 + 8 = 9
6, 8, 14 不是因为他们不是互质素
7, 5, 12 不是因为7> 5

您可以查看此Frits Beukers 2005演示文稿，以获取有关ABC-三元组的更多详细信息。

输入输出

三个整数，十进制写成。可能是单独的值或列表。无论三个整数是否是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]

— 大卫
source

输出是否仅是两个值之一，还是可以为不同的输入输出不同的真实/虚假值？

— Luis Mendo

我认为应该是一致的：无论输入如何，您的代码都必须输出一种真实/错误值。但是，诚实/虚假夫妇可能是您想要的，因为它能完成工作：区分列表。

— 大卫

如果我们将输入作为三个值的列表，则输入必须按顺序排列[A,B,C]，还是也可以按顺序[C,B,A]或按顺序接受输入[C,A,B]？

— 凯文·克鲁伊森

您必须尊重秩序，因为A <B是挑战的标准。

— 大卫

1

我不认为要求特定的列表顺序与允许将输入作为单独的值兼容，因为单独的值本质上是无序的并且可能被当作list。

— 丹尼斯，

8

果冻，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).

— 丹尼斯
source

8

Haskell，48 38 29字节

^{由于TFeld的gcd把戏，-10个字节！}

^{-7个字节感谢HPWiz改进了互素性测试并发现了多余的空间！}

^{-2个字节感谢nimi建议使用infix-operator！}

(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)$ ：

写 $\gcd(a,c) = U \cdot a + V \cdot c$ 使用贝祖等式而代 $c = a + b$ 给出：

U \cdot a + V \cdot (a + b) = (U + V) \cdot a + V \cdot b

$U \cdot a + V \cdot (a + b) = (U + V) \cdot a + V \cdot b$

由于该 $\gcd$ 是到该身份的最小正解它遵循 $\gcd(a,b) = \gcd(a,c)$ 。另一种情况是对称的。

— ბიმო
source

1

另外，我相信您只需要这样做gcd a b==1。由于gcd a b分歧a+b=c。即gcd(gcd a b)c=gcd a b

— H.PWiz

@HPWiz：好的，当然，谢谢！以后不在手机上时，将进行编辑。

— ბიმო19年

7

Perl 6的，33 32个字节

-1字节感谢nwellnhof

{(.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

— 乔·金
source

2

32个字节

— nwellnhof，

5

Excel，33个字节

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

— 韦尼施
source

4

bash，61个字节

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

在线尝试！

输入作为命令行参数，在退出代码中输出（也会在stdout上产生输出，这是副作用，但是可以忽略）。

第二部分（从开始&&((）是非常标准的，但是有趣的是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

— 门把手
source

最后&&可以改变&，因为优先

— 纳乌艾尔乌Fouilleul

4

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

-1个字节感谢@Shaggy。

在线尝试。

说明：

(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

— 凯文·克鲁伊森
source

a==1-> a<2保存一个字节。

— 粗野的

@粗野的谢谢！

— 凯文·克鲁伊森

4

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 ?

— 艾米尼亚
source

糟糕，..删除了我的评论。.> >>同样，您可以使用倍数而不是与产品RÆ_*`\‹*¿Θ Test Suite交换来节省一个字节。

— 凯文·克鲁伊森

@KevinCruijssen：谢谢！是的，通常当您进行大量交换时，您做错了：P

— Emigna

3

Python 2中，69个 67 63 62 55字节

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

在线尝试！

Python 3中，58 51个字节的

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

在线尝试！

_{-7个字节，感谢H.PWiz}

— 场
source

是gcd在gcd招是否有效？如果a不是互质的c呢？

— 乔·金

2

@ jo-king如果p将a和c相除，则应将ca除以b。

— 大卫，

2

@JoKing：在这种情况下，但不是一般情况（您可以通过Bezout的身份证明这一点）。

— ბიმო

您可以将它进一步使用并使用gcd(a,b)，因为gcd(a,b)划分a+b

— H.PWiz

@ H.PWiz谢谢:)

— TF

3

贾普特（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

— 毛茸茸
source

这是另一个11字节的解决方案，尽管仔细检查后发现，它的实际逻辑与您没有太大不同。

— 卡米尔·德拉卡里

@KamilDrakari，在一个阶段也对此有所不同。如果遵循follow时自动插入变量，则可能为10个字节。>©

— 毛茸茸的

3

JavaScript（ES6）， 54 43 42 40字节

$\gcd(a,c)$ 。通过相应地重写代码节省了11个字节。

$true$ $0$ $false$

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

在线尝试！

— Arnauld
source

1

我认为您不需要测试gcd(c,a)。

— 毛茸茸的

@粗野的谢谢！我已经完全重写了代码。

— Arnauld

3

Wolfram语言24 30 28 26字节

用Doorknob刮掉2个字节。@jaeyong sung删除了另外2个字节

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

— 戴维
source

我认为您也应该可以使用CoprimeQ@##节省2个字节。

— 门把手

@Doorknob，如果第一个和第二个数字是互质的，那么它们是否必须与它们的和互质？

— DavidC

它们是，但是原始定义实际上指出A，B和C应该是互质的。大多数答案仅检查A和B只是因为它通常更短。

— 门把手

我认为，GCD@##==1将节省2个字节

— jaeyong唱

2

C＃（Visual C＃交互式编译器），90字节

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]

数字最多可运行1e8，在我的计算机上大约需要35秒。该函数无需像其他方法一样计算gcd，而只是实例化一个巨大的数组并过滤非a或b除数的索引，并检查还剩下多少个元素。接下来，检查元素一加元素二是否等于元素三。最后，它检查第一个元素是否小于第二个元素。

在线尝试！

— 无知的体现
source

2

C＃（Visual C＃交互式编译器），59字节

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

在线尝试！

— 达娜
source

2

ECMAScript Regex，34个字节

输入为一元，在域中^x*,x*,x*$（重复x的，以分隔,）。

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

在线尝试！（.NET正则表达式引擎）
在线尝试！（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.

这个问题的确是“三个整数，十进制写成”，所以这可能不符合条件（因为它以一元形式输入），但是它使这种优雅的纯正则表达式值得我至少希望受到赞赏。

但是，请注意，如果要从字面上解释措词，则采用整数参数的lambda和函数提交也将被取消资格，以严格遵守问题的规范，它们将需要采用字符串形式的输入。

— 死码
source

1

J，27个字节

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

在线尝试！

受到Jo King Perl解决方案的启发

— 加伦·伊万诺夫（Galen Ivanov）
source

1

C＃（.NET Core），68字节

没有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;};

在线尝试！

— 毁灭性
source

1

Stax，12 个字节

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

运行并调试

— 浪费
source

通过稍微重新排列，您可以获得11。staxlang.xyz/…–

— 递归

1

干净，43字节

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

在线尝试！

基本上与其他所有内容相似，因为直接测试是相同的。

— 巨大
source

1

Pari / GP，30字节

@Shaggy节省了2个字节。

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

在线尝试！

— Alephalpha
source

1

30字节（？）

— 粗野的

1

Befunge-98（FBBI），83个字节

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

在线尝试！

输入是整数的三倍，[A,B,C]以空格分隔的整数形式输入到Befunge中C B A。

— 维斯瓦
source

1

Mathematica 35字节

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

如果订单很重要：

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

要么...

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

— 戴维·斯托克
source

1

视网膜0.8.2，42 41个字节

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

在线尝试！链接包括测试用例。编辑：由于@Deadcode，节省了1个字节。说明：

\d+
$*

转换为一元。

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

检查A和B没有共同因素。

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

检查A <B和A + B =C。

— 尼尔
source

1

您的程序中似乎有一个错误。[121，48234375，48234496]返回false。

— Deadcode，

1

@Deadcode已修复，感谢您告诉我。

— 尼尔，

与我的正则表达式一样，您可以通过更改^(1+),(1+\1),\1\2$为删除1个字节^(1+)(,1+\1)\2\1$。

— Deadcode，

1

@Deadcode谢谢！我使用Retina的A操作实际上没有为我节省任何字节，这真是令人遗憾。

— 尼尔，

1

@Deadcode我正在使用Retina的行为，即将最后一个正则表达式转换为肯定断言（实际上是（匹配阶段）），因此移动antigrep将花费我5个字节。

— 尼尔，

1

Common Lisp，51个字节

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

在线尝试！

— 伦佐
source

查找列表是否为ABC三重

输入输出

测试用例

果冻，10 9字节

怎么运行的

Haskell，48 38 29字节

说明

Perl 6的，33 32个字节

说明

Excel，33个字节

bash，61个字节

Java 10、65 64字节

05AB1E，12 11 10字节

Python 2中，69个 67 63 62 55字节

Python 3中，58 51个字节的

贾普特（16） 14 13 11字节

JavaScript（ES6）， 54 43 42 40字节

Wolfram语言24 30 28 26字节

C＃（Visual C＃交互式编译器），90字节

C＃（Visual C＃交互式编译器），59字节

ECMAScript Regex，34个字节

J，27个字节

C＃（.NET Core），68字节

Stax，12 个字节

干净，43字节

Pari / GP，30字节

Befunge-98（FBBI），83个字节

Mathematica 35字节

视网膜0.8.2，42 41个字节

Common Lisp，51个字节