एक साथी मैट्रिक्स का निर्माण

Question

आपके पास कई बहुपत्नी हैं जो एकाकी हैं, इसलिए उन्हें कुछ साथी (जो छुरा मारने की धमकी नहीं देंगे) बनाते हैं!

बहुपद की डिग्री के लिए n, इसके लिए एक n by nसाथी क्यूब मैट्रिक्स है। आपको एक ऐसा फ़ंक्शन बनाने की ज़रूरत है जो बहुपद के लिए गुणांक की एक सूची को आरोही ( a + bx +cx^2 + …) या अवरोही ( ax^n + bx^(n-1) + cx^(n-2)+…) क्रम में (लेकिन दोनों नहीं) और साथी मैट्रिक्स को आउटपुट करने के लिए स्वीकार करता है ।

एक बहुपद के लिए c0 + c1x + c2x^2 + ... + cn-1x^(n-1) + x^n, इसका साथी मैट्रिक्स है

     (0, 0, 0, ..., -c0  ),
     (1, 0, 0, ..., -c1  ),
     (0, 1, 0, ..., -c2  ),
     (...................),
     (0, 0, ..., 1, -cn-1)

ध्यान दें कि गुणांक 1 x^nहै। किसी भी अन्य मान के लिए, बाकी सभी गुणांक को x^n's द्वारा विभाजित करें । इसके अतिरिक्त, 1 के विकर्ण से ऑफसेट हैं।

यदि आप जिस भाषा का उपयोग कर रहे हैं, उसमें पहले से ही एक फ़ंक्शन या मॉड्यूल है जो ऐसा करता है, तो आप इसका उपयोग नहीं कर सकते हैं - आपको अपना खुद का लिखना होगा।

उदाहरण के लिए, यदि आपके पास 4x^2 – 7x + 12, आरोही क्रम में गुणांक हैं (12, -7, 4)और अवरोही क्रम है (4, -7, 12)। फ़ंक्शन या प्रोग्राम को [(0, -3.0), (1, 1.75)]ऑर्डर के लिए आउटपुट करना चाहिए । निर्दिष्ट करें कि आपका कोड किस आदेश को स्वीकार करता है। न्यूनतम बहुपद एक द्विघात होना चाहिए। गुणांक वास्तविक संख्या तक सीमित हैं।

नीचे दिए गए उदाहरण हैं - आपके आउटपुट को सुंदर स्वरूपण से मेल नहीं खाता है, लेकिन यह पंक्तियों को आउटपुट करना चाहिए (में () मैट्रिक्स ) ।

आरोही क्रम:

input:
    [3., 7., -5., 4., 1.]
output:
    [(0, 0, 0, -3.),
     (1, 0, 0, -7.),
     (0, 1, 0,  5.),
     (0, 0, 1, -4.)]

input:
    [-4., -7., 13.]
output:
    [(0, 0.30769231),
     (1, 0.53846154)]

input:
    [23., 1., 92., 8., -45., 88., 88.]
output:
    [(0, 0, 0, 0, 0, -0.26136364),
     (1, 0, 0, 0, 0, -0.01136364),
     (0, 1, 0, 0, 0, -1.04545455),
     (0, 0, 1, 0, 0, -0.09090909),
     (0, 0, 0, 1, 0,  0.51136364),
     (0, 0, 0, 0, 1, -1.        )]

घटते क्रम में:

input:
    [1., 4., -5., 7., 3.]
output:
    [(0, 0, 0, -3.),
     (1, 0, 0, -7.),
     (0, 1, 0,  5.),
     (0, 0, 1, -4.)]

input:
    [13., -7., -4.]
output:
    [(0, 0.30769231),
     (1, 0.53846154)]

input:
    [88., 88., -45., 8., 92.,1., 23.]
output:
    [(0, 0, 0, 0, 0, -0.26136364),
     (1, 0, 0, 0, 0, -0.01136364),
     (0, 1, 0, 0, 0, -1.04545455),
     (0, 0, 1, 0, 0, -0.09090909),
     (0, 0, 0, 1, 0,  0.51136364),
     (0, 0, 0, 0, 1, -1.        )]

---

20 बाइट्स के साथ डेनिस जीते!

Comments

गुणांक वास्तविक हैं (जटिल नहीं), सही?

— लुइस मेंडो

क्या कार्यक्रम वैध हैं, या यह केवल कार्य है? (ध्यान रखें कि फ़ंक्शंस को प्रतियोगिता तक सीमित रखना दिलचस्प

— लँगुआज़

न्यूनतम डिग्री बहुपद के लिए हमें क्या करना होगा?

— एलेक्स ए।

Answer 1

सीजेएम, 23 20 बाइट्स

{)W*f/_,,_ff=1f>\.+}

यह एक फ़ंक्शन है जो स्टैक से इनपुट (आरोही क्रम) को पॉप करता है और बदले में आउटपुट को धक्का देता है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

)   e# Pop the last element from the input array.
W*  e# Multiply it by -1.
f/  e# Divide the remaining array elements by this product.
_,  e# Push a copy of the array and compute its length (L).
,_  e# Push [0 ... L-1] twice.
ff= e# For each I in [0 ... L-1]:
    e#   For each J in [0 ... L-1]:
    e#     Push (I==J).
    e# This pushes the L x L identity matrix.
1f> e# Discard the first element of each row, i.e., the first column.
\   e# Swap the result with the modified input.
.+  e# Vectorized append; append the input as a new column.

Answer 2

CJam, 32 31 28 बाइट्स

0q~)f/f-_,(_,\0a*1+fm<~]W%z

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

यह CJam सूची प्रारूप का उपयोग करके इनपुट को आरोही क्रम में ले जाता है। नमूना इनपुट:

[-4.0 -7.0 13.0]

स्पष्टीकरण:

0     Push a 0 for later sign inversion.
q~    Get and interpret input.
)     Pop off last value.
f/    Divide all other values by it.
f-    Invert sign of values.
_,    Get count of values, which corresponds to n.
(     Decrement by 1.
_,    Create list of offsets [0 1 ... n-1] for later.
\     Swap n-1 back to top.
0a*   Create list of n-1 zeros.
1+    Append a 1. This is the second-but-last column [0 0 ... 0 1].
fm<   Apply rotation with all offsets [0 1 ... n-1] to column.
~     Unwrap the list of 0/1 columns.
]     Wrap all columns
W%    Invert their order from last-to-first to first-to last.
z     Transpose to get final matrix.
`     Convert to string for output.

Answer 3

एपीएल, 40 30 बाइट्स

{(-n↑⍵÷⊃⊖⍵),⍨⍉1↓⍉∘.=⍨⍳n←1-⍨≢⍵}

इनपुट को आरोही क्रम में स्वीकार करता है।

स्पष्टीकरण:

{
                        n←1-⍨≢⍵    ⍝ Define n = length(input)-1
                   ∘.=⍨⍳           ⍝ Create an n×n identity matrix
               ⍉1↓⍉                ⍝ Drop the leftmost column
            ,⍨                     ⍝ Append on the right:
  (-n↑⍵                            ⍝ n negated coefficients,
       ÷⊃⊖⍵)                       ⍝ divided by the n+1st
}

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

Answer 4

जूलिया, 43 बाइट्स

c->rot180([-c[2:(n=end)]/c[] eye(n-1,n-2)])

यह इनपुट के लिए अवरोही क्रम का उपयोग करता है। यह "आंख" के अधिक कुशल उपयोग को सक्षम करने के लिए, मैट्रिक्स को 180 डिग्री घुमाया जाता है, फिर मैट्रिक्स को सही अभिविन्यास में घुमाता है।

Answer 5

जूलिया, 64 44 बाइट्स

c->(k=c[n=end];[eye(n-=1)[:,2:n] -c[1:n]/k])

आरोही क्रम में गुणांक के एक वेक्टर को स्वीकार करता है।

Ungolfed:

function f(c::Array)
    # Simultaneously define k = the last element of c and
    # n = the length of c
    k = c[n = end]

    # Decrement n, create an n×n identity matrix, and exclude the
    # first column. Horizontally append the negated coefficients.
    [eye(n-=1)[:,2:n] -c[1:n]/k]
end

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

ग्लेन ओ को धन्यवाद 20 बाइट्स बचाए!

Answer 6

आर, 71 59 बाइट्स

आरोही क्रम में इनपुट लेता है।

function(x)cbind(diag(n<-length(x)-1)[,2:n],-x[1:n]/x[n+1])

Ungolfed:

f <- function(x) {
    # Get the length of the input
    n <- length(x)-1

    # Create an identity matrix and exclude the first column
    i <- diag(n)[, 2:n]

    # Horizontally append the negated coefficients divided
    # by the last one
    cbind(i, -x[1:n]/x[n+1])
}

Answer 7

मतलाब, 66 बाइट्स

function y=f(c)
n=numel(c);y=[[0*(3:n);eye(n-2)] -c(1:n-1)'/c(n)];

यह प्रारूप के साथ [3., 7., -5., 4., 1.]या इनपुट के लिए आरोही क्रम का उपयोग करता है [3. 7. -5. 4. 1.]।

इसे ऑनलाइन (ऑक्टेव में) आज़माएँ ।

उदाहरण (मतलब में):

>> f([23., 1., 92., 8., -45., 88., 88.])
ans =
                   0                   0                   0                   0                   0  -0.261363636363636
   1.000000000000000                   0                   0                   0                   0  -0.011363636363636
                   0   1.000000000000000                   0                   0                   0  -1.045454545454545
                   0                   0   1.000000000000000                   0                   0  -0.090909090909091
                   0                   0                   0   1.000000000000000                   0   0.511363636363636
                   0                   0                   0                   0   1.000000000000000  -1.000000000000000

---

यदि कोई कार्यक्रम वैध है (एक फ़ंक्शन के बजाय), स्टडिन और स्टडआउट के साथ:

मतलाब, 59 बाइट्स

c=input('');n=numel(c);[[0*(3:n);eye(n-2)] -c(1:n-1)'/c(n)]

Comments

मुझे लगता है कि आप कर सकते हैंn=numel(c=input(''));

— lirtosiast

@ThomasKwa धन्यवाद! हालाँकि, यह मतलबी में मान्य वाक्यविन्यास नहीं है। n=numel(input(''))मान्य होगा, लेकिन मुझे cबाद में फिर से उपयोग करने की आवश्यकता है

— लुइस मेंडो

माफ़ करना; इसने ऑक्टेव में काम किया जहां मैंने इसका परीक्षण किया।

— lirtosiast

Answer 8

ऑक्टेव, 45 44 बाइट्स

मान cलेना एक स्तंभ वेक्टर है जिसमें xअंत में उच्चतम शक्ति का गुणांक होता है ।

@(c)[eye(n=rows(c)-1)(:,2:n),-c(1:n)/c(end)]

पुराना संस्करण:

@(c)[eye(n=numel(c)-1)(:,2:n),-c(1:n)/c(end)]

_{उच्च पाँच, जूलिया!}

Answer 9

पायथन 2, 141 बाइट्स

मेरा अपना प्रयास:

def C(p):
 c,r=p.pop(0),range;d=[-i/c for i in p];n=len(d);m=[[0]*n for i in r(n)]
 for i in r(n-1):m[i][i+1]=1
 m[-1]=d[::-1];return zip(*m)

अवरोही क्रम में गुणांक की एक सूची लेता है और सबसे पहले साथी मैट्रिक्स के पारगमन का निर्माण करता है - छुरा घोंपने और बातूनी होने के लिए जाना जाता है। रिटर्न वास्तविक मैट्रिक्स को प्राप्त करने के लिए इस ट्रांसपोज़िशन के उत्पादन के लिए ज़िप का उपयोग करता है।

>>> C([1., 4., -5., 7., 3.])
[(0, 0, 0, -3.0), (1, 0, 0, -7.0), (0, 1, 0, 5.0), (0, 0, 1, -4.0)]

Answer 10

जावास्क्रिप्ट (ईएस 6) 85

आरोही क्रम।

किसी भी EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें।

f=c=>alert(c.map((v,i)=>c.map((x,j)=>++j-i?j-c.length?0:-v/m:1),m=c.pop()).join(`
`))

// test
// redefine alert to write into the snippet body
alert=x=>O.innerHTML+=x+'\n'

function test() {
  v=I.value.match(/\d+/g)
  I.value=v+''
  alert(v)
  f(v)
}  

test()

<input value='23.,1.,92.,8.,-45.,88.,88.' id=I><button onclick="test()">-></button>
<pre id=O></pre>

Answer 11

टीआई-बेसिक, 50 बाइट्स

Ans→X
List▶matr(ΔList(Ans-cumSum(Ans)),[A]
dim(Ans
augment(augment(0randM(Ans-2,1),identity(Ans-2))ᵀ,[A]∟X(Ans)⁻¹

आरोही क्रम में इनपुट लेता है। ध्यान दें कि यह डिग्री <2 के बहुपद के लिए काम नहीं करेगा, क्योंकि TI-BASIC खाली मैट्रिस या सूचियों का समर्थन नहीं करता है। ओपी के एक फैसले को लंबित करते हुए, मैं इसे कुछ बाइट्स की कीमत पर ठीक कर सकता हूं।

पहले, हम ∟Xअंतिम तत्व का उपयोग करने के लिए सूची को बाद में संग्रहीत करते हैं ; फिर, हम गणना करते हैं ΔList(Ans-cumSum(Ans)), जो कि पिछले तत्व को काटे जाने के साथ सिर्फ एक नकारात्मक सूची है, और इसे एक कॉलम वेक्टर में परिवर्तित करते हैं। चूंकि List▶matr(संशोधित नहीं होता है Ans, इसलिए हम सूची के आयाम को लेने के लिए अगली पंक्ति का उपयोग कर सकते हैं, जिसे हम तीन बार उपयोग करते हैं। TI-BASIC में अनुलंब अनुरेखण नहीं होता है, इसलिए हमें स्थानान्तरण और क्षैतिज रूप से समवर्ती लेने की आवश्यकता होती है। अंतिम पंक्ति में,[A]/∟X(Ans काम नहीं करेगा क्योंकि मैट्रिक्स को स्केलर से गुणा किया जा सकता है लेकिन विभाजित नहीं।

एक तरफ: शून्य के पंक्ति वेक्टर को उत्पन्न करने के लिए, हम शायद ही कभी उपयोगी randM(कमांड का लाभ उठाते हैं । randM(एक यादृच्छिक मैट्रिक्स बनाता है, लेकिन इसकी प्रविष्टियां हमेशा -9 और 9 (!) के बीच यादृच्छिक पूर्णांक होती हैं, इसलिए यह केवल शून्य मैट्रिक बनाने के लिए उपयोगी है।

Answer 12

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

p->concat(matid(#p-1),-p[1..#p-1]~/p[#p])[,2..#p]

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