당신은 외로워하는 많은 다항식을 가지고 있으므로, 그들을 동료로 찌르지 마십시오!

정도의 다항식에는 그에 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. 또한 1은 대각선에서 오프셋됩니다.

사용중인 언어에 이미이를 수행하는 함수 나 모듈이 포함 된 경우 사용할 수 없습니다. 직접 작성해야합니다.

예를 들어,가있는 경우 4x^2 – 7x + 12오름차순의 계수는 (12, -7, 4)내림차순 (4, -7, 12)입니다. 함수 또는 프로그램은 [(0, -3.0), (1, 1.75)]어느 쪽이든 출력해야합니다 . 코드가 수락하는 순서를 지정하십시오. 최소 다항식은 2 차 여야합니다. 계수는 실수로 제한됩니다.

아래는 예입니다. 출력이 예쁜 형식과 일치하지 않아도되지만 ()행렬 의 행 ( )을 순서대로 출력해야합니다 .

오름차순 :

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

Dennis 는 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 바이트

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도 회전시킨 다음 행렬을 올바른 방향으로 회전시킵니다.

줄리아, 64 44 바이트

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

계수의 벡터를 오름차순으로받습니다.

언 골프 드 :

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

온라인으로 사용해보십시오

Glen O 덕분에 20 바이트를 절약했습니다!

R, 71 59 바이트

오름차순으로 입력을받습니다.

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

언 골프 드 :

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

_{하이 파이브, 줄리아!}

파이썬 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)

계수 목록을 내림차순으로 가져와 먼저 스테이 빙 및 대화로 알려진 컴패니언 매트릭스의 조옮김을 만듭니다. 리턴은 zip을 사용하여이 전치의 전치를 생성하여 실제 행렬을 얻습니다.

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

자바 스크립트 (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)⁻¹

오름차순으로 입력을받습니다. TI-BASIC은 빈 행렬이나 목록을 지원하지 않기 때문에이 차수가 2보다 작은 다항식에는 작동하지 않습니다. OP의 판결을 보류하면서 몇 바이트의 비용으로이를 해결할 수 있습니다.

먼저, ∟X마지막 요소를 나중에 사용하기 위해 목록을 저장합니다 . 그런 다음 ΔList(Ans-cumSum(Ans))마지막 요소가 잘린 상태에서 제외 된 목록 인을 계산 하고이를 열 벡터로 변환합니다. List▶matr(수정하지 않기 때문에 Ans다음 행을 사용하여 목록의 차원을 취할 수 있습니다. TI-BASIC에는 수직 연결이 없으므로 조옮김과 수평 연결이 필요합니다. 마지막 줄에서는 [A]/∟X(Ans행렬에 스칼라를 곱할 수 있지만 나눌 수 없기 때문에 작동하지 않습니다.

따로 : 0으로 구성된 행 벡터를 생성하기 위해 거의 유용하지 않은 이점을 활용합니다. randM( 명령을 사용 . randM(임의의 행렬을 생성하지만 항목은 항상 -9와 9 (!) 사이의 임의의 정수이므로 0 행렬을 만드는 것만 유용합니다.

파리 / GP , 49 바이트

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

온라인으로 사용해보십시오!