Let zSer um número complexo. zé a enésima raiz primitiva da unidade, se para um determinado número inteiro positivo n e para qualquer número inteiro positivo k < n .

Desafio

Escreva um programa ou função completo que, dado um número inteiro positivo ncomo entrada, produza todas as enésimas enésimas raízes primitivas da unidade. Você pode produzi-los na forma polar ( e^θiou e^iθ, o argumento deve ser um decimal com pelo menos 2 casas decimais) ou retangular ( a + biou uma forma semelhante, as partes reais e imaginárias também devem ser decimais) e podem ser exibidas na lista do seu idioma / array ou como uma sequência com os números separados por espaços ou novas linhas. Construções que calculam as enésimas raízes da unidade ou as enésimas raízes primitivas da unidade não são permitidas.

Isso é código-golfe , então o código mais curto em bytes vence.

Amostras de entradas e saídas

6 -> e^1.05i, e^-1.05i # polar form
3 -> e^2.094395i, e^-2.094395i # any number of decimal places is OK as long as there are more than 2
8 -> 0.707 + 0.707i, 0.707 - 0.707i, -0.707 + 0.707i, -0.707 - 0.707i # rectangular form
1 -> 1 + 0i # this is OK
1 -> 1 # this is also OK
4 -> 0 + i, 0 - i # this is OK
4 -> i, -i # this is also OK

Geléia, 11 9 bytes

Obrigado a @Dennis por -2 bytes!

Rg=1O÷H-*

Eu queria gerar os números coprime para N dobrando a diferença definida sobre todas as raízes da unidade de 1 para N, mas não consegui descobrir como, então, usei o método de @ Dennis.

Rg=1O÷H-*         Monadic chain:          6
R                 Range                   [1,2,3,4,5,6]
 g                Hook gcds with range    [1,2,3,2,1,6]
  =1              [gcds equal to one]     [1,0,0,0,1,0]
    O             Replicate indices       [1,5]
     ÷H           Divide by half of N     [1/3,5/3]
       -          Numeric literal: - by itself is -1.
        *         Take -1 to those powers [cis π/3,cis 5π/3]

Experimente aqui . Válido nesta versão do Jelly, mas pode não estar nas versões após 1 de fevereiro de 2016.

Gelatina , 14 bytes

Rg=1O°÷×ı360Æe

Experimente online!

Como funciona

z = e ^2tπi é um n ^° de raiz de 1 , se e somente se t = k / n por algum número inteiro k .

z é primitivo se e somente se k e n são coprime.

Rg=1O°÷×ı360Æe  Main link. Input: n

R               Yield [1, ..., n].
 g              Compute the GCDs of reach integer and n.
  =1            Compare the GCDs with 1.
    O           Get all indices of 1's.
                This computes all the list of all k in [1, ..., n] 
                such that k and n are coprime.
     °          Convert the integers to radians.
      ÷         Divide the results by n.
       ×ı360    Multiply the quotient by the imaginary number 360i.
            Æe  Map exp over the results.

Julia, 48 bytes

n->cis(360deg2rad(filter(k->gcd(k,n)<2,1:n))/n)

Esta é uma função lambda que aceita um número inteiro e retorna uma matriz de flutuadores complexos. Para chamá-lo, atribua-o a uma variável. Ele usa a mesma abordagem que a resposta de Dennis 'Jelly.

Ungolfed:

function f(n::Int)
    # Get the set of all k < n : gcd(k,n) = 1
    K = filter(k -> gcd(k,n) < 2, 1:n)

    # Convert these to radian measures
    θ = deg2rad(K)

    # Multiply by 360, divide by n
    θ = 360 * θ / n

    # Compute e^iz for all elements z of θ
    return cis(θ)
end

Ruby, 46 bytes

Esta é uma implementação que não é "linguagem de golfe" da resposta do Thomas Kwa Jelly.

->n{(1..n).map{|j|1i**(4.0*j/n)if j.gcd(n)<2}}

Ungolfed:

def r(n)
  (1..n).each do |j|
    if j.gcd(n) == 1    # if j is coprime with n, then this will be a primitive root of unity
      p 1i**(4.0*j/n)   # print the fourth power of i**(j/n), i.e. the root of unity
    end
  end
end

MATL , 27 bytes

:1-tGYf1X-!\Xpg)2j*YP*G/Ze!

Usa a liberação (9.3.1) , que é anterior a esse desafio.

Experimente online!

(O compilador online usa uma versão mais recente, mas o código é executado na versão 9.3.1 e fornece o mesmo resultado)

Explicação

Existem três etapas principais:

1. Gerar números inteiros 0, 1, ..., N-1, correspondendo a todas as raízes.
2. Mantenha apenas números inteiros correspondentes às raízes primitivas. Estes são identificados usando a decomposição do fator principal de N.
3. Gere as raízes reais com um exponencial imaginário.

Código:

:1-           % 1. Implicit input "N". Produce vector [0,1,...,N-1]
t             %    duplicate
GYf           % 2. Prime factors of N
1X-           %    remove factor "1" if present (only if N==1)
!\            %    all combinations of [0,1,...,N-1] modulo prime factors of N
Xpg           %    logical "and" along the prime-factor dimension
)             %    index into original vector [0,1,...,N-1] to keep only primitive roots
2j*YP*G/Ze    % 3. Imaginary exponential to produce those roots
!             %    transpose for better output format

Matlab 49 bytes

n=input('');q=0:n-1;exp(i*2*pi/n.*q(gcd(n,q)==1))

Não conseguiu a tarefa na primeira vez, mas agora aqui está. Saídas da seguinte forma:

6
ans =
    0.5000 + 0.8660i   0.5000 - 0.8660i

ES6, 96 bytes

n=>[...Array(n).keys()].filter(i=>g(i,n)<2,g=(a,b)=>a?g(b%a,a):b).map(i=>'e^'+Math.PI*2*i/n+'i')

A forma polar foi a menor saída.

PARI / GP, 41 bytes

Bem simples: encontre os números de 1 a n que são coprime para n e, em seguida,

n->[exp(2*Pi*I*m/n)|m<-[1..n],gcd(n,m)<2]

Tem que haver um caminho mais curto, mas este foi o melhor que pude encontrar.