সহযোগী ম্যাট্রিক্স তৈরি করুন

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)

নোট করুন যেটির সহগটি x^n1। অন্য যে কোনও মানের জন্য, সহগের সমস্ত বাকী ভাগ করে নিন x^n। অতিরিক্তভাবে, 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>\.+}

এটি এমন একটি ফাংশন যা স্ট্যাক থেকে ইনপুট (আরোহণের ক্রম) পপ করে এবং বিনিময়ে আউটপুটটিকে ধাক্কা দেয়।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

)   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

সিজেম, 32 31 28 বাইট

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

এটি অনলাইনে চেষ্টা করুন

এটি সিজেএম তালিকা ফর্ম্যাটটি ব্যবহার করে আরোহণের ক্রমে ইনপুট নেয়। নমুনা ইনপুট:

[-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(''));

— 415 এ lirtosiast

@ থমাসকওয়া ধন্যবাদ! তবে, এটি মাতলাবে বৈধ সিনট্যাক্স নয়। 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

জাভাস্ক্রিপ্ট (ES6) 85

উর্দ্ধক্রমানুসারে.

যে কোনও ইকামাস্ক্রিপ্ট 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 ডিগ্রির বহুবর্ষের জন্য কাজ করবে না, কারণ টিআই-বেসিক খালি ম্যাট্রিক বা তালিকাকে সমর্থন করে না। ওপি থেকে কোনও রায় মুলতুবি রেখেছি, কয়েক বাইটের দামে আমি এটি ঠিক করতে পারি।

প্রথমত, আমরা ∟Xশেষ উপাদানটি পরে ব্যবহার করতে তালিকাটি সঞ্চয় করি ; তারপরে, আমরা গণনা করি ΔList(Ans-cumSum(Ans)), যা কেবলমাত্র অবহেলিত তালিকার শেষ উপাদানটি কেটে ফেলা হয়েছে এবং এটি একটি কলাম ভেক্টরে রূপান্তরিত করে। যেহেতু List▶matr(সংশোধন করা হয়নি Ans, তাই আমরা পরবর্তী লাইনটি তালিকার মাত্রা নিতে ব্যবহার করতে পারি, যা আমরা তিনবার ব্যবহার করি। টিআই-বেসিকের উল্লম্ব সংমিশ্রণ নেই, সুতরাং আমাদের ট্রান্সপোসগুলি এবং অনুভূমিকভাবে সংক্ষিপ্ত করে তোলা দরকার। শেষ লাইনে, [A]/∟X(Ansকাজ করবে না কারণ ম্যাট্রিকগুলি স্কেলার দ্বারা গুণিত হতে পারে তবে ভাগ হয় না।

একপাশে: জিরোসের সারি ভেক্টর তৈরি করতে আমরা খুব কমই দরকারী randM(কমান্ডের সুবিধা গ্রহণ করি । randM(একটি এলোমেলো ম্যাট্রিক্স তৈরি করে তবে এর এন্ট্রিগুলি সর্বদা -9 এবং 9 (!) এর মধ্যে এলোমেলো পূর্ণসংখ্যার হয়, সুতরাং এটি শূন্য ম্যাট্রিক্স তৈরি করতে সত্যই কার্যকর।

Answer 12

পরীর / জিপি , 49 বাইট

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

এটি অনলাইন চেষ্টা করুন!