Dado um número n >= 2, produza todos os números inteiros positivos menores que nonde gcd(n, k) == 1(com kqualquer um dos números de saída). Números desse tipo são coprime entre si.

Exemplo: 10fornece a saída [1, 3, 7, 9](de qualquer forma que você quiser, desde que os números sejam separados sem ambiguidade e em algum tipo de lista). A lista não pode ter entradas duplicadas e não precisa ser classificada.

Mais casos de teste:

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]

Também não estamos contando números acima dos nque são coprime n, apenas porque estou bastante certo de que existem infinitas soluções.

Observe também: os números que são coprime entre si também são considerados relativamente primos ou mutuamente primos entre si.

Gelatina , 3 bytes

gÐṂ

Experimente online!

Como é que isso funciona?

gÐṂ - (Monadic) Programa completo.

g - Maior divisor comum.
 Keep - Mantenha os elementos com valor mínimo de link (ou seja, aqueles com GCD == 1)
       Observe que isso cria automaticamente o intervalo [1, entrada] (inclusive).

Prova de validade

Desde que nós queremos extrair apenas os coprimes, o valor mínimo da lista Maior-Common-Divisores tem que ser 1 para o ÐṂtruque para o trabalho. Vamos provar que (em dois métodos diferentes):

1. $[1, \text{input}]$$1$$\gcd(1, x) = 1\:\:\forall\:\:x \in \mathbb{Z}^{*}$$1$

2. Dois números inteiros positivos consecutivos são sempre coprime. Considere , com . Então tomamos outro número inteiro positivo modo que e .$x, y \in \mathbb{Z}^{*}$$y = x + 1$$k$$k \mid x$$k \mid y$

   Isso implica que , então , portanto, . O único número inteiro positivo a dividir é o próprio , por isso é garantido que apareça na lista e sempre será o valor mínimo.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 bytes

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

Experimente online!

fundo

Considere o anel . Embora esse anel seja geralmente definido usando as classes de resíduos módulo n , também pode ser considerado o conjunto Z n = { 0 , … , n - 1 } , onde os operadores de adição e multiplicação são definidos por a + n b = ( a + b $(Z_n, +_n, \cdot_n)$$n$$Z_n = \{0, \dots, n - 1\}$ e a ⋅ n b = a ⋅ $a +_n b = (a + b)\:\%\: n$ , onde + $a \cdot_n b = a \cdot b\:\%\: n$ denotam os operadores usuais de adição, multiplicação e módulo sobre os números inteiros.$+,\:\cdot\text{, and } \%$

Dois elementos e b de Z n são chamados inversos multiplicativos mútuos módulo n se a ⋅ n b = $a$$b$$Z_n$$n$ . Note que$a \cdot_n b = 1\:\%\:n$ sempre que n > 1 .$1\:\%\:n = 1$$n > 1$

Corrija e deixe a ser um coprime de n em Z n . Se um ⋅ n x = um ⋅ n y por dois elementos de x e y de Z n , temos que um ⋅ $n > 1$$a$$n$$Z_n$$a \cdot_n x = a \cdot_n y$$x$$y$$Z_n$ . Isso implica que a ⋅ ( x - y $a \cdot x\:\%\:n = a \cdot y\:\%\:n$ , e seguimos que n ∣ a ⋅ ( x - y ) , ou seja, n divide a ⋅ ( x - y ) igualmente. Como n não compartilha divisores primos com a , isso significa que n ∣ x - y . Finalmente, porque - n < x - y < n , concluímos que x = y . Isso mostra que os produtos de uma $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$ são todos elementos diferentes de Z n . Como Z n tem exatamente n elementos, um (e exatamente um) desses produtos deve ser igual a 1 , ou seja, existe um b exclusivoem Z n de modo que a ⋅ 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$

Por outro lado, corrija e deixe a ser um elemento de Z n que não é coprime para n . Nesse caso, existe um primo p tal que p ∣ a e p ∣ n . Se um admitido um módulo inverso multiplicativo n (vamos chamá-lo de b ), teríamos que a ⋅ n b = 1 , significando que a ⋅ $n > 1$$a$$Z_n$$n$$p$$p \mid a$$p \mid n$$a$$n$$b$$a \cdot_n b = 1$ e, portanto, ( a ⋅ b - 1 $a \cdot b\:\%\:n = 1$ , então n ∣ a ⋅ b - 1 . Desde p ∣ a , seguimos que p ∣ a ⋅ b . Por outro lado, desde p ∣ n , seguimos também p ∣ a ⋅ b - 1 . Dessa forma, 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$, o que contradiz a suposição de que é um número primo.$p$

Isso prova que as seguintes instruções são equivalentes quando .$n > 1$

• e n são coprime.$a$$n$

• admite um módulo inverso multiplicativo n .$a$$n$

• admite umúnicomódulo inverso multiplicativo n .$a$$n$

Como funciona

Para cada par de números inteiros e b em Z n , o número inteiro k : = um ⋅ n + b é única; de facto, um e b são quociente e o resto de k dividido por n , isto é, dada k , que podem recuperar um = k / n e b = $a$$b$$Z_n$$k := a \cdot n + b$$a$$b$$k$$n$$k$$a = k/n$ , onde / denotadivisãointeira. Finalmente, uma vez que um ≤ n - 1 e b ≤ n - 1 , k é um elemento de Z n 2 ; de fato, 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$

Como observado acima, se e n forem coprime, haverá um b único, de modo que a ⋅ $a$$n$$b$ , ou seja, haverá um k únicoque k / n = a e k / n ⋅ $a \cdot b\:\%\:n = 1$$k$$k / n = a$ , então a lista gerada conterá uma exatamente uma vez.$k / n \cdot k\:\%\:n = (k / n) \cdot (k\:\%\:n)\:\%\:n = 1$$a$

Por outro lado, se e n não são coprime, a condição k / n ⋅ $a$$n$ será falso para todos os valores de k, de modo que a = k / n , portanto, a lista geradanãoconterá a .$k / n \cdot k\:\%\:n = 1$$k$$a = k / n$$a$

Isto prova que a lista dos lambda retorna irá conter todos 's coprimes em Z n exactamente uma vez.$n$$Z_n$

Gelatina , 4 bytes

gRỊT

Experimente online!

Como funciona

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&

Formato de saída ligeiramente estranho, onde cada resultado é agrupado em uma lista separada, por exemplo {{1}, {3}, {7}, {9}}. Se não estiver certo, tenho duas soluções em 30 bytes:

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

O Mathematica realmente tem, CoprimeQmas é muito longo.

2sable , 4 bytes

Código:

ƒN¿–

Explicação:

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

Usa a codificação CP-1252 . Experimente 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)]

frecursivamente verifica coprimes, e o segundo lambda os gera. Mostra uma lista.

Na verdade , 8 bytes

;╗R`╜┤`░

Experimente online!

Explicação:

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

MATL , 7 bytes

:GZd1=f

Experimente online!

MATLAB / oitava, 22 bytes

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

Experimente online!

JavaScript (ES6), 64 61 bytes

Guardado 3 bytes graças a @ user81655

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

Snippet de teste

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

Água-viva , 19 18 bytes

p
[#
`B
&~xr1
NnEi

Isso funciona calculando a fatoração primária de cada número no intervalo e verificando se ele cruza o da entrada (o Jellyfish ainda não possui um gcd). Por razões de golfe, a saída está em ordem decrescente. Experimente online!

Explicação

Primeiro, ié avaliada a entrada; para entrada 10, o valor da icélula é 10.

r1
i

Aqui r(intervalo) é aplicado à entrada e 1. Como a entrada é maior que 1, o intervalo está em ordem decrescente; para entrada 10, isso dá [9 8 7 6 5 4 3 2 1].

[#
`B
&~x
Nn

Esta parte é uma grande função, avaliada na ifaixa acima.

~x
n

Interseção ( n) de fatores primos ( x).

&~x
Nn

Está vazio? ( N)

`
&~x
Nn

Passe para o nível 0, testando para cada elemento do intervalo.

[#
`B
&~x
Nn

Filtre ( #) o intervalo em relação a esta lista de booleanos. Como a função produzida por [deseja usar o argumento #como seu próprio argumento, colocamos um Bbloco #para evitar qualquer argumento. Caso contrário, o valor da ~célula-seria usado como argumento da grande função. Por fim, pimprime o resultado.

Empilhados, não concorrentes, 24 21 bytes

Economizou 3 bytes, inspirado no rubi de Borsunho . ( 1 eqpara 2<)

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

Experimente aqui!

Este é um n-lambda que pega um único argumento e gera a matriz.

{!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%:*},}

Experimente online!

Explicação

Não precisamos verificar todos os divisores possíveis ae btestar se são coprimes. É suficiente verificar se algum dos principais fatores das bdivisões 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$_,^$_}

Braquilog , 16 13 bytes

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

Esta é uma função que recebe N como entrada e gera todos os números inteiros menores que e coprime para ela.

Experimente online! Como costuma ser o caso do Brachylog, esse código adicional foi adicionado para transformar a função em um programa completo; O intérprete de Brachylog, se receber uma função em vez de um programa completo, executará, mas não imprimirá a saída, o que significa que você não pode realmente observar o funcionamento.

Explicação:

Um programa Brachylog é uma cadeia de restrições; normalmente, o LHS de uma restrição é o RHS da próxima.

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

Golpeou três caracteres ao perceber que não há razão para verificar se o fator comum (que já é conhecido como um fator primordial da saída) é um fator primordial da entrada. Já sabemos que é excelente, então podemos apenas verificar se é um fator. Estou agradavelmente surpreendido aqui que :A*?não envia o intérprete para um loop infinito e não permite um valor não inteiro para A , mas como o intérprete faz o que eu quero, eu aceito.

Dyalog APL, 10 bytes .

0~⍨⍳×1=⊢∨⍳

Explicação (entrada 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.

Japonês -f , 9 8 5 2 bytes

jN

Tente

• 2 bytes salvos graças ao ETH apontando um peido cerebral, o que levou a outro byte salvo.

Mathematica, 33 bytes

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

Contém U + F4A1

Haskell, 27 bytes

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

Experimente online!

Julia 0,5 , 23 bytes

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

Experimente online!

memes , 11 bytes não concorrentes , desatualizado

Não competir, pois a iteração do STDIN é nova. Usa codificação UTF-8.

d`}}]i=1?ip

Explicação:

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

}acessa o próximo item de entrada, mas a última entrada é repetida quando fornecida, portanto a entrada 6resultará como 6 6 6 6 6 ...em STDIN, possibilitando a leitura de duas saídas de uma.

05AB1E , 3 bytes

Lʒ¿

Experimente online!

Tem novos recursos.

Ruby, 36 34

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

É certo que esta não é uma resposta muito inspirada .

2 bytes salvos graças a Conor O'Brien.

Python 3 , 60 bytes

Importa o gcd em vez de escrever um novo lambda para ele. Sugestões de golfe são bem-vindas. Experimente 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)

Função anônima. filterremove elementos de uma lista que não é verdadeira de acordo com uma função.

Nesse caso, a função é x->(gcd(n,x)<2)(true se o mcd da entrada e o elemento da lista for menor que 2). A lista é o intervalo 1:n.

PARI / GP , 27 bytes

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

Isso usa a notação de conjunto introduzida na versão 2.6.0 (2013). Nas versões anteriores, eram necessários mais quatro bytes:

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

seria necessário.

05AB1E , 4 bytes

GN¿–

Experimente online!

Como funciona

     # 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));}

Esta é uma porta da minha resposta Python .

Experimente online!

Pitão , 5 bytes

x1iLQ

Experimente online!

Como funciona

Observe que o Pyth usa a indexação 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)