Bei einer gegebenen Zahl n >= 2werden alle positiven ganzen Zahlen kleiner als nwhere ausgegeben gcd(n, k) == 1(wobei kes sich um eine der ausgegebenen Zahlen handelt). Zahlen dieser Art sind miteinander koprimiert .

Beispiel: 10gibt die Ausgabe aus [1, 3, 7, 9](in beliebiger Form, solange die Zahlen eindeutig getrennt sind und in einer Liste stehen). Die Liste darf keine doppelten Einträge enthalten und muss nicht sortiert werden.

Weitere Testfälle:

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]

Wir zählen auch keine Zahlen darüber n, für die Coprime gilt n, nur weil ich ziemlich sicher bin, dass es unendlich viele Lösungen gibt.

Beachten Sie auch: Zahlen, die miteinander in Zusammenhang stehen, gelten ebenfalls als relativ prim oder für sich gegenseitig prim.

Gelee , 3 Bytes

gÐṂ

Probieren Sie es online!

Wie funktioniert das?

gÐṂ - (Monadic) Volles Programm.

g - Größter gemeinsamer Teiler.
 ÐṂ - Behalte die Elemente mit dem minimalen Verknüpfungswert (dh die mit GCD == 1)
       Beachten Sie, dass dadurch automatisch der Bereich [1, Eingabe] (einschließlich) erstellt wird.

Gültigkeitsnachweis

Da wir die coprimes nur extrahieren möchten, der Minimalwert der Greatest-Common Divisoren Liste hat seine 1 für den ÐṂTrick an der Arbeit. Beweisen wir das (auf zwei verschiedene Arten):

1. Der implizit generierte Bereich enthält und . Der größte gemeinsame Teiler ist immer eine streng positive ganze Zahl, daher ist das Auftreten von garantiert und der Mindestwert.$[1, \text{input}]$$1$$\gcd(1, x) = 1\:\:\forall\:\:x \in \mathbb{Z}^{*}$$1$

2. Zwei aufeinanderfolgende positive ganze Zahlen sind immer Koprime. Betrachte mit . Dann nehmen wir eine weitere positive ganze Zahl so dass und .$x, y \in \mathbb{Z}^{*}$$y = x + 1$$k$$k \mid x$$k \mid y$

   Dies impliziert, dass , also , also . Die einzige positive Ganzzahl zum Teilen von ist selbst, daher wird sie garantiert in der Liste angezeigt und ist immer der Mindestwert.$k \mid (y - x)$$k \mid (x + 1 - x)$$k \mid 1$$1$$1$

Python 2 , 61 47 Bytes

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

Probieren Sie es online!

Hintergrund

Betrachten Sie den Ring . Während dieser Ring normalerweise unter Verwendung der Restklassen modulo , kann er auch als die Menge , wobei die Additions- und Multiplikationsoperatoren durch und , wobei die übliche Addition bezeichnen, Multiplikation und Modulo-Operatoren über die ganzen Zahlen.n Z n = { 0 , … , n - 1 } a + n b = ( a + b $(Z_n, +_n, \cdot_n)$$n$$Z_n = \{0, \dots, n - 1\}$a ⋅ n b = a ⋅ $a +_n b = (a + b)\:\%\: n$+ $a \cdot_n b = a \cdot b\:\%\: n$$+,\:\cdot\text{, and } \%$

Zwei Elemente und von heißen gegenseitige multiplikative Inversen modulo wenn . Beachten Sie, dass wenn .b Z n n a ≤ n b = $a$$b$$Z_n$$n$$a \cdot_n b = 1\:\%\:n$n > $1\:\%\:n = 1$$n > 1$

Fixiere und sei ein Koprime von in . Wenn für zwei Elemente und von , haben wir das . Dies impliziert, dass , und wir folgen diesem , dh teilt gleichmäßig auf. Da keine Primteiler mit teilt , bedeutet dies, dass . Endlich, weila n Z n a ≤ n x = a ≤ n y x y Z n a ≤ $n > 1$$a$$n$$Z_n$$a \cdot_n x = a \cdot_n y$$x$$y$$Z_n$a ⋅ ( x - y $a \cdot x\:\%\:n = a \cdot y\:\%\:n$n ∣ a ⋅ ( x - y ) n a ⋅ ( x - y ) n a n ∣ x - y - n < x - y < n x = y a ⋅ n 0 , ... , a ⋅ n ( n - 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$ , wir schließen daraus, dass . Dies zeigt, dass die Produkte alle verschiedene Elemente von . Da genau Elemente hat, muss eines (und genau eines) dieser Produkte gleich , dh es gibt ein eindeutiges in so dass .$x = y$$a \cdot_n 0, \dots, a \cdot_n (n - 1)$$Z_n$$Z_n$$n$$1$ $b$ a ≤ n b = $Z_n$$a \cdot_n b = 1$

umgekehrt und lasse ein Element von , das nicht zu ist . In diesem Fall gibt es eine Primzahl , so daß und . Wenn eine multiplikative Inverse Modulo zugelassen (nennen wir es ), wir haben würde , was bedeutet , dass und daher , also . Seit folgen wir dema Z n n p p | a p | n a n b eine ⋅ n b = 1 eine ⋅ $n > 1$$a$$Z_n$$n$$p$$p \mid a$$p \mid n$$a$$n$$b$$a \cdot_n b = 1$( a ⋅ b - 1 $a \cdot b\:\%\:n = 1$n | a ⋅ b - 1 p | a p | a ⋅ b p | n p | a ⋅ b - 1 p | ( a ⋅ b ) - ( a ⋅ 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$ . Andererseits folgen wir seit auch diesem . Auf diese Weise ist , was der Annahme widerspricht, dass eine Primzahl ist.$p \mid n$$p \mid a \cdot b - 1$$p \mid (a \cdot b) - (a \cdot b - 1) = 1$$p$

Dies beweist, dass die folgenden Aussagen äquivalent sind, wenn .$n > 1$

• $a$ und sind Koprime.$n$

• $a$ ein multiplikatives inverses Modulo .$n$

• $a$ gibt eine eindeutige multiplikative Inverse modulo .$n$

Wie es funktioniert

Für jedes Paar von ganzen Zahlen und in ist die ganze Zahl eindeutig; Tatsächlich sind und Quotient und der Rest von geteilt durch , dh wenn , können wir und , wobei eine ganzzahlige Division bedeutet. Schließlich ist , da und , ein Element von ; in der Tat ist .b Z n k : = a ⋅ n + b a b k n k ein = k / n b = $a$$b$$Z_n$$k := a \cdot n + b$$a$$b$$k$$n$$k$$a = k/n$/ a ≤ n - 1 b ≤ n - 1 k Z n 2 k ≤ ( n - 1 ) ⋅ n + ( n - 1 ) = n 2 - $b = k\:\%\: n$$/$$a ≤ n - 1$$b ≤ n - 1$$k$$Z_{n^2}$$k ≤ (n - 1) \cdot n + (n - 1) = n^2 - 1$

Wie oben erwähnt, gibt es , wenn und Koprime sind, ein eindeutiges so dass , dh es gibt ein eindeutiges so dass und , so wird die erzeugte Liste enthält genau einmal.n b a ⋅ $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$

Umgekehrt, wenn und sind nicht coprime, die Bedingung für alle Werte von falsch sein derart , daß , so dass die erzeugte Liste wird nicht enthalten .$a$$n$$k / n \cdot k\:\%\:n = 1$$k$$a = k / n$$a$

Dies beweist, dass die Liste, die das Lambda zurückgibt, genau einmal alle Koprime von in .Z $n$$Z_n$

Gelee , 4 Bytes

gRỊT

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Etwas seltsames Ausgabeformat, bei dem jedes Ergebnis in eine separate Liste eingeschlossen wird, z {{1}, {3}, {7}, {9}}. Wenn das nicht in Ordnung ist, habe ich zwei Lösungen mit 30 Bytes:

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

Mathematica hat tatsächlich, CoprimeQaber das ist viel zu lang.

2sable , 4 Bytes

Code:

ƒN¿–

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python, 93 82 74 Bytes

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

fprüft rekursiv auf Koprime und das zweite Lambda generiert sie. Gibt eine Liste aus.

Eigentlich 8 Bytes

;╗R`╜┤`░

Probieren Sie es online!

Erläuterung:

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

MATL , 7 Bytes

:GZd1=f

Probieren Sie es online!

MATLAB / Octave, 22 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 64 61 Bytes

3 Bytes gespart dank @ user81655

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

Testschnipsel

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

Qualle , 19 18 Bytes

p
[#
`B
&~xr1
NnEi

Dies funktioniert, indem die Primfaktorisierung jeder Zahl im Bereich berechnet und überprüft wird, ob sie die der Eingabe schneidet (Jellyfish hat noch keinen integrierten GCD). Aus Golfgründen erfolgt die Ausgabe in absteigender Reihenfolge. Probieren Sie es online!

Erläuterung

Zunächst iwird die Eingabe ausgewertet. für die Eingabe 10ist der Wert der i-Zelle 10.

r1
i

Hier wird r(range) auf den Eingang und 1 angewendet. Da der Eingang größer als 1 ist, ist der Bereich in absteigender Reihenfolge. für die Eingabe 10gibt dies [9 8 7 6 5 4 3 2 1].

[#
`B
&~x
Nn

Dieser Teil ist eine große Funktion, die auf iund über den oben genannten Bereich ausgewertet wird.

~x
n

Schnittmenge ( n) von Primfaktoren ( x).

&~x
Nn

Ist es leer? ( N)

`
&~x
Nn

Fädle dich auf Level 0 ein und teste für jedes Element des Bereichs.

[#
`B
&~x
Nn

Filtern Sie ( #) den Bereich in Bezug auf diese Liste von Booleschen Werten. Die von erzeugte Funktion [möchte das Argument to #als eigenes Argument verwenden, daher Bblockieren wir das Abrufen #von Argumenten mit a. Andernfalls würde der Wert der ~-Zelle als Argument der großen Funktion verwendet. Zum Schluss wird pdas Ergebnis gedruckt.

Gestapelt, nicht konkurrierend, 24 21 Bytes

3 Bytes gespeichert , inspiriert von Borsunhos Rubin . ( 1 eqzu 2<)

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

Probieren Sie es hier aus!

Dies ist ein n-Lambda, das ein einzelnes Argument verwendet und das Array ergibt.

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

{:X{Xmff%:*},}

Probieren Sie es online!

Erläuterung

Wir müssen nicht alle möglichen Teiler von überprüfen aund btesten, ob es sich um Coprime handelt. Es ist ausreichend zu prüfen, ob einer der Hauptfaktoren der bTeilung ist 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 Bytes

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

Perl 6 , 20 Bytes

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

Brachylog , 16 bis 13 Bytes

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

Dies ist eine Funktion, die N als Eingabe verwendet und alle Ganzzahlen generiert, die kleiner sind als und gleichzeitig dazu gehören.

Probieren Sie es online! Wie so oft in Brachylog wurde ein zusätzlicher Code hinzugefügt, um die Funktion in ein vollständiges Programm zu verwandeln. Wenn der Brachylog-Interpreter eine Funktion anstelle eines vollständigen Programms ausführt, wird die Ausgabe jedoch nicht gedruckt, was bedeutet, dass Sie die Funktionsweise nicht wirklich beobachten können.

Erläuterung:

Ein Brachylog-Programm ist eine Kette von Einschränkungen. Typischerweise ist die LHS einer Einschränkung die RHS der nächsten.

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

Es gibt keinen Grund zu prüfen, ob der gemeinsame Faktor (von dem bereits bekannt ist, dass er ein Primfaktor der Ausgabe ist) ein Primfaktor der Eingabe ist. Wir wissen bereits, dass es eine Primzahl ist, also können wir einfach prüfen, ob es sich um einen Faktor handelt. Ich bin hier angenehm überrascht, dass :A*?der Interpreter nicht in eine Endlosschleife geschickt wird und keinen nicht ganzzahligen Wert für A zulässt , aber da der Interpreter tut, was ich will, nehme ich ihn.

Dyalog APL, 10 Bytes .

0~⍨⍳×1=⊢∨⍳

Erklärung (Eingabe 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 Bytes

jN

Versuch es

• 2 Bytes gespart dank Hinweis der ETH auf einen Brainfart, der zu einem weiteren gesparten Byte führte.

Mathematica, 33 Bytes

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

Enthält U + F4A1

Haskell, 27 Bytes

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

Probieren Sie es online!

Julia 0,5 , 23 Bytes

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

Probieren Sie es online!

Meme , 11 Bytes nicht konkurrierend , veraltet

Nicht konkurrierend als Iteration von STDIN ist neu. Verwendet UTF-8-Codierung.

d`}}]i=1?ip

Erläuterung:

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

}greift auf das nächste Eingabeelement zu, die letzte Eingabe wird jedoch durchgeschleift, sodass die Eingabe 6wie 6 6 6 6 6 ...bei STDIN erfolgt und das Lesen von zwei Ausgängen von einem ermöglicht wird.

05AB1E , 3 Bytes

Lʒ¿

Probieren Sie es online!

Hat neue Funktionen.

Ruby, 36 34

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

Zugegeben, das ist keine sehr inspirierte Antwort.

2 Bytes gespart dank Conor O'Brien.

Python 3 , 60 Bytes

Importiert gcd, anstatt ein neues Lambda dafür zu schreiben. Golfvorschläge sind willkommen. Probieren Sie es online!

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

Julia, 30 Bytes

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

Anonyme Funktion. filterEntfernt Elemente aus einer Liste, die gemäß einer Funktion nicht wahr sind.

In diesem Fall lautet die Funktion x->(gcd(n,x)<2)(true, wenn der gcd des Eingangs und des Listenelements kleiner als 2 ist). Die Liste ist der Bereich 1:n.

PARI / GP , 27 Bytes

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

Hierbei wird die in Version 2.6.0 (2013) eingeführte Set-Notation verwendet. In früheren Versionen wurden vier weitere Bytes benötigt:

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

würde gebraucht werden.

05AB1E , 4 Bytes

GN¿–

Probieren Sie es online!

Wie es funktioniert

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

C (gcc) , 54 Bytes

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

Dies ist ein Port meiner Python-Antwort .

Probieren Sie es online!

Pyth , 5 Bytes

x1iLQ

Probieren Sie es online!

Wie es funktioniert

Beachten Sie, dass Pyth die 0-Indizierung verwendet.

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)