给定一个数字n >= 2，输出小于nwhere的所有正整数gcd(n, k) == 1（k输出数字中的任何一个）。这类数字互为互质。

示例：10给出输出[1, 3, 7, 9]（只要您喜欢的任何形式，只要数字明确地分开并以某种形式列出即可）。该列表不能有重复的条目，也不必进行排序。

更多测试用例：

2 -> [1]
3 -> [1, 2]
6 -> [1, 5]
10 -> [1, 3, 7, 9]
20 -> [1, 3, 7, 9, 11, 13, 17, 19]
25 -> [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 21, 22, 23, 24]
30 -> [1, 7, 11, 13, 17, 19, 23, 29]

我们也不在n此之上算数n，因为我可以肯定地确定有无限的解决方案。

另请注意：互互质数也被称为互质数或互质数。

果冻，3 个字节

gÐṂ

在线尝试！

这是如何运作的？

gÐṂ-（单声道）完整程序。

g-最大公约数。
 ÐṂ-保持链接值最小的元素（即，GCD == 1的元素）
       请注意，这会自动创建范围[1，输入]（含）。

有效性证明

因为我们只想提取的coprimes，最大-共除数列表的最小值有是1的ÐṂ伎俩工作。让我们证明一下（用两种不同的方法）：

1. 隐式生成的范围包含和。最大公约数始终是严格的正整数，因此保证出现且始终为最小值。1 gcd （1 ，x ）= $[1, \text{input}]$$1$$\gcd(1, x) = 1\:\:\forall\:\:x \in \mathbb{Z}^{*}$$1$

2. 两个连续的正整数始终是互质的。考虑，其中。然后我们取另一个正整数，使和。 Ŷ = X + 1 ķ ķ | X ķ | $x, y \in \mathbb{Z}^{*}$$y = x + 1$$k$$k \mid x$$k \mid y$

   这意味着，所以，因此。除以的唯一正整数本身就是，因此可以保证它出现在列表中，并且始终是最小值。k ∣ （x + 1 − x ）k ∣ 1 1 $k \mid (y - x)$$k \mid (x + 1 - x)$$k \mid 1$$1$$1$

Python 2中，61个 47字节

lambda n:[k/n for k in range(n*n)if k/n*k%n==1]

在线尝试！

背景

考虑环 。尽管通常使用残基类定义此环，但也可以将其视为，其中加法和乘法运算符由定义。和，其中表示通常的加法，整数的乘法和模运算符。ñ Ž Ñ = { 0 ，... ，ñ - 1 } 一个+ Ñ b = （一个+ b $(Z_n, +_n, \cdot_n)$$n$$Z_n = \{0, \dots, n - 1\}$一个⋅ Ñ b = 一个⋅ $a +_n b = (a + b)\:\%\: n$+ $a \cdot_n b = a \cdot b\:\%\: n$$+,\:\cdot\text{, and } \%$

如果，则两个元素和称为模互乘逆。请注意，只要。b ž Ñ Ñ一个⋅ Ñ b = $a$$b$$Z_n$$n$$a \cdot_n b = 1\:\%\:n$n > $1\:\%\:n = 1$$n > 1$

固定，并让是的互质在。如果为两个元素和的，我们有。这意味着，我们遵循，即将均分。由于不与共享素数，这意味着。最后，因为一个Ñ ž ñ一个⋅ Ñ X = 一个⋅ Ñ ý X ý ž Ñ一个⋅ $n > 1$$a$$n$$Z_n$$a \cdot_n x = a \cdot_n y$$x$$y$$Z_n$一个⋅ （X - Ý $a \cdot x\:\%\:n = a \cdot y\:\%\:n$Ñ | 一个⋅ （X - Ý ）ñ 一个⋅ （X - Ý ）ñ 一个ñ | X - ý - Ñ < X - ý < Ñ X = ý 一个⋅ Ñ 0 ，... ，一个⋅ Ñ（Ñ − 1 ）Z n Z n n 1 b $a \cdot (x - y)\:\%\:n = a \cdot x\:\%\:n - a \cdot y\:\%\:n = 0$$n \mid a \cdot (x - y)$$n$$a \cdot (x - y)$$n$$a$$n \mid x - y$$-n < x - y < n$，我们得出结论。这表明乘积都是不同元素。由于正好具有元素，因此这些乘积中的一个（正好一个）必须等于，即存在唯一的，使得。$x = y$$a \cdot_n 0, \dots, a \cdot_n (n - 1)$$Z_n$$Z_n$$n$$1$ $b$一个⋅ Ñ b = $Z_n$$a \cdot_n b = 1$

相反，将固定，并让为不与互素的元素。在这种情况下，存在素数使得和。如果被接受的乘法逆模（我们称其为），我们将有，这意味着，因此，所以。由于，我们遵循一个Ž Ñ Ñ p p | 一个p | Ñ 一个Ñ b 一个⋅ Ñ b = 1 一个⋅ $n > 1$$a$$Z_n$$n$$p$$p \mid a$$p \mid n$$a$$n$$b$$a \cdot_n b = 1$（一个⋅ b - 1 $a \cdot b\:\%\:n = 1$Ñ | 一个⋅ b - 1个p | 一个p | 一个⋅ b p | Ñ p | 一个⋅ b - 1个p | （一个⋅ b ）- （一⋅ b - 1 ）= 1 $(a \cdot b - 1)\:\%\:n = a \cdot b\:\%\:n - 1 = 0$$n \mid a \cdot b - 1$$p \mid a$$p \mid a \cdot b$。另一方面，由于，我们也遵循。这样，，这与是素数的假设相矛盾。$p \mid n$$p \mid a \cdot b - 1$$p \mid (a \cdot b) - (a \cdot b - 1) = 1$$p$

这证明当时，以下语句是等效的。$n > 1$

• $a$和是互质的。$n$

• $a$一个乘积逆模。$n$

• $a$接受唯一的乘法逆模。$n$

这个怎么运作

对于每一对整数和在，整数是唯一的; 实际上，和是商，并且余除以，即给定，我们可以恢复和，其中表示整数除法。最后，由于和，因此是的元素；实际上，。b ž Ñ ķ ：= 一个⋅ Ñ + b 一个b ķ Ñ ķ 一个= ķ / Ñ b = $a$$b$$Z_n$$k := a \cdot n + b$$a$$b$$k$$n$$k$$a = k/n$/一个≤ ñ - 1 b ≤ ñ - 1个ķ Ž Ñ 2 ķ ≤ （ñ - 1 ）⋅ ñ + （ñ - 1 ）= ñ 2 - $b = k\:\%\: n$$/$$a ≤ n - 1$$b ≤ n - 1$$k$$Z_{n^2}$$k ≤ (n - 1) \cdot n + (n - 1) = n^2 - 1$

如上所述，如果和是互质的，则将有一个唯一的，使得，即，将有一个唯一的，使得和，所以所生成的列表将包含正好一次。Ñ b 一个＆CenterDot; $a$$n$$b$ķ ķ / Ñ = 一个ķ / Ñ ⋅ $a \cdot b\:\%\:n = 1$$k$$k / n = a$$k / n \cdot k\:\%\:n = (k / n) \cdot (k\:\%\:n)\:\%\:n = 1$$a$

相反，如果和是不互为素，条件会出现假用于的所有值使得，所以所生成的列表将不包含。Ñ ķ / Ñ ⋅ $a$$n$k a = k / n $k / n \cdot k\:\%\:n = 1$$k$$a = k / n$$a$

这证明了lambda返回的列表将只包含一次所有的互质数。ž $n$$Z_n$

果冻，4字节

gRỊT

在线尝试！

这个怎么运作

gRỊT  Main link. Argument: n

 R    Range; yield [1, ..., n].
g     Compute the GCD of n and each k in [1, ..., n].
  Ị   Insignificant; return 1 for GCDs less or equal to 1.
   T  Truth; yield the indices of all truthy elements.

Mathematica，25个字节

Range@#~GCD~#~Position~1&

有点奇怪的输出格式，其中每个结果都包装在单独的列表中，例如{{1}, {3}, {7}, {9}}。如果那还不行，那么我有两个30字节的解决方案：

Select[Range[x=#],#~GCD~x<2&]&
#&@@@Range@#~GCD~#~Position~1&

Mathematica实际上有，CoprimeQ但是那太长了。

2sable，4个字节

码：

ƒN¿–

说明：

ƒ       # For N in the range [0, input]..
 N¿     #   Compute the GCD of N and the input
   –    #   If 1, print N with a newline

使用CP-1252编码。在线尝试！

Python，93 82 74字节

f=lambda a,b:f(b,a%b)if b else a<2
lambda c:[i for i in range(c)if f(i,c)]

f递归检查互素，第二个lambda生成它们。输出列表。

实际上，8个字节

;╗R`╜┤`░

在线尝试！

说明：

;╗R`╜┤`░
  R`  `░  elements of range(1, n+1) where
;╗  ╜     n and the element
     ┤    are coprime

MATL，7个字节

:GZd1=f

在线尝试！

MATLAB / Octave，22个字节

@(n)find(gcd(1:n,n)<2)

在线尝试！

JavaScript（ES6），64 61字节

@ user81655节省了3个字节

n=>[...Array(n).keys()].filter(b=>(g=a=>b?g(b,b=a%b):a<2)(n))

测试片段

f=n=>[...Array(n).keys()].filter(b=>(g=a=>b?g(b,b=a%b):a<2)(n))

for(var i = 2; i < 50; i++) console.log(i + ":", `[${ f(i) }]`);

水母，19 18字节

p
[#
`B
&~xr1
NnEi

通过计算范围中每个数字的质数分解并检查它是否与输入的质数相交（水母还没有内置gcd），可以起作用。由于打高尔夫球的原因，输出按降序排列。 在线尝试！

说明

首先，i是评估输入；对于输入10，i-cell的值为10。

r1
i

这里r（范围）应用于输入和1。由于输入大于1，因此范围按降序排列；对于输入10，这给[9 8 7 6 5 4 3 2 1]。

[#
`B
&~x
Nn

这部分是一个很大的功能，i在上面和上面的范围内进行评估。

~x
n

n主因子（x）的交集（）。

&~x
Nn

是空的吗？（N）

`
&~x
Nn

转到级别0，测试范围内的每个元素。

[#
`B
&~x
Nn

过滤（#）关于此布尔值列表的范围。[要产生的函数要使用参数#作为自己的参数，因此我们将a设置B为禁止#获取任何参数。否则，~-cell 的值将用作big函数的参数。最后，p打印结果。

堆叠式非竞争，24 21字节

受Borsunho的红宝石启发，保存了3个字节。（1 eq至2<）

{!n:>1+:n gcd 2<keep}

在这里尝试！

这是一个n-lambda，它接受单个参数并产生数组。

{!n:>1+:n gcd 2<keep}
{!                  }  n-lambda
  n                    push n
   :>                  range [0, n)
     1+                range [1, n]
       :               duplicate
        n gcd          element-wise gcd with n
              2<       element-wise equality with 1
                       this yields the range [1, n] and a boolean mask of coprime numbers
                keep   then, we simply apply the mask to the range and keep coprimes.

CJam，14个字节

{:X{Xmff%:*},}

在线尝试！

说明

我们并不需要检查所有可能的除数a，并b测试它们是否是互质。看看是否存在任何主要的b分割因素就足够了a。

:X     e# Store the input in X.
{      e# Filter the list [0 1 ... X-1] by the results of this block...
  Xmf  e#   Get the prime factors of X.
  f%   e#   Take the current value modulo each of those prime factors.
  :*   e#   Multiply the results. Iff any of them divide the current
       e#   value, there's a 0 in the list, and the result of the product
       e#   is also 0, dropping the value from the resulting list.
},

Mathematica，26个字节

Pick[r=Range@#,r~GCD~#,1]&

Perl 6，20个字节

{grep 2>* gcd$_,^$_}

Brachylog，16 13字节

>.$p'(e:A*?),

此函数以N为输入，并生成所有小于并对其互质的整数。

在线尝试！与Brachylog中的情况一样，此代码中添加了额外的代码，以使该功能成为完整的程序。如果Brachylog的解释器具有功能而不是完整的程序，它将运行该解释器，但不输出输出，这意味着您无法真正观察其工作情况。

说明：

Brachylog程序是约束链。通常，一个约束的LHS是下一个约束的RHS。

>.$p'(e:A*?),
>              The input is greater than
 .             the output, whose
  $p           prime factorisation does
    '(     )   not obey the following constraint:
      e        it has an element which
       :A*     can be multiplied by something to
          ?    produce the input.
            ,  (This comma turns off an unwanted implicit constraint.)

通过意识到没有理由检查是否有公因数（已知为输出的素数）是否是输入的素数，可以细分三个字符。我们已经知道它是主要的，因此我们可以检查它是否是一个因素。我惊喜在这里，:A*?不发送解释陷入无限循环并且不允许非整数值一个，但作为解释我想要做什么，我会接受它。

Dyalog APL，10 个字节。

0~⍨⍳×1=⊢∨⍳

说明（输入n）：

0~⍨⍳×1=⊢∨⍳
         ⍳ - 1 ... n (Thus, ⎕IO is 1)
       ⊢∨  - Each GCD'd by n
     1=    - Test equality with 1 on each element
   ⍳×      - multiplied by its index
0~⍨        - without 0.

Japt -f，9 8 5 2个字节

jN

试试吧

• 由于ETH指出了Brainfart，因此节省了2个字节，从而节省了另一个字节。

Mathematica，33个字节

xSelect[Range@x,x~CoprimeQ~#&]

包含U + F4A1

Haskell，27个字节

f n=[k|k<-[1..n],gcd n k<2]

在线尝试！

朱莉娅0.5，23字节

!n=1÷gcd.(1:n,n)|>find

在线尝试！

模因，11字节无竞争，过时

非竞争性的STDIN迭代是新的。 使用UTF-8编码。

d`}}]i=1?ip

说明：

d     Set program to not output result
`}    Loop next input-times
}]i   GCD of input and loop index
=1?   Is it equal to 1? If yes,
ip    Print out loop index

}访问下一个输入项，但是如果给定最后一个输入，6则将其循环通过，因此输入的结果将6 6 6 6 6 ...与STDIN相同，从而可以从一个输入中读取两个输出。

05AB1E，3个字节

Lʒ¿

在线尝试！

具有新功能。

红宝石，36 34

->n{n.times{|i|p i if i.gcd(n)<2}}

诚然，这不是一个很有启发性的答案。

感谢Conor O'Brien，节省了2个字节。

Python 3，60个字节

导入gcd而不是为其编写新的lambda。欢迎打高尔夫球。在线尝试！

import math
lambda c:[i for i in range(c)if math.gcd(c,i)<2]

朱莉娅，30个字节

n->filter(x->(gcd(n,x)<2),1:n)

匿名函数。filter根据函数从列表中删除不真实的元素。

在这种情况下，函数为x->(gcd(n,x)<2)（如果输入和列表元素的gcd小于2 ，则为true）。该列表是范围1:n。

PARI / GP，27字节

n->[k|k<-[1..n],gcd(k,n)<2]

这使用版本2.6.0（2013）中引入的设置符号。在早期版本中，还需要四个字节：

n->select(k->gcd(k,n)<2,[1..n])

将需要。

05AB1E，4个字节

GN¿–

在线尝试！

这个怎么运作

     # implicit input
G    # for N in range(1..input)
 N   # push N
  ¿  # gcd(input, N)
   – # if 1, print N

C（gcc），54个字节

k;f(n){for(k=0;++k/n<n;k/n*k%n-1||printf("%u ",k/n));}

这是我的Python回答的一部分。

在线尝试！

Pyth，5个字节

x1iLQ

在线尝试！

这个怎么运作

请注意，Pyth使用0索引。

x1iLQ   Q = eval(input())

x1iLQQ  implicit Q at the end
  iLQQ  [gcd(Q,0), gcd(Q,1), ..., gcd(Q,Q-1)]
x1      all occurences of 1 in the above list (return their indices)