พื้นหลัง (ข้ามไปที่คำจำกัดความ)

ออยเลอร์พิสูจน์ทฤษฎีบทที่สวยงามเกี่ยวกับจำนวนเชิงซ้อน: e ^ix = cos (x) + i sin (x)

สิ่งนี้ทำให้ทฤษฎีบทของเดอมอยฟอร์พิสูจน์ได้ง่าย:

(e ^ix ) ⁿ = e ^{i (nx)}

(cos (x) + i sin (x)) ⁿ = cos (nx) + i sin (nx)

เราสามารถพล็อตตัวเลขที่ซับซ้อนโดยใช้ระนาบแบบยุคลิดแบบสองมิติโดยมีแกนนอนเป็นตัวแทนของส่วนจริงและแกนตั้งเป็นตัวแทนของส่วนจินตภาพ ด้วยวิธีนี้ (3,4) จะสอดคล้องกับจำนวนเชิงซ้อน 3 + 4i

หากคุณคุ้นเคยกับพิกัดเชิงขั้ว (3,4) จะเป็น (5, arctan (4/3)) ในพิกัดเชิงขั้ว หมายเลขแรก r คือระยะทางของจุดจากจุดกำเนิด ตัวเลขที่สองคือ angle คือมุมที่วัดจากแกน x บวกถึงจุดทวนเข็มนาฬิกา ดังนั้น 3 = r cosθและ 4 = r sinθ ดังนั้นเราจึงสามารถเขียน 3 + 4i เป็น R cosθ + ri sinθ = R (cosθsinθ + i) = ใหม่iθ

ขอให้เราแก้สมการที่ซับซ้อน z ⁿ = 1 โดยที่ n เป็นจำนวนเต็มบวก

เราปล่อยให้ Z = ใหม่iθ จากนั้น Z ⁿ = R ⁿอีinθ ระยะทางของ z ⁿจากจุดกำเนิดคือ^rnและมุมคือnθ อย่างไรก็ตามเรารู้ว่าระยะทาง 1 จากจุดกำเนิดคือ 1 และมุมคือ 0 ดังนั้น r ⁿ = 1 และnθ = 0 อย่างไรก็ตามหากคุณหมุน2πขึ้นไปคุณจะยังคงอยู่ที่จุดเดียวกันเนื่องจาก2πเป็นเพียงวงกลมเต็ม ดังนั้น r = 1 และnθ = 2kπให้เรา Z = อี^{2ikπ /} n

เราย้ำการค้นพบของเรา: การแก้ปัญหาถึง z ⁿ = 1 Z = อี^{2ikπ /} n

พหุนามสามารถแสดงออกในรูปของราก ตัวอย่างเช่นรากของ x ² -3x + 2 คือ 1 และ 2 ดังนั้น x ² -3x + 2 = (x-1) (x-2) ในทำนองเดียวกันจากการค้นพบของเราด้านบน:

อย่างไรก็ตามผลิตภัณฑ์นั้นมีรากของเอ็นอื่น ๆ อย่างแน่นอน ตัวอย่างเช่นใช้ n = 8 รากของ z ⁴ = 1 ก็จะถูกรวมอยู่ในรากของ z ⁸ = 1 เนื่องจาก z ⁴ = 1 หมายถึง z ⁸ = (z ⁴ ) ² = 1 ² = 1 ลองใช้ n = 6 เป็นตัวอย่าง ถ้า z ² = 1 แล้วเราก็จะได้ z ⁶ = 1 ด้วย เช่นเดียวกันถ้า z ³ = 1 ดังนั้น z ⁶ = 1

หากเราต้องการแยกรากที่ไม่ซ้ำกับ z ⁿ = 1 เราจะต้องมี k และ n เพื่อไม่แชร์ตัวหารร่วมยกเว้น 1 หรืออย่างอื่นถ้าพวกเขาแชร์ตัวหารสามัญ d โดยที่ d> 1 แล้ว z จะเป็น (k / d) -th root ของ z ^{n / d} = 1 การใช้เทคนิคด้านบนเพื่อเขียนพหุนามในแง่ของรากเราได้พหุนาม:

โปรดทราบว่าพหุนามนี้ทำโดยลบรากของ z ^{n / d} = 1 โดยที่ d เป็นตัวหารของ n เราอ้างว่าพหุนามข้างต้นมีค่าสัมประสิทธิ์จำนวนเต็ม พิจารณา LCM ของพหุนามในรูปแบบของ z ^{n / d} -1 โดยที่ d> 1 และ d หาร n รากของ LCM เป็นรากที่เราต้องการลบอย่างแน่นอน เนื่องจากแต่ละองค์ประกอบมีค่าสัมประสิทธิ์จำนวนเต็ม LCM จึงมีค่าสัมประสิทธิ์จำนวนเต็มด้วย เนื่องจาก LCM หาร z ⁿ -1 ความฉลาดจึงต้องเป็นพหุนามที่มีสัมประสิทธิ์จำนวนเต็มและความฉลาดทางคือพหุนามข้างต้น

รากของ z ⁿ = 1 ทั้งหมดมีรัศมี 1 ดังนั้นพวกมันจึงเกิดเป็นวงกลม พหุนามแสดงถึงจุดของวงกลมที่ไม่ซ้ำกับ n ดังนั้นในแง่หนึ่งชื่อพหุนามสร้างพาร์ติชันของวงกลม ดังนั้นพหุนามข้างบนคือพหุนาม n-th cyclotomic (cyclo- = circle; tom- = to cut)

คำจำกัดความ 1

พหุนาม n-th cyclotomic แสดงว่าเป็นพหุนามที่ไม่ซ้ำกับสัมประสิทธิ์จำนวนเต็มที่แบ่ง x ⁿ -1 แต่ไม่ใช่ x ^k -1 สำหรับ k <n

คำจำกัดความ 2

พหุนาม cyclotomic เป็นชุดของพหุนามหนึ่งชุดสำหรับจำนวนเต็มบวกแต่ละตัวเช่น:

โดยที่ k | n หมายถึง k หาร n

คำจำกัดความ 3

พหุนาม n-th cyclotomic คือพหุนาม x ⁿ -1 หารด้วย LCM ของพหุนามในรูปแบบ x ^k -1 โดยที่ k หาร n และ k <n

ตัวอย่าง

1. Φ ₁ (x) = x - 1
2. Φ ₂ (x) = x + 1
3. Φ ₃ (x) = x ² + x + 1
4. Φ ₃₀ (x) = x ⁸ + x ⁷ - x ⁵ - x ⁴ - x ³ + x + 1
5. Φ ₁₀₅ (x) = x ⁴⁸ + X ⁴⁷ + X ⁴⁶ - x ⁴³ - x ⁴² - 2x ⁴¹ - x ⁴⁰ - x ³⁹ + X ³⁶ + X ³⁵ + X ³⁴ + X ³³ + X ³² + X ³¹ - x ²⁸ - x ²⁶ - x ²⁴ - x ²² - x ²⁰ + x ¹⁷ + x ¹⁶ + x ¹⁵ + x ¹⁴ + x ¹³ + x ¹² - x⁹ - x ⁸ - 2x ⁷ - x ⁶ - x ⁵ + x ² + x + 1

งาน

รับค่าจำนวนเต็มบวกnคืนค่าnพหุนาม -th cyclotomic ตามที่นิยามไว้ข้างต้นในรูปแบบที่เหมาะสม (อนุญาตรายการ ieg ของค่าสัมประสิทธิ์)

กฎระเบียบ

คุณสามารถคืนค่าทศนิยมหรือจำนวนเชิงซ้อนได้ตราบใดที่มันปัดเศษเป็นค่าที่ถูกต้อง

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์

อ้างอิง

• Wolfram MathWorld
• วิกิพีเดีย

Haskell , 120 ไบต์

import Data.Complex
p%a=zipWith(\x y->x-a*y)(p++[0])$0:p
f n=foldl(%)[1][cis(2*pi/fromInteger n)^^k|k<-[1..n],gcd n k<2]

ลองออนไลน์!

ให้รายชื่อของการลอยที่ซับซ้อนที่มีรายการเช่น1.0000000000000078 :+ 3.314015728506092e-14เนื่องจากการลอยความไม่แน่นอน วิธีการโดยตรงของการคูณออกเพื่อกู้คืนพหุนามจากรากของมัน

นี่fromIntegerเป็นสัมปทานขนาดใหญ่สำหรับระบบประเภทของ Haskell จะต้องมีวิธีที่ดีกว่า ข้อเสนอแนะยินดีต้อนรับ การจัดการกับรากเหง้าของความเป็นสัญลักษณ์อาจช่วยได้

Haskell , 127 ไบต์

(h:t)%q|all(==0)t=[]|1>0=h:zipWith(\x y->x-h*y)t q%q
f n=foldl(%)(1:(0<$[2..n])++[-1])[tail$f k++[0,0..]|k<-[1..n-1],mod n k<1]

ลองออนไลน์!

ไม่มีการนำเข้า

ใช้สูตร

คำนวณΦ_n (x) โดยการหาร LHS ด้วยเงื่อนไขอื่น ๆ ใน RHS

ผู้ปฏิบัติ%งานทำการหารพหุนามโดยอาศัยส่วนที่เหลือเป็นศูนย์ ตัวหารจะถือว่าเป็น monic และจะได้รับโดยไม่ต้องนำที่ 1 zipWithและยังมีเลขท้ายอนันต์เพื่อหลีกเลี่ยงการตัดทอนเมื่อทำ

Mathematica, 43 41 ไบต์

Factor[x^#-1]/Times@@#0/@Most@Divisors@#&

แน่นอนเราสามารถใช้ในตัว แต่ถ้าเราทำไม่ได้แบ่งนี้x ⁿ -1 โดยΦ _k ( x ) (คำนวณซ้ำ) สำหรับทุกตัวหารที่เหมาะสมkของn

เราใช้Factorเพื่อรับพหุนามในตอนท้าย ฉันคิดว่าเหตุผลที่งานนี้เป็นx^#-1ปัจจัยที่มีอยู่ในพหุนาม cyclotomic ทั้งหมดของตัวหารของnแล้วเราหารสิ่งที่เราไม่ต้องการ

-2 ไบต์ขอบคุณ Jenny_mathy เขียนใหม่Factorเพื่อใช้กับตัวเศษเท่านั้น

MATL , 32 31 27 25 ไบต์

Z\"@:@/]XHxvHX~18L*Ze1$Yn

ผลลัพธ์อาจไม่ใช่จำนวนเต็มเนื่องจากความไม่ถูกต้องของเลขทศนิยม (ซึ่งอนุญาต) ส่วนท้ายจะปัดเศษเพื่อความชัดเจน

ลองออนไลน์!

Haskell , 250 236 233 218 216 ไบต์

นี่เป็นเวอร์ชัน verbose (@xnor สามารถทำได้เกือบครึ่งคะแนน ) แต่รับประกันว่าจะทำงานได้nตราบใดที่คุณมีหน่วยความจำเพียงพอ แต่ไม่ได้ใช้ builtin สำหรับสร้างพหุนาม n-th cyclotomic อินพุตเป็นจำนวนเต็มขนาดโดยพลการและเอาต์พุตเป็นพหุนามชนิดที่มีสัมประสิทธิ์ rational (แน่นอน)

แนวคิดคร่าวๆนี่คือแคลคูลัสพหุนามแบบวนซ้ำ สำหรับn=1หรือnนายกมันเล็กน้อย สำหรับตัวเลขอื่น ๆ วิธีการนี้ใช้สูตรจากนิยาม 2

แก้ไขได้ ขอบคุณ @ H.PWiz สำหรับจำนวนไบต์!

import Math.Polynomial
import Data.Ratio
import NumberTheory
p=powPoly x
q=poly LE
c n|n<2=q[-1,1%1]|isPrime n=sumPolys$p<$>[0..n-1]|1>0=fst$quotRemPoly(addPoly(p n)$q[-1])$foldl1 multPoly[c d|d<-[1..n-1],n`mod`d<1]

สำหรับn=105อัตราผลตอบแทนดังต่อไปนี้พหุนาม (ฉันจัดเรียงส่วนทั้งหมด%1):

[1,1,1,0,0,-1,-1,-2,-1,-1,0,0,1,1,1,1,1,1,0,0,-1,0,-1,0,-1,0,-1,0,-1,0,0,1,1,1,1,1,1,0,0,-1,-1,-2,-1,-1,0,0,1,1,1]

พหุนามn=15015สามารถพบได้ที่นี่ (ค่าสัมประสิทธิ์ที่ใหญ่ที่สุดคือ 23)

ลองออนไลน์!

เยลลี่ 23 ไบต์

R÷
ÆḌÇ€FQœ-@Ç×ı2×ØPÆeÆṛ

ลองออนไลน์!

ส่งออกเป็นรายการของค่าสัมประสิทธิ์

มีจุดลอยตัวและความคลาดเคลื่อนที่ซับซ้อน ท้ายกระดาษทำการปัดเศษเพื่อทำให้เอาต์พุตสวยขึ้น

J , 36 ไบต์

1+//.@(*/)/@(,.~-)_1^2*%*i.#~1=i.+.]

ลองออนไลน์!

ใช้สูตร

มีความไม่ถูกต้องบางจุดลอยตัว แต่ได้รับอนุญาต

Mathematica, 81 ไบต์

Round@CoefficientList[Times@@(x-E^(2Pi*I#/k)&/@Select[Range[k=#],#~GCD~k<2&]),x]&

R , 176 171 139 112 ไบต์

function(n){for(r in exp(2i*pi*(x=1:n)[(g=function(x,y)ifelse(o<-x%%y,g(y,o),y))(x,n)<2]/n))T=c(0,T)-r*c(T,0)
T}

ลองออนไลน์!

เวอร์ชั่นที่เรียบง่ายกว่าเดิม ใช้ห่วงมากกว่าforReduce

Pari / GP 8 ไบต์

แบบในตัว

polcyclo

ลองออนไลน์!

Pari / GPขนาด 39 ไบต์โดยไม่มีในตัว

f(n)=p=x^n-1;fordiv(n,d,d<n&&p/=f(d));p

ใช้สูตร:

$\Phi_n(x)=\dfrac{x^{n}-1}{\prod\limits_{\stackrel{d|n}{{}_{d<n}}}\Phi_{d}(x)}$.

ลองออนไลน์!

CJam ( 52 51 ไบต์)

{M{:K,:!W+K,0-{K\%!},{j($,\:Q,-[{(\1$Qf*.-}*;]}/}j}

สาธิตออนไลน์ นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชั่น) ซึ่งใช้จำนวนเต็มบนสแต็กและปล่อยให้มีค่าสัมประสิทธิ์อาร์เรย์ขนาดใหญ่ในสแต็ก

การผ่า

{                    e# Define a block
  M{                 e#   Memoised recursion with no base cases.
    :K,:!W+          e#     Store argument in K and build (x^K - 1)
    K,0-{K\%!},      e#     Find proper divisors of K
    {                e#     Foreach proper divisor D...
      j              e#       Recursive call to get Dth cyclotomic poly
      ($,\:Q,-       e#       The cleverest bit. We know that it is monic, and the
                     e#       poly division is simpler without that leading 1, so
                     e#       pop it off and use it for a stack-based lookup in
                     e#       calculating the number of terms in the quotient.
                     e#       Ungolfed this was (;:Q1$,\,-
                     e#       Store the headless divisor in Q.
      [              e#       Gather terms into an array...
        {            e#         Repeat the calculated number of times...
          (\         e#           Pop leading term, which goes into the quotient.
          1$Qf*.-    e#           Multiply Q by that term and subtract from tail.
        }*;          e#         Discard the array of Q,( zeroes. 
      ]
    }/
  }j
}

JavaScript (ES6), 337 333 284 ... 252 250 245 242 ไบต์

(v,z=[e=[1,u=0]],g=(x,y)=>y?g(y,x%y):x,h=Math,m=(l,x,p=h.cos(l),q=h.sin(l),i=0)=>x.map(()=>[(i&&(n=x[i-1])[0])-(w=x[i])[0]*p+w[1]*q,(i++&&n[1])-w[1]*p-w[0]*q]))=>{for(;++u<v;z=g(v,u)-1?z:[...m(h.PI*2*u/v,z),e]);return z.map(r=>h.round(r[0]))}

คำอธิบาย (เลือกไว้):

z=[e=[1,u=0]]

เริ่มต้น z = (1 + 0i) * x ^ 0

g=(x,y)=>y?g(y,x%y):x

การคำนวณ GCD

h=Math

เนื่องจากฉันต้องการใช้ฟังก์ชั่นคณิตศาสตร์ค่อนข้างมากฉันจึงใช้ตัวแปรอื่นที่นี่

m=(l,x,p=h.cos(l),q=h.sin(l),i=-1)=>blah blah blah

การคูณพหุนาม

for(;++u<v;z=g(v,u)-1?z:[...m(h.PI*2*u/v,z),e]);

สูตรที่ใช้คือ

return z.map(r=>h.round(r[0]))

บีบอัดผลลัพธ์กลับไปที่อาร์เรย์จำนวนเต็ม

ขาออก:

Array (ต้องระบุ) อาร์เรย์ของจำนวนเต็มโดยมีองค์ประกอบที่ตำแหน่ง i แสดงถึงค่าสัมประสิทธิ์ x ^ i

หนึ่งในปัญหาของ JS คือเนื่องจาก JS ไม่ได้ให้ไลบรารี่เนทีฟสำหรับการคำนวณเกี่ยวกับชื่อพหุนามและจำนวนเชิงซ้อน

console.log (phi (105)) ให้

Array(49)
 0:  1    1:  1    2:  1    3: -0    4: -0    5: -1    6: -1 
 7: -2    8: -1    9: -1   10:  0   11: -0   12:  1   13:  1 
14:  1   15:  1   16:  1   17:  1   18:  0   19: -0   20: -1 
21:  0   22: -1   23: -0   24: -1   25:  0   26: -1   27: -0 
28: -1   29:  0   30:  0   31:  1   32:  1   33:  1   34:  1 
35:  1   36:  1   37: -0   38: -0   39: -1   40: -1   41: -2 
42: -1   43: -1   44: -0   45: -0   46:  1   47:  1   48:  1 
length: 49
__proto__: Array(0)

337> 333 (-4): เปลี่ยนรหัสเพื่อตรวจสอบค่าที่ไม่ได้กำหนด

333> 284 (-49): เปลี่ยนฟังก์ชั่นการคูณพหุนามเพราะสามารถทำให้ง่ายขึ้น

284> 277 (-7): ลบรหัสซ้ำซ้อนบางส่วน

277> 265 (-12): ใช้ 2 ตัวแปรแทนอาร์เรย์ 2 องค์ประกอบเพื่อปล่อยบางไบต์ในการใช้อาร์เรย์

265> 264 (-1): ใช้ Array.push () แทน Array.concat () เพื่อลด 4 ไบต์ แต่เพิ่ม 3 สำหรับวงเล็บปีกกา for-loop และตัวแปร z

264> 263 (-1): เล่นกอล์ฟเพิ่มเติมในการแก้ไขครั้งล่าสุด

263> 262 (-1): เล่นกอล์ฟบน for loop

262> 260 (-2): เขียนประโยค if

260> 258 (-2): รวมการประกาศเพิ่มเติม

258> 252 (-6): ใช้เพื่อนำการอ้างอิงอาร์เรย์กลับมาใช้ใหม่

252> 250 (-2): แทนที่ตัวดำเนินการยูนารีบางตัวเป็นตัวดำเนินการไบนารี

250> 245 (-5): ย้ายการเพิ่มขึ้นใน Array.map () ไปที่การอ้างอิงล่าสุดของตัวนับเพื่อลบไบต์

245> 242 (-3): ใช้ไวยากรณ์การแพร่กระจายแทน Array.push ()