Bạn có một số đa thức cô đơn, vì vậy hãy tạo cho họ một số bạn đồng hành (những người sẽ không đe dọa đâm)!

Đối với một đa thức bậc n, có một ma trận khối lập phươngn by n đồng hành cho nó. Bạn cần tạo một hàm chấp nhận một danh sách các hệ số cho một đa thức theo thứ tự tăng dần ( ) hoặc giảm dần ( ) (nhưng không phải cả hai) và xuất ra ma trận đồng hành. a + bx +cx^2 + …ax^n + bx^(n-1) + cx^(n-2)+…

đối với đa thức c0 + c1x + c2x^2 + ... + cn-1x^(n-1) + x^n, ma trận đồng hành của nó là

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

lưu ý rằng hệ số cho x^nlà 1. Đối với bất kỳ giá trị nào khác, hãy chia tất cả các hệ số còn lại cho x^n's. Ngoài ra, số 1 được bù từ đường chéo.

Nếu ngôn ngữ bạn đang sử dụng đã chứa một chức năng hoặc mô-đun thực hiện điều này, bạn không thể sử dụng ngôn ngữ đó - bạn phải tự viết.

Chẳng hạn, nếu bạn có 4x^2 – 7x + 12, các hệ số theo thứ tự tăng dần (12, -7, 4)và thứ tự giảm dần (4, -7, 12). Các chức năng hoặc chương trình nên đầu ra [(0, -3.0), (1, 1.75)]cho một trong hai thứ tự. Chỉ định thứ tự mà mã của bạn chấp nhận. Đa thức tối thiểu phải là một bậc hai. Hệ số được giới hạn ở số thực.

Dưới đây là các ví dụ - đầu ra của bạn không phải phù hợp với định dạng đẹp nhưng nó sẽ xuất các hàng (theo ()) của ma trận theo thứ tự.

Thứ tự tăng dần:

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

Thứ tự giảm dần:

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

Dennis chiến thắng với 20 byte!

CJam, 23 20 byte

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

Đây là một chức năng bật đầu vào (thứ tự tăng dần) từ ngăn xếp và đẩy đầu ra trở lại.

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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

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

Dùng thử trực tuyến

Điều này nhận đầu vào theo thứ tự tăng dần, sử dụng định dạng danh sách CJam. Đầu vào mẫu:

[-4.0 -7.0 13.0]

Giải trình:

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 byte

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

Chấp nhận đầu vào theo thứ tự tăng dần.

Giải trình:

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

Dùng thử trực tuyến

Julia, 43 byte

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

Điều này sử dụng thứ tự giảm dần cho đầu vào. Nó xây dựng ma trận xoay 180 độ, để cho phép sử dụng "mắt" hiệu quả hơn, sau đó xoay ma trận theo đúng hướng.

Julia, 64 44 byte

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

Chấp nhận một vectơ của các hệ số theo thứ tự tăng dần.

Ung dung:

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

Dùng thử trực tuyến

Đã lưu 20 byte nhờ Glen O!

R, 71 59 byte

Đưa đầu vào theo thứ tự tăng dần.

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

Ung dung:

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 byte

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

Nó sử dụng thứ tự tăng dần cho đầu vào, với định dạng [3., 7., -5., 4., 1.]hoặc [3. 7. -5. 4. 1.].

Hãy thử trực tuyến (trong Octave).

Ví dụ (trong 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

Nếu một chương trình hợp lệ (thay vì một hàm), với stdin và stdout:

Matlab, 59 byte

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

Octave, 45 44 byte

Giả sử clà một vectơ cột với hệ số công suất cao nhất xở cuối.

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

Phiên bản cũ:

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

_{Năm cao, Julia!}

Python 2, 141 byte

Nỗ lực của riêng tôi:

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)

Đưa ra một danh sách các hệ số theo thứ tự giảm dần và đầu tiên xây dựng chuyển vị của ma trận đồng hành - được biết đến với việc đâm và nói nhiều. Trả về sử dụng zip để tạo ra sự hoán vị của chuyển vị này để có được ma trận thực tế.

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

Thứ tự tăng dần.

Kiểm tra chạy đoạn mã dưới đây trong bất kỳ trình duyệt tuân thủ EcmaScript 6 nào.

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 byte

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

Đưa đầu vào theo thứ tự tăng dần. Lưu ý rằng điều này sẽ không hoạt động cho đa thức bậc <2, vì TI-BASIC không hỗ trợ các ma trận hoặc danh sách trống. Trong khi chờ phán quyết từ OP, tôi có thể sửa lỗi này với chi phí một vài byte.

Đầu tiên, chúng tôi lưu trữ danh sách vào ∟Xđể sử dụng phần tử cuối cùng sau này; sau đó, chúng tôi tính toán ΔList(Ans-cumSum(Ans)), đó chỉ là danh sách phủ định với phần tử cuối cùng được cắt ra và chuyển đổi nó thành một vectơ cột. Vì List▶matr(không sửa đổi Ans, chúng tôi có thể sử dụng dòng tiếp theo để lấy thứ nguyên của danh sách mà chúng tôi sử dụng ba lần. TI-BASIC không có nối dọc, vì vậy chúng ta cần thực hiện chuyển vị và ghép theo chiều ngang. Trong dòng cuối cùng, [A]/∟X(Anssẽ không hoạt động vì ma trận có thể được nhân với vô hướng nhưng không được chia.

Một bên: Để tạo ra các vectơ hàng không, chúng ta tận dụng randM(lệnh hiếm khi hữu ích . randM(tạo một ma trận ngẫu nhiên, nhưng các mục nhập của nó luôn là các số nguyên ngẫu nhiên trong khoảng từ -9 đến 9 (!), vì vậy nó thực sự chỉ hữu ích khi tạo ma trận bằng không.

Pari / GP , 49 byte

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

Hãy thử trực tuyến!