Bir sayı verildiğinde n >= 2, tüm pozitif tamsayıları ( çıktı numaralarından herhangi biriyle) olduğu nyerden daha az çıktılayın . Bu tür sayılar birbirlerinin kopyasıdır .gcd(n, k) == 1k

Örnek: 10Çıktıyı verir [1, 3, 7, 9](sayılar açıkça ayrılmadan ve bir çeşit listede olduğu sürece istediğiniz herhangi bir biçimde). Liste yinelenen girişlere sahip olamaz ve sıralanması gerekmez.

Daha fazla test durumu:

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]

Ayrıca, yukarıda sayısız nolan sayıları saymıyoruz n, çünkü yalnızca sonsuz çözümler bulunduğundan oldukça eminim.

Ayrıca not edin: Birbirlerine kopuk olan sayıların da birbirlerine göre asal veya karşılıklı asal olduğu söylenir.

Jöle , 3 bayt

gÐṂ

Çevrimiçi deneyin!

Bu nasıl çalışıyor?

gÐṂ - (Monadic) Tam program.

g - En büyük ortak bölen.
 Minimum - Elemanları minimum bağlantı değerine sahip tutun (örn. GCD == 1)
       Bunun otomatik olarak [1, giriş] (dahil) aralığını oluşturduğunu unutmayın.

Geçerlilik kanıtı

Biz sadece coprimes ayıklamak istediğimiz için, Greatest-Yaygın-Bölenler listenin minimum değer var olmak 1 için ÐṂhile çalışmak. Bunu ispatlayalım (iki farklı yöntemle):

1. Örtük olarak oluşturulan aralık, 1 ve$[1, \text{input}]$ içerir.$1$ . En büyük ortak bölen her zaman kesin olarak pozitif bir tamsayıdır, bu nedenlegerçekleşmesi garanti edilir ve her zaman minimum değer olacaktır.$\gcd(1, x) = 1\:\:\forall\:\:x \in \mathbb{Z}^{*}$$1$

2. İki ardışık pozitif tamsayı her zaman kopya olur. , ile düşünün . Sonra başka pozitif tam sayı almak öyle ki ve . y = x + 1 k k ∣ x k ∣ $x, y \in \mathbb{Z}^{*}$$y = x + 1$$k$$k \mid x$$k \mid y$

   Bu, , yani k ∣ ( x + 1 - x ) , yani . Bölmek için tek pozitif tam sayı ise listede görünmesini garanti ve her zaman minimum değer olacak, böylece kendisi.$k \mid (y - x)$$k \mid (x + 1 - x)$1 $k \mid 1$$1$$1$

Python 2 , 61 47 bayt

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

Çevrimiçi deneyin!

Arka fon

Halkayı düşünün . Bu halka genellikle modulo n kalıntı sınıfları kullanılarak tanımlanırken , toplama ve çarpma operatörlerinin a + n b = ( a ile tanımlandığı Z n = { 0 , … , n - 1 } kümesi olarak da düşünülebilir. + b $(Z_n, +_n, \cdot_n)$$n$$Z_n = \{0, \dots, n - 1\}$ ve a ⋅ n b = a ⋅ $a +_n b = (a + b)\:\%\: n$ , burada + $a \cdot_n b = a \cdot b\:\%\: n$ , tamsayılar üzerinde normal toplama, çarpma ve modulo operatörlerini belirtir.$+,\:\cdot\text{, and } \%$

İki elemanın ve b arasında Z'nin n karşılıklı olarak adlandırılır çarpımsal tersleri modulo n ise , bir ⋅ n b = $a$$b$$Z_n$$n$ . 1 olduğunu unutmayın$a \cdot_n b = 1\:\%\:n$ olduğunda , n > 1 .$1\:\%\:n = 1$$n > 1$

Fix ve let bir bir göreceli asal olmak n içinde Z n . Eğer bir ⋅ n x = a ⋅ n y iki eleman için x ve y ve Z, n , sahip olduğu bir ⋅ $n > 1$$a$$n$$Z_n$$a \cdot_n x = a \cdot_n y$$x$$y$$Z_n$ . Bu bir ⋅ ( x - y ) anlamına gelir$a \cdot x\:\%\:n = a \cdot y\:\%\:n$ , ve de onu takip n | bir ⋅ ( x - y ) , yani N bölen bir ⋅ ( x - y ) eşit. Yana n ile hisselerin hiçbir asal bölenler bir , bu demektir n | x - y . Son olarak, - n < x - y < n olduğundan , x = y olduğu sonucuna vardık. Bu, ürünlerin bir ⋅ olduğunu gösterir.$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$ tüm farklı elemanları , Z , n . Bu yana , Z , n tam olarak bulunur , n elemanları eşit olmalıdır, bu ürünlerin bir (ve tam bir) 1 , yani, bir olduğueşsiz b içinde Z , n , öyle ki bir ⋅ n b = 1 .$a \cdot_n 0, \dots, a \cdot_n (n - 1)$$Z_n$$Z_n$$n$$1$ $b$$Z_n$$a \cdot_n b = 1$

Bunun aksine, düzeltmek ve izin bir unsuru olarak , Z , n olduğu değil için asal n . Bu durumda, bir asal vardır p böyle p | a ve p | n . Eğer bir çarpımsal ters modülo kabul n (diyelim b , bunu olurdu) bir ⋅ n b = 1 , yani bu bir ⋅ $n > 1$$a$$Z_n$$n$$p$$p \mid a$$p \mid n$$a$$n$$b$$a \cdot_n b = 1$ ve bu nedenle, ( a ⋅ b - 1 $a \cdot b\:\%\:n = 1$ , yani n ∣ a ⋅ b - 1 . Yana p | bir , de onu takip p | bir ⋅ b . Öte yandan, çünkü p | n , biz de o izleyin p | a ⋅ b - 1 . Bu şekilde, p ∣ ( a ⋅ b ) - ( a ⋅ b - 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$ki bu, asal bir sayı olduğu varsayımına aykırıdır .$p$

Bu, aşağıdaki ifadelerin olduğunda eşdeğer olduğunu kanıtlar .$n > 1$

• ve n eşittir.$a$$n$

• çarpımsal ters modül kabul n .$a$$n$

• bir itirafbenzersizçarpımsal ters modülo n .$a$$n$

Nasıl çalışır

Her bir tamsayı çifti için ve b olarak Z, n , tam sayı k : = bir ⋅ n + b benzersizdir; Aslında, a ve b , k ' nin bölümü ve kalanı n ' ye bölünür , yani k verildiğinde , a = k / n ve b = k ' ı kurtarabiliriz.$a$$b$$Z_n$$k := a \cdot n + b$$a$$b$$k$$n$$k$$a = k/n$ ,tamsayılıbölmenerede / anlamına gelir. Son olarak, bu yana bir ≤ n - 1 ve b ≤ n - 1 , k, bir elemanıdır , Z , n 2 ; aslında, k ≤ ( n - 1 ) ⋅ N + ( n - 1 ) = N 2 - 1 .$b = k\:\%\: n$$/$$a ≤ n - 1$$b ≤ n - 1$$k$$Z_{n^2}$$k ≤ (n - 1) \cdot n + (n - 1) = n^2 - 1$

Yukarıda belirtildiği gibi, eğer ve n, göreceli asal olan, benzersiz olacaktır b böyle bir ⋅ $a$$n$$b$ , yani, benzersiz olacaktır k , öyle ki k / n = a ve k / n ⋅ $a \cdot b\:\%\:n = 1$$k$$k / n = a$ , üretilen liste çok içerecek bir tam olarak bir kez.$k / n \cdot k\:\%\:n = (k / n) \cdot (k\:\%\:n)\:\%\:n = 1$$a$

Tersine, eğer ve n edilir değil asal, durumu k / n ⋅ $a$$n$ ve tüm değerleri için yanlış olacaktır k , öyle ki , bir = k / n , üretilen bir liste böylecedeğiliçeren bir .$k / n \cdot k\:\%\:n = 1$$k$$a = k / n$$a$

Bu liste kanıtlıyor lambda döner tüm içerecektir içinde 'ın coprimes Z n tam olarak bir kez.$n$$Z_n$

Jöle , 4 bayt

gRỊT

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Her bir sonuç ayrı bir listede sarılır Biraz garip çıkış biçimi, örneğin {{1}, {3}, {7}, {9}}. Sorun değil, 30 baytta iki çözüm buldum:

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

Mathematica aslında var CoprimeQama bu çok uzun.

2sable , 4 bayt

Kod:

ƒN¿–

Açıklama:

ƒ       # 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 kodlamasını kullanır . Çevrimiçi deneyin!

Python, 93 82 74 bayt

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)]

ftekrarlı olarak kopyaları kontrol eder ve ikinci lambda bunları üretir. Bir liste çıkarır.

Aslında 8 bayt

;╗R`╜┤`░

Çevrimiçi deneyin!

Açıklama:

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

MATL , 7 bayt

:GZd1=f

Çevrimiçi deneyin!

MATLAB / Octave, 22 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 64 61 bayt

@ User81655 sayesinde 3 bayt kaydedildi

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

Test pasajı

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) }]`);

Denizanası , 19 18 bayt

p
[#
`B
&~xr1
NnEi

Bu, aralıktaki her sayının asal çarpanlarını hesaplayarak ve girdiyle kesişip kesişmediğini kontrol ederek çalışır (Denizanası henüz bir gcd yerleşikine sahip değildir). Golf nedeniyle, çıkış azalan sırada. Çevrimiçi deneyin!

açıklama

İlk olarak, igirdi değerlendirilir; giriş 10için i-cell'in değeri 10.

r1
i

Burada r(aralık) girişe ve 1'e uygulanır. Giriş 1'den büyük olduğundan, aralık azalan sıradadır; giriş için 10bu verir [9 8 7 6 5 4 3 2 1].

[#
`B
&~x
Nn

Bu bölüm, iyukarıdaki aralıkta değerlendirilen büyük bir fonksiyondur .

~x
n

nAsal faktörlerin ( x) kesişimi ( ).

&~x
Nn

Boş mu? ( N)

`
&~x
Nn

Seviyenin her bir elemanı için test ederek seviye 0'a geçirin.

[#
`B
&~x
Nn

#Bu boolean listesine göre aralığı ( ) filtreleyin . Üretilen işlev [, argümanı #kendi argümanı olarak kullanmak istiyor , bu yüzden herhangi bir argüman almasını Bengellemeye çalışıyoruz #. Aksi takdirde ~-cell'in değeri , büyük fonksiyonun argümanı olarak kullanılır. Sonunda psonucu yazdırır.

Yığılmış, rekabet etmeyen, 24 21 bayt

Borsunho'nun yakutundan esinlenerek 3 bayt kurtarıldı . ( 1 eqiçin 2<)

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

Burada dene!

Bu, tek bir argüman alan ve diziyi veren bir n-lambdadır.

{!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 bayt

{:X{Xmff%:*},}

Çevrimiçi deneyin!

açıklama

Muhtemel bütün bölenleri kontrol etmemize ave bonların koprime olup olmadıklarını test etmemize gerek yok. bBölünmenin ana faktörlerinden herhangi birinin olup olmadığına bakmak yeterlidir 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 bayt

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

Perl 6 , 20 bayt

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

Brachylog , 16 13 bayt

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

Bu alan bir fonksiyonudur N girdi olarak ve üretir buna tümünden daha az tam sayıları ile asal.

Çevrimiçi deneyin! Brachylog’da olduğu gibi, fonksiyonu tam bir program haline getirmek için ek kod eklenmiştir; Brachylog'un tercümanı, eğer tam bir programdan ziyade bir işlev verildiyse, onu çalıştıracak, ancak çıktısını basmayacaktır, bu da çalışmalarını gerçekten gözlemleyemediğiniz anlamına gelir.

Açıklama:

Brachylog programı bir kısıtlar zinciridir; tipik olarak, bir kısıtlamanın LHS'si diğerinin RHS'sidir.

>.$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.)

Ortak bir faktörün (halihazırda çıktının ana bir faktörü olduğu bilinen) girişin ana faktörü olup olmadığını kontrol etmek için hiçbir neden bulunmadığını fark ederek üç karaktere düşürüldü . Asal olduğunu zaten biliyoruz, bu yüzden faktör olup olmadığını kontrol edebiliriz. Hoş burada şaşırdım :A*?sonsuz döngüye tercüman göndermez ve bir tam sayı olmayan değeri izin vermez A , ancak tercüman ne istiyorum yaptığı gibi, ben alacağım.

Dyalog APL, 10 bayt .

0~⍨⍳×1=⊢∨⍳

Açıklama (giriş 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 bayt

jN

Dene

• ETH sayesinde kaydedilen 2 bayt , bir başka bayta kaydedilen bir beyin fırtınasını işaret etti.

Mathematica, 33 bayt

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

U + F4A1 içerir

Haskell, 27 bayt

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

Çevrimiçi deneyin!

Julia 0.5 , 23 bayt

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

Çevrimiçi deneyin!

memes , 11 bayt rekabet eden , modası geçmiş

STDIN'in yinelenmesi yeni olduğu için rekabet dışı. UTF-8 kodlamasını kullanır.

d`}}]i=1?ip

Açıklama:

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

}bir sonraki giriş öğesine erişir, ancak son giriş verildiğinde çevrilir, bu nedenle giriş STDIN'de 6olduğu gibi sonuçlanır 6 6 6 6 6 ...ve birinden iki çıkış okunmasını mümkün kılar.

05AB1E , 3 bayt

Lʒ¿

Çevrimiçi deneyin!

Yeni özelliklere sahip.

Ruby, 36 34

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

Kuşkusuz, bu çok ilham verici bir cevap değil.

Conor O'Brien sayesinde 2 bayt kurtarıldı.

Python 3 , 60 bayt

Bunun için yeni bir lambda yazmak yerine gcd alır. Golf önerileri kabul edilir. Çevrimiçi deneyin!

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

Julia, 30 bayt

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

Anonim işlev filterbir işleve göre truthy olmayan bir listeden öğeleri kaldırır.

Bu durumda, işlev x->(gcd(n,x)<2)(girişin gcd'si ve liste öğesinin 2'den küçük olması durumunda geçerlidir). Liste aralığıdır 1:n.

PARI / GP , 27 bayt

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

Bu, 2.6.0 (2013) versiyonunda belirtilen set gösterimini kullanır. Daha önceki sürümlerde dört bayt daha gerekiyordu:

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

gerekli olacaktı.

05AB1E , 4 bayt

GN¿–

Çevrimiçi deneyin!

Nasıl çalışır

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

C (gcc) , 54 bayt

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

Bu Python cevabımın bir limanı .

Çevrimiçi deneyin!

Pyth , 5 bayt

x1iLQ

Çevrimiçi deneyin!

Nasıl çalışır

Pyth'in 0 indeksleme kullandığını unutmayın.

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)