Dato un numero n >= 2, genera tutti gli interi positivi meno di ndove gcd(n, k) == 1(con kuno qualsiasi dei numeri di output). I numeri di questo tipo si coprono l'un l'altro.

Esempio: 10fornisce l'output [1, 3, 7, 9](in qualsiasi forma ti piaccia, purché i numeri siano separati in modo univoco e in una sorta di elenco). L'elenco non può contenere voci duplicate e non deve essere ordinato.

Altri casi di test:

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]

Inoltre non stiamo contando i numeri sopra nche sono coprimi n, solo perché sono abbastanza sicuro che ci siano infinite soluzioni.

Nota anche: i numeri che si coprono tra loro si dicono anche relativamente primi o reciprocamente primi.

Gelatina , 3 byte

gÐṂ

Provalo online!

Come funziona?

gÐṂ - (Monadic) Programma completo.

g - Il massimo comune divisore.
 ÐṂ - Mantieni gli elementi con un valore di collegamento minimo (cioè quelli con GCD == 1)
       Si noti che ciò crea automaticamente l'intervallo [1, input] (incluso).

Prova di validità

Dato che vogliamo estrarre solo i coprimi, il valore minimo dell'elenco dei più grandi divisori comuni deve essere 1 affinché il ÐṂtrucco funzioni. Dimostriamo che (in due diversi metodi):

1. L'intervallo generato implicitamente, contiene e . Il massimo comune divisore è sempre un numero intero strettamente positivo, quindi è garantito e sarà sempre il valore minimo.$[1, \text{input}]$$1$$\gcd(1, x) = 1\:\:\forall\:\:x \in \mathbb{Z}^{*}$$1$

2. Due interi positivi consecutivi sono sempre coprimi. Considera , con . Poi prendiamo un altro intero positivo tale che e . y = x + 1 k k ∣ x k ∣ $x, y \in \mathbb{Z}^{*}$$y = x + 1$$k$$k \mid x$$k \mid y$

   Ciò implica che , quindi , quindi . L'unico numero intero positivo per dividere è stesso, quindi è garantito che venga visualizzato nell'elenco e sarà sempre il valore minimo.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 byte

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

Provalo online!

sfondo

Considera l' anello . Sebbene questo anello sia generalmente definito usando le classi di residui modulo , può anche essere pensato come l'insieme , dove gli operatori di addizione e moltiplicazione sono definiti da e , dove indicano la solita aggiunta, moltiplicazione e operatori modulo sugli interi.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 } \%$

Due elementi e di sono chiamati reciproci inversi moltiplicativi modulo se . Si noti che ogni volta che .b Z n n a ⋅ n b = $a$$b$$Z_n$$n$$a \cdot_n b = 1\:\%\:n$n > $1\:\%\:n = 1$$n > 1$

Fix e sia essere un coprimi di in . Se per due elementi e di , abbiamo che . Ciò implica che , e seguiamo che , cioè divide modo uniforme. Poiché non condivide i divisori primi con , ciò significa che . Finalmente, perchéa $n > 1$$a$$n$ a ⋅ n x = a ⋅ n y x y Z n a ⋅ $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$ , concludiamo che . Ciò mostra che i prodotti sono tutti elementi diversi di . Dato che ha esattamente elementi, uno (e esattamente uno) di quei prodotti deve essere uguale a , cioè c'è un unico in tale che .$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$

Viceversa, fix e lascia essere un elemento di che non primi con . In questo caso, esiste una principale tale che e . Se ammettesse un modulo inverso moltiplicativo (chiamiamolo ), avremmo che , il che significa che e, quindi, , quindi . Da , seguiamo quelloa Z n n p p ∣ a p ∣ n a n b a ⋅ n b = 1 a ⋅ $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$ . D'altra parte, poiché , seguiamo anche che . In questo modo, , che contraddice l'assunto che sia un numero primo.$p \mid n$$p \mid a \cdot b - 1$$p \mid (a \cdot b) - (a \cdot b - 1) = 1$$p$

Ciò dimostra che le seguenti affermazioni sono equivalenti quando .$n > 1$

• $a$ e sono coprimi.$n$

• $a$ ammette un modulo inverso moltiplicativo .$n$

• $a$ ammette un unico modulo moltiplicativo inverso .$n$

Come funziona

Per ogni coppia di interi e in , il numero intero è unico; infatti, e sono quoziente e resto diviso per , cioè, dato , possiamo recuperare e , dove denota interi divisione. Infine, poiché e , è un elemento di ; infatti, .b Z n k : = a ⋅ n + b a b k n k a = 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$

Come notato sopra, se e sono coprime, ci sarà un unico tale che , cioè ci sarà un unico tale che e , per cui l'elenco generato conterrà esattamente una volta.n b a ⋅ $a$$n$$b$k k / n = a k / n ⋅ $a \cdot b\:\%\:n = 1$$k$$k / n = a$$k / n \cdot k\:\%\:n = (k / n) \cdot (k\:\%\:n)\:\%\:n = 1$$a$

Al contrario, se e non sono coprime, la condizione sarà falsa per tutti i valori di tale che , quindi l'elenco generato non conterrà .n k / n ⋅ $a$$n$k a = k / n $k / n \cdot k\:\%\:n = 1$$k$$a = k / n$$a$

Ciò dimostra che l'elenco restituito da lambda conterrà tutti i coprimi di in esattamente una volta.Z $n$$Z_n$

Gelatina , 4 byte

gRỊT

Provalo online!

Come funziona

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 byte

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

Formato di output leggermente strano, in cui ogni risultato è racchiuso in un elenco separato, ad es {{1}, {3}, {7}, {9}}. Se non va bene, ho due soluzioni a 30 byte:

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

Mathematica ha effettivamente, CoprimeQma è troppo lungo.

2 file , 4 byte

Codice:

ƒN¿–

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!

Python, 93 82 74 byte

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

fcontrolla ricorsivamente per coprimi, e il secondo lambda li genera. Emette un elenco.

In realtà , 8 byte

;╗R`╜┤`░

Provalo online!

Spiegazione:

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

MATL , 7 byte

:GZd1=f

Provalo online!

MATLAB / Ottava, 22 byte

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

Provalo online!

JavaScript (ES6), 64 61 byte

3 byte salvati grazie a @ user81655

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

Test snippet

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

Medusa , 19 18 byte

p
[#
`B
&~xr1
NnEi

Questo funziona calcolando la scomposizione in fattori primi di ogni numero nell'intervallo e controllando se interseca quello dell'input (Jellyfish non ha ancora un gcd incorporato). Per motivi di golf, l'output è in ordine decrescente. Provalo online!

Spiegazione

Prima di tutto, iviene valutato l'input; per input 10, il valore di i-cell è 10.

r1
i

Qui r(intervallo) viene applicato all'ingresso e 1. Poiché l'ingresso è maggiore di 1, l'intervallo è in ordine decrescente; per input 10, questo dà [9 8 7 6 5 4 3 2 1].

[#
`B
&~x
Nn

Questa parte è una grande funzione, che viene valutata sulla igamma sopra.

~x
n

Intersezione ( n) dei fattori primi ( x).

&~x
Nn

È vuoto? ( N)

`
&~x
Nn

Passa al livello 0, test per ogni elemento dell'intervallo.

[#
`B
&~x
Nn

Filtro ( #) l'intervallo rispetto a questo elenco di valori booleani. La funzione prodotta da [vuole usare l'argomento #come proprio argomento, quindi mettiamo un Bblocco #per ottenere qualsiasi argomento. Altrimenti, il valore di ~-cell verrebbe usato come argomento della grande funzione. Infine, pstampa il risultato.

Impilato, non competitivo, 24 21 byte

Salvato 3 byte, ispirato al rubino di Borsunho . ( 1 eqa 2<)

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

Provalo qui!

Questo è un n-lambda che accetta un singolo argomento e produce l'array.

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

{:X{Xmff%:*},}

Provalo online!

Spiegazione

Non è necessario controllare tutti i possibili divisori di ae bverificare se sono coprimi. È sufficiente verificare se uno dei fattori primi delle bdivisioni 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 byte

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

Perl 6 , 20 byte

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

Brachylog , 16 13 byte

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

Questa è una funzione che accetta N come input e genera tutti i numeri interi inferiori e coprimi.

Provalo online! Come spesso accade in Brachylog, è stato aggiunto del codice aggiuntivo per rendere la funzione un programma completo; L'interprete di Brachylog, se viene data una funzione piuttosto che un programma completo, la eseguirà ma non stamperà l'output, il che significa che non puoi davvero osservarne il funzionamento.

Spiegazione:

Un programma Brachylog è una catena di vincoli; in genere, l'LHS di un vincolo è l'RHS del successivo.

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

Scivolando tre caratteri realizzando che non c'è motivo di verificare se il fattore comune (che è già noto per essere un fattore primo dell'output) è un fattore primo dell'input. Sappiamo già che è eccellente, quindi possiamo solo verificare se è un fattore. Sono piacevolmente sorpreso qui che :A*?non manda l'interprete in un ciclo infinito e non consenta un valore non intero per A , ma poiché l'interprete fa quello che voglio, lo prenderò.

Dyalog APL, 10 byte .

0~⍨⍳×1=⊢∨⍳

Spiegazione (input 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 byte

jN

Provalo

• 2 byte salvati grazie all'ETH che indica un Brainfart, che ha portato a un altro byte salvato.

Mathematica, 33 byte

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

Contiene U + F4A1

Haskell, 27 byte

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

Provalo online!

Julia 0,5 , 23 byte

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

Provalo online!

meme , 11 byte non concorrenti , obsoleti

Non competitiva poiché l'iterazione di STDIN è nuova. Utilizza la codifica UTF-8.

d`}}]i=1?ip

Spiegazione:

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

}accede all'elemento di input successivo, ma l'ultimo input viene ripetuto ciclicamente quando viene fornito, quindi l'inserimento 6risulterà come 6 6 6 6 6 ...in STDIN, rendendo possibile la lettura di due output da uno.

05AB1E , 3 byte

Lʒ¿

Provalo online!

Ha nuove funzionalità.

Ruby, 36 34

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

Certo, questa non è una risposta molto ispirata .

2 byte salvati grazie a Conor O'Brien.

Python 3 , 60 byte

Importa gcd invece di scrivere una nuova lambda per questo. Suggerimenti di golf benvenuti. Provalo online!

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

Julia, 30 byte

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

Funzione anonima. filterrimuove elementi da un elenco che non sono veritieri secondo una funzione.

In questo caso, la funzione è x->(gcd(n,x)<2)(vero se gcd dell'input e l'elemento list sono inferiori a 2). L'elenco è l'intervallo 1:n.

PARI / GP , 27 byte

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

Questo utilizza la notazione set introdotta nella versione 2.6.0 (2013). Nelle versioni precedenti erano necessari altri quattro byte:

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

sarebbe necessario.

05AB1E , 4 byte

GN¿–

Provalo online!

Come funziona

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

C (gcc) , 54 byte

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

Questa è una porta della mia risposta Python .

Provalo online!

Pyth , 5 byte

x1iLQ

Provalo online!

Come funziona

Nota che Pyth usa l'indicizzazione 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)