सायक्लोटोमिक बहुपद

Question

पृष्ठभूमि (परिभाषाओं पर जाएं)

यूलर ने जटिल संख्याओं के बारे में एक सुंदर प्रमेय साबित किया: ई ^ix = कॉस (एक्स) + आई पाप (एक्स)।

यह डी मोइवर के प्रमेय को साबित करना आसान बनाता है:

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

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

हम द्वि-आयामी यूक्लिडियन विमान का उपयोग करके जटिल संख्याओं की साजिश कर सकते हैं, जिसमें वास्तविक हिस्से का प्रतिनिधित्व करने वाले क्षैतिज अक्ष और काल्पनिक भाग का प्रतिनिधित्व करने वाले ऊर्ध्वाधर अक्ष हैं। इस तरह, (3,4) जटिल संख्या 3 + 4i के अनुरूप होगा।

यदि आप ध्रुवीय निर्देशांक से परिचित हैं, (३,४) ध्रुवीय निर्देशांक में (५, अर्कटन (४/३) होंगे। पहली संख्या, आर, मूल से बिंदु की दूरी है; दूसरी संख्या, second, सकारात्मक x- अक्ष से बिंदु, काउंटर-दक्षिणावर्त तक मापा जाने वाला कोण है। परिणामस्वरूप, 3 = r cosθ और 4 = r sinθ। इसलिए, हम 3 + 4i को r cos r + ri sin r = r (cos can + i sinθ) = re i = के रूप में ^{लिख सकते हैं} ।

आइए हम जटिल समीकरण z ^{n को} हल करते हैं = 1 को , जहाँ n एक धनात्मक पूर्णांक है।

हम z = re ^{iθ करते हैं} । फिर, z ⁿ = r ⁿ e ^inθ । मूल से z ⁿ की दूरी r ^{n है} , और कोण ⁿ from है। हालांकि, हम जानते हैं कि मूल से 1 की दूरी 1 है, और कोण 0. है, इसलिए r ⁿ = 1 और ⁿ । = 0। हालांकि, यदि आप 2π अधिक घुमाते हैं, तो आप अभी भी उसी बिंदु पर समाप्त होते हैं, क्योंकि 2 just केवल एक पूर्ण चक्र है। इसलिए, r = 1 और nθ = 2k r, हमें z = e ^{2ik n / n} दे रहा है ।

हम अपनी खोज को ^{पुनर्स्थापित} करते हैं : z ⁿ = 1 के समाधान z = e ^{2ik n / n हैं} ।

एक बहुपद को अपनी जड़ों के संदर्भ में व्यक्त किया जा सकता है। उदाहरण के लिए, x ² -3x + 2 की जड़ें 1 और 2 हैं, इसलिए x ² -3x + 2 = (x-1) (x-2)। इसी तरह, ऊपर हमारी खोज से:

हालांकि, उस उत्पाद में निश्चित रूप से अन्य n की जड़ें थीं। उदाहरण के लिए, n = 8 लें। Z ⁴ = 1 की जड़ें z ⁸ = 1 की जड़ों के अंदर भी शामिल होंगी , क्योंकि z ⁴ = 1 का तात्पर्य z ⁸ = (z ⁴ ) ² = 1 ² = 1. n = 6 को उदाहरण के रूप में लें। यदि z ² = 1 है, तो हमारे पास z ⁶ = 1 भी होगा । इसी तरह, अगर z ³ = 1 है, तो z ⁶ = 1 है।

अगर हम z ⁿ = 1 के लिए अद्वितीय जड़ों को निकालना चाहते हैं , तो हमें 1. को छोड़कर किसी भी सामान्य भाजक को साझा करने के लिए k और n की आवश्यकता होगी, अन्यथा यदि वे एक सामान्य भाजक d जहाँ d> 1 साझा करते हैं, तो z होगा (k / d) -थ ^{n n / d} = 1 की जड़ । अपनी जड़ों के संदर्भ में बहुपद लिखने के लिए ऊपर दी गई तकनीक का उपयोग करके, हम बहुपद प्राप्त करते हैं:

ध्यान दें कि यह बहुपद z ^{n / d} = 1 की जड़ों को हटाकर ^d का n भाजक होने के साथ किया जाता है। हम दावा करते हैं कि ऊपर दी गई बहुपद में पूर्णांक गुणांक हैं। Z ^{n / d} -1 के रूप में बहुपदों के LCM पर विचार करें जहाँ d> 1 और d विभाजित होता है n। एलसीएम की जड़ें वे जड़ें हैं जिन्हें हम हटाना चाहते हैं। चूंकि प्रत्येक घटक में पूर्णांक गुणांक होते हैं, LCM में पूर्णांक गुणांक भी होते हैं। चूंकि LCM z ⁿ -1 को विभाजित करता है , इसलिए भागफल गुणांक के साथ बहुपद होना चाहिए, और भागफल बहुपद होता है।

Z ⁿ = 1 की जड़ों में सभी त्रिज्या 1 हैं, इसलिए वे एक सर्कल बनाते हैं। बहुपद n के अनूठे वृत्त के बिंदुओं का प्रतिनिधित्व करता है, इसलिए एक मायने में बहुपद चक्र का एक विभाजन बनाते हैं। इसलिए, ऊपर वाला बहुपद n-th साइक्लोटोमिक बहुपद है। (साइक्लो- = वृत्त; टमाटर- = काटने के लिए)

परिभाषा १

एन-वें साइक्लोओटोमिक बहुपद, निरूपित , पूर्णांक गुणांक के साथ अद्वितीय बहुपद है जो x ⁿ -1 को विभाजित करता है लेकिन k <n के लिए x ^k -1 नहीं है ।

परिभाषा २

साइक्लोओटोमिक बहुपद बहुपद का एक समूह है, जो प्रत्येक सकारात्मक पूर्णांक के लिए एक है, जैसे:

जहाँ k | n का मतलब k को विभाजित करता है n।

परिभाषा ३

एन-वें cyclotomic बहुपद बहुपद एक्स है ⁿ -1 रूप में बहुआयामी पद का एलसीएम एक्स से विभाजित ^{कश्मीर} -1 जहां कश्मीर विभाजित n और कश्मीर <n।

उदाहरण

1. Φ ₁ (x) = x - 1
2. Φ ₂ (x) = x + 1
3. Φ ₃ (x) = x ² + x + 1
4. Φ ₃₀ (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 ⁹ - x ⁸ - 2x ⁷ - x ⁶ - x ⁵ + x ² + x + 1

कार्य

एक सकारात्मक पूर्णांक को देखते हुए n, लौट nवें cyclotomic बहुपद ऊपर परिभाषित, एक उचित प्रारूप में (गुणांकों के ieeg सूची अनुमति दी है)।

नियम

आप फ़्लोटिंग पॉइंट / कॉम्प्लेक्स नंबरों को वापस कर सकते हैं जब तक कि वे सही मान पर गोल न हो जाएं।

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

संदर्भ

• वोल्फ्राम मैथवर्ल्ड
• विकिपीडिया

Comments

शायद परीक्षण के रूप में 105 जोड़ सकते हैं?

— जोनाथन एलन

@JonathanAllan मैं ४

— लीक नून

क्या फ्लोटिंग-पॉइंट अशुद्धि की अनुमति है?

— मील

@ मीलों मैं एक जुनून के साथ तैरने से नफरत करता हूं

— लीक नून

क्या हम तब तक जटिल फ़्लोटिंग पॉइंट नंबरों को आउटपुट कर सकते हैं जब तक कि वे निकटतम पूर्णांक / गौसियन पूर्णांक में गोल होने पर सही उत्तर देते हैं?

— फायरफ्लेम 241

Answer 1

हास्केल , 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हास्केल के प्रकार प्रणाली के लिए एक बड़ा रियायत है। वहाँ एक बेहतर तरीका हो गया है। सुझावों का स्वागत है। प्रतीकात्मक रूप से एकता की जड़ों से निपटना भी काम कर सकता है।

---

हास्केल , 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]

इसे ऑनलाइन आज़माएं!

कोई आयात नहीं।

सूत्र का उपयोग करता है

RHS में अन्य शर्तों के प्रत्येक LHS को विभाजित करके the_n (x) की गणना करता है।

ऑपरेटर %बहुपद पर विभाजन करता है, शेष शून्य होने पर निर्भर करता है। भाजक को राक्षसी माना जाता है, और अग्रणी 1 के बिना दिया जाता है, और जब ऐसा करने से बचने के लिए अनंत अनुगामी शून्य के साथ zipWith।

Comments

[0,0..]से एक बाइट कम है repeat 0।

— लाईकोनी

@flawr पॉलीओनियम्स को विभाजित करता है। मुझे लगता है कि यह आपके समाधान के समान विधि है।

— 21

यह बहुत खूबसूरत लग रहा है, मुझे कल करीब आना होगा :)

— दोष

यह जवाब मुझे हास्केल सीखना चाहता है।

— ग्यूसेप

@xnor -1 बाइट

— H.PWiz

Answer 2

गणितज्ञ, ४३ ४१ बाइट्स

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

बेशक, हम हमेशा में निर्मित उपयोग कर सकते हैं, लेकिन अगर हम नहीं करते हैं, यह विभाजित x ⁿ -1 Φ द्वारा _{कश्मीर} ( एक्स हर उचित भाजक के लिए) (रिकर्सिवली अभिकलन) कश्मीर के एन ।

हम Factorअंत में एक बहुपद प्राप्त करने के लिए उपयोग करते हैं। मुझे लगता है कि इसका कारण यह है कि nx^#-1 के विभाजक के सभी सायक्लोटोमिक बहुपद में कारक हैं , और फिर हम उन लोगों को विभाजित करते हैं जिन्हें हम नहीं चाहते हैं।

-2 बाइट्स जेनी_मैथी को धन्यवाद, Factorकेवल अंश पर लागू करने के लिए फिर से लिखना ।

Comments

यह भी खूब रही! आप का उपयोग करके एक बाइट बचा सकते हैंFactor@

— 23:42 पर J42161217

@ जेनी_मैथी ऐसा करने के Factor[x^#-1]/Times@@...बजाय पार्स करने लगती है ; अगर हमारे पास वहाँ कोष्ठक नहीं थे, तो हम कोष्ठक चाहते हैं।

— मिशा लावरोव

ठीक है ... लेकिन मेरा कहना है कि जब मैंने इसका परीक्षण किया, तो यह सही परिणाम दे रहा था ...

— J42161217

यह तो दिलचस्प है। इसका मतलब है कि हम इसे लिखकर एक और बाइट बचा सकते हैं Factor[x^#-1]/Times@@..., और इसका मतलब यह भी है कि मेरे पास कोई सुराग नहीं है कि यह कैसे काम करता है।

— मिशा लावरोव

Answer 3

MATL , 32 31 27 25 बाइट्स

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

फ्लोटिंग-पॉइंट अशुद्धियों (जिसकी अनुमति है) के कारण आउटपुट गैर-पूर्णांक हो सकता है। पाद स्पष्टता के लिए गोलाई करता है।

इसे ऑनलाइन आज़माएं!

Answer 4

हास्केल , 250 236 233 218 216 बाइट्स

यह एक वर्बोज़ संस्करण है, (@xnor इसे लगभग आधे स्कोर में कर सकता है ) लेकिन यह किसी भी nलंबे समय तक काम करने की गारंटी है जब तक आपके पास पर्याप्त मेमोरी है, लेकिन यह एन-वें साइक्लोथोमिक जीनोमियल उत्पन्न करने के लिए एक बिल्डिन का उपयोग नहीं करता है। इनपुट एक मनमाना आकार पूर्णांक है और आउटपुट एक बहुपद प्रकार है जिसमें (सटीक) तर्कसंगत गुणांक होते हैं।

यहाँ मोटे तौर पर अनुमान बहुपदों की गणना करता है। के लिए 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 है)।

इसे ऑनलाइन आज़माएं!

Comments

+1बिलियन नहीं होने के लिए।

— DJMcMayhem

@flawr आप क्यों उपयोग कर रहे हैं Rationals? यह उनके बिना ठीक काम करने लगता है

— H.PWiz

क्या यह? मेरे साथ समस्या थी quotRemPoly, मुझे फिर से कोशिश करने दें!

— दोष

आह "समस्या" यह थी कि यह Doubleगुणांक देता है यदि आप Ratio Integerइसके बजाय उपयोग नहीं करते हैं, जो बहुत (बहुत) बड़ी समस्याओं का कारण हो सकता है n।

— दोष

एह ... मुझे नहीं लगता कि यह एक समस्या है।

— H.PWiz

Answer 5

जेली , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

गुणांक की एक सूची के रूप में आउटपुट।

फ्लोटिंग पॉइंट और जटिल अशुद्धियाँ हैं। पाद लेख आउटपुट को सुंदर बनाने के लिए चक्कर लगाता है।

Answer 6

जे , 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सूत्र का उपयोग करता है

कुछ फ्लोटिंग-पॉइंट गलतियाँ हैं, लेकिन इसकी अनुमति है।

Answer 7

गणितज्ञ, 81 बाइट्स

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

Answer 8

आर , 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}

इसे ऑनलाइन आज़माएं!

व्यापक रूप से सरल संस्करण; forलूप का उपयोग करता है बजाय एक Reduce।

Answer 9

परी / जीपी , 8 बाइट्स

एक अंतर्निहित।

polcyclo

इसे ऑनलाइन आज़माएं!

---

पैरी / जीपी , 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)}$।

इसे ऑनलाइन आज़माएं!

Answer 10

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
}

Answer 11

जावास्क्रिप्ट (ईएस 6), 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

जीसीडी गणना।

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

किसी पूर्णांक सरणी में आउटपुट को कम से कम करें।

आउटपुट:

पूर्णांक का एक सरणी, स्थिति पर तत्व के साथ मैं x ^ i के गुणांक का प्रतिनिधित्व करता हूं।

जेएस की एक समस्या यह है कि चूंकि जेएस बहुपत्नी और जटिल संख्याओं पर गणना के लिए देशी पुस्तकालय प्रदान नहीं करता है, इसलिए उन्हें एक सरणी की तरह लागू करने की आवश्यकता है।

कंसोल.लॉग (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): 4 बाइट को कम करने के लिए Array.concat () के बजाय Array.push () का उपयोग करें, लेकिन लूप ब्रेसिज़ और z चर के लिए 3 जोड़ा

264> 263 (-1): अंतिम संशोधन पर आगे चलकर

263> 262 (-1): लूप के लिए तैयार है

262> 260 (-2): अगर क्लॉज को बाहर निकाला गया

260> 258 (-2): आगे की घोषणाओं को संयुक्त किया

258> 252 (-6): सरणी संदर्भों के पुन: उपयोग पर गोल्फ

२५२> २५० (-२): बाइनरी ऑपरेटरों के रूप में कुछ यूनीरी ऑपरेटरों को बदलें

250> 245 (-5): बाइट निकालने के लिए काउंटर के अंतिम संदर्भ में Array.map () में वेतन वृद्धि को स्थानांतरित करें

245> 242 (-3): Array.push () के बजाय स्प्रेड सिंटैक्स का उपयोग करें