Soit zun nombre complexe. zest une nième racine primitive d'unité si pour un certain entier positif n et pour tout entier positif k < n .

Défi

Écrivez un programme ou une fonction complète qui, étant donné un entier positif nen entrée, génère toutes les nièmes racines primitives de l'unité. Vous pouvez les afficher sous forme polaire ( e^θiou e^iθ, l'argument doit être une décimale avec au moins 2 décimales) ou rectangulaire ( a + biou une forme similaire, les parties réelles et imaginaires doivent également être des décimales), et elles peuvent être sorties dans la liste de votre langue / format tableau ou sous forme de chaîne avec les nombres séparés par des espaces ou des retours à la ligne. Les éléments intégrés qui calculent les nièmes racines de l'unité ou les nièmes racines primitives de l'unité ne sont pas autorisés.

C'est le code-golf , donc le code le plus court en octets l'emporte.

Exemples d'entrées et de sorties

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ée, 11 9 octets

Merci à @Dennis pour -2 octets!

Rg=1O÷H-*

Je voulais générer les nombres coprimes en N en repliant la différence d'ensemble sur toutes les racines de l'unité de 1 à N, mais je ne pouvais pas comprendre comment j'ai donc utilisé la méthode 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]

Essayez-le ici . Valide dans cette version de Jelly, mais peut-être pas dans les versions après le 1er février 2016.

Gelée , 14 octets

Rg=1O°÷×ı360Æe

Essayez-le en ligne!

Comment ça fonctionne

z = e ^2tπi est un n ^ième racine de 1 si et seulement si t = k / n pour un entier k .

z est primitif si et seulement si k et n sont des nombres premiers.

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 octets

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

Il s'agit d'une fonction lambda qui accepte un entier et renvoie un tableau de flottants complexes. Pour l'appeler, affectez-le à une variable. Il utilise la même approche que la réponse Jelly de Dennis.

Non golfé:

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

Rubis, 46 octets

Il s'agit d'une implémentation non "en langage golfique" de la réponse Jelly de Thomas Kwa .

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

Non golfé:

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 octets

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

Utilise la version (9.3.1) , qui est antérieure à ce défi.

Essayez-le en ligne!

(Le compilateur en ligne utilise une version plus récente, mais le code s'exécute dans la version 9.3.1 et donne le même résultat)

Explication

Il y a trois étapes principales:

1. Générer des nombres 0, 1..., N-1correspondant à toutes les racines.
2. Ne conservez que des entiers correspondant à des racines primitives. Ceux-ci sont identifiés à l'aide de la décomposition en facteurs premiers de N.
3. Générez les racines réelles avec une exponentielle imaginaire.

Code:

: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 octets

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

N'a pas eu la tâche à la première fois, mais maintenant la voici. Sorties comme suit:

6
ans =
    0.5000 + 0.8660i   0.5000 - 0.8660i

ES6, 96 octets

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

La forme polaire était la sortie la plus courte.

PARI / GP, 41 octets

Assez simple: trouvez les nombres de 1 à n qui sont des nombres premiers à n, puis

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

Il doit y avoir un moyen plus court, mais c'était le meilleur que j'ai pu trouver.