रैखिक समीकरणों की एक प्रणाली को हल करें

12

यथासंभव कम से कम रैखिक समीकरणों की एक श्रृंखला को हल करने के लिए एक कार्यक्रम लिखें। यह समीकरण समस्याओं की मनमानी संख्या को हल करना चाहिए। हालांकि वे आपको पसंद कर सकते हैं, संवर्धित मैट्रिक्स के गुणांक शायद सबसे आसान हैं। कार्यक्रम को गैर-पूर्णांक गुणांक या समाधान को संभालने की आवश्यकता नहीं है। किसी भी पतित या अमान्य मामलों का परीक्षण नहीं किया जाएगा। कार्यक्रम को प्रत्येक चर या कम रो इकोलोन फॉर्म के मूल्य को आउटपुट करना होगा।

पुस्तकालयों, मैट्रिक्स कार्यों या स्वचालित रूप से हल करने के लिए किसी भी तरह से हल करने की कोई अनुमति नहीं है। आप सरणियों या सूचियों के साथ मैट्रिसेस का अनुकरण कर सकते हैं।

उदाहरण इनपुट (या समतुल्य):

m={{2,1,-1,8},{-3,-1,2,-11},{-2,1,2,-3}}

यह प्रतिनिधित्व करता है 2x+y-z=8, -3x-y+2z=-11, -2x+y+2z=-3

उदाहरण आउटपुट (या समतुल्य):

{2,3,-1}

यह प्रतिनिधित्व करता है x=2, y=3, z=-1

code-golf  math 
— qwr
स्रोत
2
क्या चर के गुणांक और स्थिर शब्दों को इनपुट में दो सरणियों में अलग किया जा सकता है?
— user12205
@ace हाँ, यह ठीक है
— qwr
1
पतित मामलों द्वारा आप वास्तव में क्या कह रहे हैं? मुझे लगता है कि आप उन सभी मामलों का उल्लेख कर रहे हैं: 1) विकृत इनपुट; 2) चीजें जैसे 0x=0या 0x=5; 4) मामले जहां समीकरणों की संख्या चर की संख्या से अलग है; 5) विरोधाभासी मामले जैसे x+5y=7, x+5y=8; 6) रैखिक स्वतंत्रता के बिना मामले, जैसे x+3y=6, 2x+6y=12। क्या मैं सही हू?
— विक्टर स्टैफुसा
@ विक्टर हां, कोई भी इनपुट जिसमें कोई भी अस्पष्टता है या वह हल नहीं है।
— क्यूरॉ
उन मामलों के बारे में जो पतित नहीं हैं लेकिन बीमार हैं? (या, दूसरे शब्दों में, किस तरह की धुरी की आवश्यकता है?)
— पीटर टेलर

जवाबों:

3

अजगर 169 166

कार्यान्वयन

def s(a):
 if a:b=a[0];r=s([[x-1.*y*b[0]/r[0]for x,y in zip(b[1:],r[1:])]for r in a[1:]]);return[round((b[-1]-sum(x*y for x,y in zip(b[1:-1],r)))/b[0])]+r
 return[]

डेमो

>>> arr=[[2, 1, -1, 8], [-3, -1, 2, -11], [-2, 1, 2, -3]]
>>> s(arr)
[2.0, 3.0, -1.0]

ध्यान दें

यदि आप फ्लोट सन्निकटन के साथ ठीक हैं, तो आप गोल फ़ंक्शन कॉल और आगे के गोल्फ को 159 वर्णों तक हटा सकते हैं

— अभिजीत
स्रोत
9

एपीएल, 1 चार

मुझे पता है कि यह (संशोधित) आवश्यकताओं के अनुरूप नहीं है, लेकिन पोस्ट न करना बहुत अच्छा है:

⌹

प्रतीक "डोमिनोज़" ⌹(विभाजन)÷ एक आयत के अंदर ) मैट्रिक्स विभाजन करता है, इसलिए यह रैखिक समीकरणों की किसी भी प्रणाली को हल कर सकता है। आपको बस इसे लगातार शब्द वेक्टर और मैट्रिक्स के बीच अन्य शब्दों के साथ रखना होगा:

      8 ¯11 ¯3 ⌹ ⊃(2 1 ¯1)(¯3 ¯1 2)(¯2 1 2)
2 3 ¯1

(यदि आप इसे TryApl पर आज़माना चाहते हैं, ⊃तो ↑)

— Tobia
स्रोत
4

जावास्क्रिप्ट ( 284 181) - गॉस एलिमिनेशन विधि

function f(A){l=A.length;d=1;for(i=0;i+1;i+=d){v=A[i][i];for(k=0;k<l+1;k++)A[i][k]/=v;for(j=i+d;A[j];j+=d)for(k=0,w=A[j][i];k<l+1;k++)A[j][k]-=w*A[i][k];if(i==l-d)d=-1,i=l}return A}

परीक्षा

f([[2,1,-1,8],[-3,-1,2,-11],[-2,1,2,-3]]);

=> [[1,0,0,2],[0,1,0,3],[-0,-0,1,-1]]

लौटे सरणी पहचान मैट्रिक्स और समाधान को जोड़ती है।

— माइकल एम।
स्रोत
आप युगल को अधिक वर्ण सहेज सकते हैं।
— MarcinJuraszek
l=A.length;for(i=0;i<l;i++)उपयोग के बजाय for(i=0;i<l=A.length;i++)।
— विक्टर स्टैफुसा
for(i=l-1;i>=0;i--)उपयोग के बजाय for(i=l;--i;)।
— विक्टर स्टैफुसा
तुम भी चारों ओर ले w=A[j][i]जाने for()और छोड़ सकते हैं {}।
— MarcinJuraszek
सभी को धन्यवाद, मैं एक ही चरण में आगे और पीछे के कदमों को मिलाने में कामयाब रहा, एक सौ चार्ट की बचत की और आपके कुछ टिप्स अब मान्य नहीं हैं। (@MarcinJuraszek टिप को छोड़कर)
— माइकल एम।
3

यह उत्तर अब नियम में बदलाव के बाद किसी सवाल को फिट नहीं करता है क्योंकि यह मैट्रिक्स फ़ंक्शन का उपयोग करता है। *

साधु , ३२

~matrix(input())*vector(input())

नमूना इनपुट:

[[2, 1, -1], [-3, -1, 2], [-2, 1, 2]]
[8, -11, -3]

नमूना उत्पादन:

(2, 3, -1)

* यकीनन, matrix()एक टाइपकास्ट है, फ़ंक्शन नहीं (रनिंग import types; isinstance(matrix, types.FunctionType)देता है False)। इसके अलावा, ~और *कर रहे हैं ऑपरेटरों , नहीं काम करता है।

— user12205
स्रोत
मैंने नियम अपडेट किए हैं। कोड को समीकरणों की विभिन्न संख्या को संभालना होगा और अब आप मैट्रिक्स फ़ंक्शन का उपयोग नहीं कर सकते।
— क्वार
3

जावा - ५२२ ४३४ २२। 213 वर्ण

व्यवस्थित रूप से सभी संभावित पूर्णांक n-tuples को सीधा गुणा करके जाँचता है जब तक कि एक काम नहीं मिलता है।

फंक्शन संवर्धित मैट्रिक्स, ए, ट्रायल सॉल्यूशन वेक्टर, x और डायमेंशन, n, इनपुट के रूप में लेता है - सॉल्यूशन सॉल्यूशन वेक्टर, x। ध्यान दें कि वेक्टर x वास्तव में संभव समाधानों के माध्यम से कदम उठाने में मदद करने के आयाम से बड़ा है। (यदि मैंने वेरिएबल A, x, n, j, k, s को उदाहरण के चर के रूप में घोषित किया, तो फ़ंक्शन कुल 182 के लिए 31 चार्ट छोटा होगा - लेकिन ऐसा लगता है कि नियमों को बहुत दूर झुकाना पसंद है।)

int[]Z(int[][]A,int[]x,int n){int j,k,s;for(;;){for(j=0;j<n;j++){for(k=s=0;k<n;s+=A[j][k]*x[k++]);if(s!=A[j][n])j+=n;}if(j==n)return x;for(j=0;j<=n;j++)if(x[j]!=x[n]||j==n){x[j]++;for(k=0;k<j;x[k++]=-x[n]);j=n;}}}

परीक्षण के लिए कार्यक्रम (कुछ हद तक असंयमी):

import java.util.*;
class MatrixSolver{
    public MatrixSolver() {
        Scanner p=new Scanner(System.in); //initialize everything from stdin
        int j,k,n=p.nextInt(),A[][]=new int[n][n+1],x[]=new int[n+1];
        for(j=0;j<n;j++)for(k=0;k<=n;A[j][k++]=p.nextInt());
        x=Z(A,x,n); //call the magic function
        for(j=0;j<n;j++) System.out.print(x[j]+" "); //print the output
    }
    public static void main(String[]args){
        new MatrixSolver();
    } 

    int[]Z(int[][]A,int[]x,int n){
        int j,k,s;
        for(;;){
            for(j=0;j<n;j++){ //multiply each row of matrix by trial solution and check to see if it is correct
                for(k=s=0;k<n;s+=A[j][k]*x[k++]);
                if(s!=A[j][n])j+=n;
            }
            if(j==n)return x; //if it is correct return the trial solution
            for(j=0;j<=n;j++)if(x[j]!=x[n]||j==n){//calculate the next trial solution
                x[j]++;
                for(k=0;k<j;x[k++]=-x[n]);
                j=n;
            }
        }
    }
}

कार्यक्रम स्टड से इनपुट लेता है क्योंकि अंतरिक्ष अलग पूर्णांक निम्नानुसार है: पहला, समस्या का आयाम, दूसरा, पंक्ति के साथ संवर्धित मैट्रिक्स की प्रविष्टियां।

नमूना रन:

$java -jar MatrixSolver.jar
3 2 1 -1 8 -3 -1 2 -11 -2 1 2 -3
2 3 -1

मैंने छोरों और "जनता" के बारे में विक्टर की सलाह का पालन करते हुए कई पात्रों का मुंडन किया, अलग-अलग के बजाय संवर्धित मैट्रिक्स में आरएचएस का भंडारण किया, और प्रत्येक नए परीक्षण समाधान की पीढ़ी को सरल बनाने के लिए मेरे परीक्षण समाधान में एक अतिरिक्त प्रविष्टि जोड़ दी। ओपी ने यह भी कहा कि एक फ़ंक्शन पर्याप्त है - पूरे कार्यक्रम को गिनने की आवश्यकता नहीं है।

— वैली
स्रोत
while(true){f=0;for(j=0;j<n;j++)द्वारा प्रतिस्थापित किया जा सकता है while(true){for(f=j=0;j<n;j++)। इसके अलावा आपकी कक्षा को सार्वजनिक होने की आवश्यकता नहीं है। शरीर में केवल एक निर्देश के साथ लूप के लिए घुंघराले ब्रेस की आवश्यकता नहीं है।
— विक्टर स्टैफुसा
मुझे लगता है कि for(j=0;j<n;j++){for(k=0;k<n;k++){A[j][k]=p.nextInt();}b[j]=p.nextInt();}इसके द्वारा प्रतिस्थापित किया जा सकता हैfor(j=0;j<n;b[j++]=p.nextInt())for(k=0;k<n;)A[j][k++]=p.nextInt();
— विक्टर स्टैफुसा
@ विक्टर धन्यवाद, मैंने उन लोगों को, और अन्य, परिवर्तन किए।
— वैली
while(true)बदला जा सकता हैfor(;;)
— user12205
@ace धन्यवाद - कि और एक जोड़ी अन्य चीजों को बदल दिया और 15 वर्णों का मुंडन किया।
— वल्ली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.