Lascia che zsia un numero complesso. zè un'ennesima radice primitiva di unità se per un certo numero intero positivo n e per qualsiasi numero intero positivo k < n .

Sfida

Scrivi un programma o una funzione completa che, dato un intero positivo ncome input, produce tutte le ennesime radici primitive dell'unità. Puoi emetterli in forma polare ( e^θio e^iθ, l'argomento dovrebbe essere un decimale con almeno 2 posizioni decimali) o rettangolare ( a + bio una forma simile, anche le parti reali e immaginarie dovrebbero essere decimali) e potrebbero essere emesse nell'elenco della tua lingua / formato array o come stringa con i numeri separati da spazi o newline. Non sono ammessi incorporamenti che calcolano l'ennesima radice dell'unità o l'ennesima radice primitiva dell'unità.

Questo è code-golf , quindi vince il codice più breve in byte.

Ingressi e uscite di esempio

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

Gelatina, 11 9 byte

Grazie a @Dennis per -2 byte!

Rg=1O÷H-*

Volevo generare i numeri coprimi su N piegando la differenza di set su tutte le radici dell'unità da 1 a N, ma non sono riuscito a capire come ho usato il metodo di @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]

Provalo qui . Valido in questa versione di Jelly, ma potrebbe non esserlo nelle versioni successive al 1 ° febbraio 2016.

Gelatina , 14 byte

Rg=1O°÷×ı360Æe

Provalo online!

Come funziona

z = e ^2tπi è un n ^esima radice di 1 se e solo se t = k / n per qualche intero k .

z è primitivo se e solo se k e n sono coprimi.

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 byte

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

Questa è una funzione lambda che accetta un numero intero e restituisce una matrice di float complessi. Per chiamarlo, assegnarlo a una variabile. Utilizza lo stesso approccio della risposta Jelly di Dennis.

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

Rubino, 46 ​​byte

Questa è un'implementazione non "golfistica" della risposta di Jelly di Thomas Kwa .

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

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

Usa la versione (9.3.1) , che è precedente a questa sfida.

Provalo online!

(Il compilatore online utilizza una versione più recente, ma il codice viene eseguito nella versione 9.3.1 e fornisce lo stesso risultato)

Spiegazione

Ci sono tre passaggi principali:

1. Genera numeri interi 0, 1, ..., N-1, corrispondenti a tutte le radici.
2. Mantieni solo numeri interi corrispondenti alle radici primitive. Questi sono identificati usando la decomposizione del fattore primo di N.
3. Genera le radici reali con un esponenziale immaginario.

Codice:

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

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

Non ho ottenuto il compito per la prima volta, ma ora eccolo qui. Emette come segue:

6
ans =
    0.5000 + 0.8660i   0.5000 - 0.8660i

ES6, 96 byte

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 forma polare è stata l'output più breve.

PARI / GP, 41 byte

Abbastanza semplice: trova i numeri da 1 a n che sono coprimi ad n, quindi

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

Deve esserci un modo più breve, ma questo è stato il migliore che ho trovato.