คุณมีพหุนามจำนวนมากที่อ้างว้างดังนั้นทำให้พวกเขามีเพื่อนบางคน (ที่ไม่ขู่ว่าจะแทง)!

สำหรับพหุนามของดีกรี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)

โปรดทราบว่าค่าสัมประสิทธิ์สำหรับx^nคือ 1 สำหรับค่าอื่น ๆ ให้หารค่าสัมประสิทธิ์ที่เหลือทั้งหมดด้วย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 ไบต์!

CJam, 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.

CJam, 32 31 28 bytes

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.

APL, 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
}

ลองออนไลน์

จูเลีย 43 ไบต์

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

สิ่งนี้ใช้ลำดับจากมากไปน้อยสำหรับอินพุต มันสร้างเมทริกซ์ที่หมุนได้ 180 องศาเพื่อให้สามารถใช้ "ตา" ได้อย่างมีประสิทธิภาพมากขึ้นจากนั้นหมุนเมทริกซ์ไปในทิศทางที่ถูกต้อง

Julia, 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 ไบต์ขอบคุณ Glen O!

R, 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])
}

Matlab, 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.]

ลองออนไลน์ (ในระดับแปดเสียง)

ตัวอย่าง (ใน Matlab):

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

หากโปรแกรมนั้นถูกต้อง (แทนที่จะเป็นฟังก์ชั่น) ด้วย stdin และ stdout:

Matlab, 59 ไบต์

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

อ็อกเทฟ, 45ไบต์

สมมติว่า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)]

_{สูงห้าจูเลีย!}

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

JavaScript (ES6) 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>

TI-BASIC, 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 ไม่สนับสนุนเมทริกซ์หรือรายการที่ว่างเปล่า รอการพิจารณาคดีจาก OP ฉันสามารถแก้ไขได้ด้วยราคาไม่กี่ไบต์

อันดับแรกเราเก็บรายการไว้∟Xเพื่อใช้องค์ประกอบสุดท้ายในภายหลัง จากนั้นเราคำนวณΔList(Ans-cumSum(Ans))ซึ่งเป็นรายการที่ถูกลบเมื่อองค์ประกอบสุดท้ายถูกตัดออกและแปลงเป็นเวกเตอร์คอลัมน์ เนื่องจากList▶matr(ไม่ได้แก้ไขAnsเราสามารถใช้บรรทัดถัดไปเพื่อพิจารณาขนาดของรายการซึ่งเราใช้สามครั้ง TI-BASIC ไม่มีการต่อข้อมูลแนวตั้งดังนั้นเราจำเป็นต้องทำการเชื่อมโยงและเชื่อมโยงในแนวนอน ในบรรทัดสุดท้าย[A]/∟X(Ansจะไม่ทำงานเพราะสเกลาร์สามารถคูณด้วยสเกลาร์ได้ แต่จะไม่หาร

อีกด้านหนึ่ง: เพื่อสร้างเวกเตอร์แถวของศูนย์เราใช้ประโยชน์จากสิ่งที่ไม่ค่อยมีประโยชน์ randM(คำสั่งที่randM(สร้างเมทริกซ์แบบสุ่ม แต่รายการของมันจะเป็นจำนวนเต็มแบบสุ่มเสมอระหว่าง -9 ถึง 9 (!) ดังนั้นมันจึงมีประโยชน์จริง ๆ เท่านั้นที่จะสร้างเมทริกซ์เป็นศูนย์

Pari / GP , 49 ไบต์

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

ลองออนไลน์!