क्या यह एक स्टोकेस्टिक मैट्रिक्स है?

Question

एक स्टोकेस्टिक मैट्रिक्स मार्कोव श्रृंखला के संदर्भ में उपयोग की जाने वाली संभावनाओं का एक मैट्रिक्स है।

एक सही स्टोचैस्टिक मैट्रिक्स एक मैट्रिक्स है जहां प्रत्येक पंक्ति के लिए रकम होती है 1।

एक बायां स्टोकेस्टिक मैट्रिक्स एक मैट्रिक्स है जहां प्रत्येक कॉलम को कहा जाता है 1।

एक दोगुना स्टोचस्टिक मैट्रिक्स एक मैट्रिक्स है जहां प्रत्येक पंक्ति और प्रत्येक कॉलम के लिए गाया जाता है 1।

इस चुनौती में, हम पूर्णांक का उपयोग करके प्रतिशत में संभावनाओं का प्रतिनिधित्व करेंगे । एक पंक्ति या कॉलम उस मामले में होना चाहिए 100और नहीं 1।

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

इनपुट

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

इनपुट मैट्रिक्स हमेशा चौकोर होगा और इसमें केवल गैर-नकारात्मक पूर्णांक होंगे। इनपुट मैट्रिक्स हमेशा कम से कम होगी 1×1।

आप STDINफ़ंक्शन तर्क, या समान कुछ के रूप में इनपुट का उपयोग कर सकते हैं ।

उत्पादन

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

संक्षेप में, चार संभावित मामलों में आपके आउटपुट के बीच 1 से 1 का पत्राचार होना चाहिए। उन चार outputs के कुछ उदाहरण होगा {1, 2, 3, 4}या {[1,0], [0,1], [1,1], [0,0]}या यहाँ तक कि {right, left, doubly, none}।

कृपया अपने उत्तर में इंगित करें कि आपके प्रोग्राम द्वारा उपयोग किए जाने वाले चार आउटपुट।

यदि एक मैट्रिक्स दोगुना स्टोचस्टिक है, तो आपको दोगुना स्टोचस्टिक के अनुरूप आउटपुट वापस करना होगा, और दाएं या बाएं स्टोचस्टिक नहीं।

आप आउटपुट को प्रिंट कर सकते हैं STDOUT, इसे किसी फ़ंक्शन या किसी समान से वापस कर सकते हैं।

परीक्षण के मामलों

[100]               => Doubly stochastic

[42]                => None of those

[100  0  ]          => Doubly stochastic
[0    100]

[4   8   15]
[16  23  42]        => Left stochastic
[80  69  43]

[99  1 ]            => Right stochastic
[2   98]

[1   2   3   4 ]
[5   6   7   8 ]    => None of those
[9   10  11  12]
[13  14  15  16]

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

Comments

क्या मैं पहले मैट्रिक्स के आकार का निर्धारण करने वाला इनपुट ले सकता हूं?

— हाइपरएन्यूट्रीनो

@AlexL। नहीं, इस बिंदु पर चश्मा बदलना अनुचित होगा।

— घातक

Answer 1

05AB1E , 13 11 10 बाइट्स

सही स्टोचैस्टिक: [0,1]
लेफ्ट स्टोचैस्टिक: [1,0]
डब स्टोचस्टिक: [1,1]
उनमें से कोई नहीं: [0,0]

Dø2FOTnQPˆ

इसे ऑनलाइन आज़माएं!

व्याख्या

D            # duplicate input
 ø           # transpose the copy
  2F         # 2 times do (once for each matrix)
    O        # sum of the rows
     TnQ     # is equal to 100
        P    # product
         ˆ   # add to global list
             # implicitly print global list at the end of the program

Answer 2

हास्केल, 57 55 बाइट्स

import Data.List
s a=all((==100).sum)<$>[transpose a,a]

प्रकार का इनपुट (Eq a, Num a) => [[a]]। आउटपुट बूलियन सूची[left-stochastic, right-stochastic]

2 बाइट बचाने के लिए @proudhaskeller को धन्यवाद

Comments

क्या आप फंक्शन को पॉइंटफ्री बनाकर कुछ बाइट्स नहीं बचा सकते हैं? उदाहरण के साथ [transpose,id]<*>(तब आप s a=जितने भी विषम कार्यों की अनुमति दे सकते हैं)

— त्रुटिपूर्ण

@flawr संभवतः, लेकिन [transpose,id]<*>का एक प्रकार है [[[a]]]->[[[a]]], जो की एक और परत की जरूरत है mapऔर एक pure/ return/ (:[])या एक प्रकार के इनपुट [[[इंट]]], जो प्राकृतिक नहीं है। सर्वश्रेष्ठ मुझे मिला हैmap(all(==100).map sum).(<$>[transpose,id]).flip id

— एंग्स

आह ठीक है, स्पष्टीकरण के लिए धन्यवाद!

— दोष

कैसे के all((==100).sum)बजाय के बारे में all(==100).map sum?

— गर्वित हैकेलर

@proudhaskeller का जरूर! allअपने आप में एक मानचित्रण करता है।

— Angs

Answer 3

आर, 55 बाइट्स

function(m)c(all(colSums(m)==100),all(rowSums(m)==100))

कहाँ कार्य करते हैं m को आर-मैट्रिक्स माना जाता है।

आउटपुट:

• [1] TRUE FALSE: बायां स्टोकेस्टिक
• [1] FALSE TRUE: सही स्टोकेस्टिक
• [1] TRUE TRUE: निस्संदेह
• [1] FALSE FALSE: कोई नहीं

Comments

any(colSums(m)-100)और इसी तरह rowSumsआप सभी आउटपुट को प्राप्त करते हुए आपको दो बाइट छोड़ देंगे, इसलिए यदि आप उन्हें रखना चाहते हैं, तो आप !नेट -1बाइट के लिए हमेशा सामने रख सकते हैं ।

— Giuseppe

Answer 4

ऑक्टेव, 35 34 32 31 बाइट्स

@(n)any([sum(n);sum(n')]-100,2)

इसे इस तरह से कॉल करें:

f(100)
f(42)
f([4,8,15; 16,23,42; 80,69,43])
f([99,1;2,98])
f([1,2,3,4;5,6,7,8;9,10,11,12;13,14,15,16])

इसका परीक्षण यहां करें।

शुरू में दोष के लिए 2 बाइट्स बचाए गए, लेकिन एक और दृष्टिकोण के लिए चला गया जो 1 बाइट छोटा था।

यह विभिन्न मामलों के लिए निम्न आउटपुट देता है:

0    Doubly
0    

1    None
1

0    Left
1

1    Right
0

,2यदि एक अंक को शामिल नहीं किया गया तो अंतिम अनावश्यक होगा। इसके अलावा, अगर इसके 1बजाय 100(जैसा कि यह हो सकता है), यह एक और 4बाइट्स को बचाएगा ।

Answer 5

गणितज्ञ 29 बाइट्स

{}⋃Tr/@#=={100}&/@{#,#}&

 = U + F3C7 = [\ Transpose] वर्ण को प्रतिस्थापित करना। यह कोड स्निपेट सही तरीके से मैथेमेटिका में पेस्ट करेगा।

आउटपुट के रूप में {lefttruth, righttruth} के साथ समान सत्यता सम्मेलन

Comments

{}⋃एक बाइट बचाता हैUnion@

— एक सिमंस

@ASimmons, टिप के लिए धन्यवाद! इसे रखो और मेरे बाइट कुल में एक त्रुटि को ठीक किया।

— केली लोल्डर

इसके अलावा, मुझे लगता है कि अगर आप अपना आउटपुट {राइटट्रूथ, लेफ्टट्रुथ} बनाते हैं, तो उसके Total@साथ रिप्लेस करने पर Tr/@आगे के 2 बाइट्स बचेंगे।

— एक सीमन्स

या समतुल्य रूप से दो मैट्रिक्स को उलट दें ताकि समाधान बन जाए{}⋃Tr/@#=={100}&/@{#,#}&

— ए सिमंस

@ASimmons, हाँ, कि एक और बचाया 2. धन्यवाद!

— केली लोडर

Answer 6

k, 21 19 बाइट्स

{min'100=+/'(x;+x)}

उत्पादन

• 00b कोई नहीं
• 10b बाएं
• 01b सही
• 11b दोनों

उदाहरण:

k)f:{min'100=+/'(x;+x)} //store function as f
k)f(100 0;98 2)
01b

संपादित करें: बाइट काउंट को 3 से कम करें - फ़ंक्शन को लंबोदर में संलग्न करने की आवश्यकता नहीं है

संपादित करें: bytecount को 2 से कम करें - H / T @Simon प्रमुख

Comments

आप वास्तव में एक मेमने में संलग्न करके एक बाइट बचा सकते हैं: {min'100 = + / '(x; +: x)}

— साइमन मेजर

Answer 7

MATL , 12 बाइट्स

sG!sv!100=XA

आउटपुट दो शून्य / एक मान है। पहला इंगित करता है कि क्या मैट्रिक्स बाएं-स्टोचस्टिक है, दूसरा अगर यह सही-स्टोचस्टिक है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

s      % Implicitly input N×N matrix. Sum of each column. Gives a 1×N vector
G!     % Push input transposed
s      % Sum of each column. Gives a 1×N vector
v      % Concatenate vertically. Gives a 2×N matrix
!      % Transpose. N×2
100=   % Does each entry equal 100?
XA     % True for columns that contain only "true". Gives 1×2 vector. Implicitly display

Comments

यार कि 100 महंगे थे, अच्छा जवाब।

— मैजिक ऑक्टोपस Urn

Answer 8

मैथेमेटिका, 46 43 बाइट्स

AllTrue[#==100&]/@Apply[Plus,{#,#},{1}]&

अन्य उत्तरों के साथ, आउटपुट हैं

{False, False} गैर-स्टोकेस्टिक के लिए

{True, False} बाएं-स्टोचैस्टिक के लिए

{False, True} दाएं-स्टोकेस्टिक के लिए

{True, True} डबल स्टोकेस्टिक के लिए

के ऑपरेटर रूप में स्विच करके 3 बाइट्स सहेजे गए AllTrue

Comments

U + F3C7 (निजी उपयोग) के लिए\[Transpose]

— u54112

मैंने इस पर विचार किया, लेकिन सोचा कि यह �ज्ञानवर्धक था

— ए सिमंस

इसके अलावा @अंत में एक अतिरिक्त है

— u54112

Answer 9

PHP, 104 बाइट्स

function($a){for($s=array_sum;$a[+$i];)$o|=$s($a[+$i])!=100|($s(array_column($a,+$i++))!=100)*2;echo$o;}

एक अनाम फ़ंक्शन जो इकोस 0 => दोनों, 1 => बाएं, 2 => दाएं, 3 => दोनों नहीं है।
उपयोग की तरह:

php -r "$c=function($a){for($s=array_sum;$a[+$i];)$o|=$s($a[+$i])!=100|($s(array_column($a,+$i++))!=100)*2;echo$o;};$c(json_decode($argv[1]));" "[[4,8,15],[16,23,42],[80,69,43]]"

114 बाइट्स पर एक कमांड लाइन प्रोग्राम संस्करण:

for($a=json_decode($argv[1]);$a[+$i];)$o|=($s=array_sum)($a[+$i])!=100|($s(array_column($a,+$i++))!=100)*2;echo$o;

जैसे इस्तेमाल किया:

 php -r "for($a=json_decode($argv[1]);$a[+$i];)$o|=($s=array_sum)($a[+$i])!=100|($s(array_column($a,+$i++))!=100)*2;echo$o;" "[[4,8,15],[16,23,42],[80,69,43]]"

Answer 10

पायथन 2, 70 64 बाइट्स

यहाँ कुछ भी पागल नहीं, बस अंदर बहकने का उपयोग कर रहा है zip मैट्रिक्स को स्थानांतरित करने के लिए कर रहे हैं :) आउटपुट इस प्रकार हैं:

0 - not stochastic
1 - right stochastic
2 - left stochastic
3 - doubly stochastic

और यहाँ कोड है :)

k=lambda m:all(sum(x)==100for x in m)
lambda n:k(n)+2*k(zip(*n))

Comments

क्या स्टार इन (* ना गलती है?

— hhh

@ नहीं, वह splatऑपरेटर है: अनिवार्य रूप से वह है जो मुझे मैट्रिक्स को स्थानांतरित करने दे रहा है :)

— Kade

Answer 11

सी #, 205 203 183 बाइट्स

golfed:

int F(int[,]m){int x,i,j,r,c,e,w;x=m.GetLength(0);e=w=1;for(i=0;i<x;i++){r=c=0;for(j=0;j<x;j++){r+=m[i,j];c+=m[j,i];}if(r!=100)e=0;if(c!=100)w=0;}return e==1&&w==1?3:e==1?1:w==1?2:4;}

टिप्पणियों के साथ अपुष्ट:

    int F(int[,] m)
    {
        //x - matrix size
        //i, j - loop control variables
        //r, c - row/column sum
        //e, w - east/west, pseudo-bool values indicate right/left stochastic
        int x, i, j, r, c, e, w;
        x = m.GetLength(0);
        e = w = 1;

        for (i = 0; i < x; i++)
        {
            r = c = 0;

            for (j = 0; j < x; j++)
            {
                r += m[i, j];
                c += m[j, i];
            }

            if (r != 100)
                e = 0;

            if (c != 100)
                w = 0;
        }

        return e == 1 && w == 1 ? 3 : e == 1 ? 1 : w == 1 ? 2 : 4;
    }

आउटपुट कुंजी: 1 - दाएं स्टोचस्टिक 2 - बायां स्टोचस्टिक 3 - डबल स्टोचस्टिक 4 - कोई नहीं

इसे आज़माएं: http://rextester.com/PKYS11433

EDIT1: r=0;c=0;=>r=c=0;

EDIT2: नेस्टर्ड टर्नरी ऑपरेटर। क्रेडिट्स @Yodle को जाता है।

Comments

if(e==1&&w==1)return 3;if(e==1)return 1;return w==1?2:4;के बाद से eऔर wकेवल 1 या 0 हो सकता है, यह करने के लिए बदला जा सकता है return w<<1|e;और फिर से परिभाषित कोई भी == 0।

— लिंक एनजी

यदि आप उन कुछ ifबयानों को टर्नरी संचालन में बदल देते हैं और अंत में पूर्णांक लौटाते हैं, तो आप उन्हें 30 से छोटा कर सकते हैं । Idunno अगर मैं अपने समाधान पोस्ट करना चाहिए क्योंकि यह बहुत समान है।

— योडल

@LinkNg बहुत अच्छा। मैं बिना समझे कोड लिखना नहीं चाहता। मैं बाइनरी ऑपरेटरों से परिचित नहीं हूं।

— 19

@Yodle धन्यवाद, मैंने अपना समाधान बदल दिया। यह बहुत समान है, भले ही अपना पोस्ट करने के लिए स्वतंत्र महसूस करें।

— 19

Answer 12

जावास्क्रिप्ट (ईएस 6), 83 बाइट्स

a=>[a.some(a=>a.reduce((l,r)=>l-r,100)),a.some((_,i)=>a.reduce((l,a)=>l-a[i],100))]

बस इसके विपरीत, न केवल यह आउटपुट बाईं ओर दाएं स्टॉकिस्टिक परिणाम करता है, बल्कि बुलियन भी उलटा होता है, इसलिए [false, true]अभी भी आउटपुट का अर्थ सही स्टोकिस्टिक है।

Answer 13

सी # 6, 130 बाइट्स

using System.Linq;bool[]F(int[][]a)=>new[]{a.Where((_,i)=>a.Select(x=>x[i]).Sum()==100).Count()==a.Length,a.All(x=>x.Sum()==100)};

{False, False}
{True, False}बाएं-स्टोचस्टिक के लिए गैर-स्टोचस्टिक के लिए
{False, True} लिए दाएं-स्टोचस्टिक के
{True, True}लिए दोगुना स्टोचस्टिक के लिए

repl.it डेमो

Ungolfed

bool[]F(int[][]a)=>
    // Return new array of two bools. Array type is inferred from arguments
    new[]
    {
        // Left:
        // Count the no. of columns which sums up to 100
        a.Where((_,i)=>a.Select(x=>x[i]).Sum()==100).Count()
            // Then check if no. of such columns equal to total column count
            ==a.Length,
        // Right: Do all rows sum up to 100?
        // Can't use this trick for left because no overload of All() accept Func<TSource,int,bool> like Where() does
        a.All(x=>x.Sum()==100)
    };

Answer 14

ग्रूवी, 57

{a={it.every{it.sum()==100}};[a(it),a(it.transpose())]}​

उत्पादन

[0,0] यदि नहीं।

[1,0] अगर सही है।

[0,1] अगर छोड़ दिया।

[1,1] अगर दोनों।

Answer 15

रंज , 17 बाइट्स

एक अप्रत्याशित मोड़ में, यह सबमिशन एक फ़ंक्शन है।

{[h]=UQ$+_M[Zaa]}

दो 0/ 1मूल्यों की सूची लौटाता है : [0 0]= स्टोचस्टिक नहीं, [0 1]= बाएं स्टोचस्टिक, [1 0]= राइट स्टोचैस्टिक, [1 1]= डबल स्टोकेस्टिक।इसे ऑनलाइन आज़माएं!

व्याख्या

{               }  A function:
              a    Function argument (nested list)
           [Za ]   Create a list containing a's transpose and a
          M        Map this function to each of the above:
       $+_           Sum down the columns
     UQ              Get unique elements
 [h]=                If stochastic, the result should be [100]

Answer 16

दिल्लोग एपीएल , 16 बाइट्स

{∧/100=+/↑⍵(⍉⍵)}

{ } प्रत्यक्ष फ़ंक्शन परिभाषा (उर्फ "dfn"), ⍵ तर्क है

⍵(⍉⍵) मैट्रिक्स इसके ट्रांसपोज़ेशन के साथ है

↑ उन्हें एक एकल 2 × n × n सरणी में मिलाएं

+/ अंतिम अक्ष के साथ, 2 × n मैट्रिक्स प्राप्त करें

100= कौन से तत्व 100 हैं (बूलियन 0 1 हैं)

∧/ अंतिम अक्ष के साथ "और" कटौती, बाएं, दाएं स्टोचस्टिक के लिए 2 बूलियन प्राप्त करें

Answer 17

सी ++ 14, 139 136 133 130 बाइट्स

-3 बाइट्स के लिए s=M.size(), -3 बाइट्स संदर्भ पैरामीटर द्वारा लौटने के लिए, -3 बाइट्स एक अनाम लैम्ब्डा के रूप में

[](auto M,int&r){int a,b,i,j,s=M.size();r=3;for(i=-1;++i<s;){for(j=-1,a=b=0;++j<s;a+=M[i][j],b+=M[j][i]);r&=(a==100)+2*(b==100);}}

इनपुट को पसंद करता है vector<vector<int>> । दोगुने, बाएं, दाएं, कोई भी स्टोकेस्टिक के लिए 3,2,1,0 रिटर्न।

Ungolfed:

auto f=
[](auto M, int& r){
  int a,b,i,j,s=M.size();
  r=3;
  for(i=-1;++i<s;){
    for(j=-1,a=b=0;++j<s;
      a+=M[i][j],
      b+=M[j][i]);
    r&=(a==100)+2*(b==100);
  }
}
;