Bir stokastik matris Markov zincirlerinin bağlamında kullanılan olasılıkların matrisidir.

Bir doğru stokastik matris her sıra toplamı bir matristir 1.

Bir sol stokastik matris, her sütun toplamları bir matristir 1.

İki kat rasgele bir matris, her satırın ve her sütunun toplandığı bir matristir 1.

Bu mücadelede, tamsayıları kullanma olasılığını yüzde olarak temsil edeceğiz . Bir satır veya sütun bu durumda toplamalı 100ve toplamalı olmalıdır 1.

Amacınız , girdi olarak kare bir tamsayı matrisi verildiğinde, matrisin ya sağ stokastik, sol stokastik, iki kat stokastik ya da bunlardan hiçbirinin olmadığını gösteren dört değerden birini veren bir program ya da fonksiyon yazmaktır.

Giriş

Giriş için kendi diliniz için doğal olan bir matrisin herhangi bir uygun gösterimini kullanabilirsiniz. Örneğin, bir listeler listesi, bir virgül dizesi, satırları çizgilerle ayrılmış vb.

Giriş matrisi her zaman kare olacak ve yalnızca negatif olmayan tam sayılar içerecektir. Giriş matrisi her zaman en azından olacaktır 1×1.

STDINBir işlev argümanı veya benzer bir şey kullanarak girişi iletebilirsiniz .

Çıktı

Sağ stokastik , sol stokastik , iki kat stokastik veya bunlardan hiçbirine karşılık gelen dört farklı çıktı seçmelisiniz . Bu çıktılar, hangi girişin geçtiğinden bağımsız olarak sabit olmalıdır. Programınız aynı durum için farklı çıktılar döndürmeyebilir, örneğin, herhangi bir olumsuz sayının bunların hiçbirine karşılık gelmediğini söylemek.

Kısacası, çıktınızla dört olası dava arasında bire bir yazışma olmalıdır. Bu dört çıkış bazı örnekleri olacaktır {1, 2, 3, 4}ya da {[1,0], [0,1], [1,1], [0,0]}hatta {right, left, doubly, none}.

Lütfen cevabınızda programınızın kullandığı dört çıktıyı belirtin.

Eğer bir matris iki kat stokastik ise, o zaman iki kat stokastik karşılık gelen çıktısını iade etmelisiniz, sağ veya sol stokastik değil.

Çıktıyı STDOUTbir işlevden veya benzer bir şeyden geri almak için yazdırabilirsiniz .

Test durumları

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

puanlama

Bu kod golf , yani bayt cinsinden en kısa cevap kazanır.

05AB1E , 13 11 10 bayt

Stokastik sağ: [0,1]
Stokastik sağ : [1,0]
İki kat stokastik: [1,1]
Bunlardan hiçbiri: [0,0]

Dø2FOTnQPˆ

Çevrimiçi deneyin!

açıklama

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

Haskell, 57 55 bayt

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

Çeşidi Girdi (Eq a, Num a) => [[a]]. Boole listesini çıkarır[left-stochastic, right-stochastic]

2 byte tasarruf için @proudhaskeller teşekkürler

R, 55 bayt

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

mBir R-matrisi olduğu varsayılan adsız işlev .

Çıktı:

• [1] TRUE FALSESol stokastik
• [1] FALSE TRUESağ stokastik
• [1] TRUE TRUE: İki kat
• [1] FALSE FALSE: Yok

Octave, 35 34 32 31 bayt

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

Buna şöyle diyoruz:

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

Burada test et.

Başlangıçta kusur sayesinde 2 bayt kurtarıldı, ancak 1 bayt daha kısa olan başka bir yaklaşıma gitti.

Bu, farklı durumlar için aşağıdakileri verir:

0    Doubly
0    

1    None
1

0    Left
1

1    Right
0

,2Tek basamak dahil edilmemişse, sonuncusu gereksiz olacaktır. Ayrıca, 1bunun 100(toplayabileceği şekilde) yerine toplanması durumunda , başka bir 4bayt kurtarır .

Mathematica 29 Bayt

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

 = U + F3C7 = [\ Transpose] karakterinin değiştirilmesi. Bu kod pasajı, Mathematica'ya doğru şekilde yapıştırılacak.

Çıktı olarak {lefttruth, righttruth} ile aynı doğruluk sözleşmesi

k, 21 19 bayt

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

Çıktı

• 00b Yok
• 10b ayrıldı
• 01b sağ
• 11b her ikisi de

Örnek:

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

düzenleme: bayt sayısını 3 ile azaltır - bir lambda içine alınmış olması gerekmez

düzenleme: 2 bytecount azaltmak - H / T @Simon Major

MATL , 12 bayt

sG!sv!100=XA

Çıktı iki sıfır / bir değerdir. Birincisi, matrisin sol-stokastik olup olmadığını, ikincisi ise sağ-stokastik olup olmadığını gösterir.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın

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

Mathematica, 46 43 bayt

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

Diğer cevaplarda olduğu gibi çıktılar

{False, False} stokastik olmayanlar için

{True, False} sol-stokastik için

{False, True} sağ-stokastik için

{True, True} iki kere Stokastik için

Operatör biçimine geçerek 3 bayt kurtarıldı AllTrue

PHP, 104 bayt

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

0 => her ikisini de ekleyen anonim bir işlev, 1 => sol, 2 => sağ, 3 => hiçbiri.
Gibi kullanın:

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 baytlık bir komut satırı programı sürümü:

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

Gibi kullanılır:

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

Python 2, 70 64 Bayt

Burada çılgınca bir şey yok, sadece zipmatrisi devretmek için sıçramaktan faydalanmak :)

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

Ve işte kod :)

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

C #, 205 203 183 bayt

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

Yorumsuz Ungolfed:

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

Çıkış anahtarı: 1 - sağ stokastik 2 - sol stokastik 3 - çift stokastik 4 - yok

Deneyin: http://rextester.com/PKYS11433

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

EDIT2: İç içe üçlü operatörler. Krediler @Yodle'a gidiyor.

JavaScript (ES6), 83 bayt

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

Tam tersine, bu çıktı yalnızca soldaki sağ stoachistik sonucu ortaya çıkarmakla kalmaz, aynı zamanda [false, true]boolanlar da ters çevrilir, bu nedenle hala bir sağ çıktı, stoachistik anlamına gelir.

C # 6, 130 bayt

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}stochastic olmayanlar
{True, False}için sol stochastic
{False, True}için sağ stochasticler
{True, True}için iki kat stochastic için

repl.it demo

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)
    };

Harika, 57

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

Çıktı

[0,0] eğer değilse.

[1,0] eğer doğru.

[0,1] eğer kaldıysa

[1,1] ikisi de olursa.

Pip , 17 bayt

Beklenmeyen bir bükümde bu gönderme bir fonksiyondur.

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

İki 0/ 1değerin bir listesini döndürür : [0 0]= stokastik değil, [0 1]= sol stokastik, [1 0]= sağ stokastik, [1 1]= iki kat stokastik. Çevrimiçi deneyin!

açıklama

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

Dyalog APL , 16 bayt

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

{ }direkt fonksiyon tanımı (aka "dfn"), ⍵bağımsız değişkendir

⍵(⍉⍵) aktarımının yanı sıra matris

↑ tek bir 2 × n × n dizisine karıştırın

+/ Son eksen boyunca toplam, 2 × n matris elde et

100= hangi elementler 100 (boolean'lar 0 1)

∧/ Son eksen boyunca "ve" -düksiyon, sol, sağ stokastik için 2 boolean olsun

C ++ 14, 139 136 133 130 bayt

İçin -3 bayt s=M.size(), referans parametresiyle geri dönmek için -3 bayt, adlandırılmamış bir lambda olarak -3 bayt

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

Bunun gibi bir girdi olduğunu varsayar vector<vector<int>>. İki kat, sol, sağ, stokastik olmayanlar için 3,2,1,0 döndürür.

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);
  }
}
;