甲随机矩阵是马尔可夫链的上下文中使用的概率的矩阵。

甲右随机矩阵是矩阵，其中每一行款项1。

一种 左随机矩阵是其中，每个列总和到1。

一种 双随机矩阵是一个矩阵，其中每行和每列总和到1。

在这个挑战中，我们将使用整数以百分比表示概率。在这种情况下，行或列的总和必须为100不是1。

您的目标是编写一个程序或函数，给定一个整数平方的矩阵作为输入，该程序或函数将输出四个值之一，这些值指示该矩阵是右随机，左随机，双随机或全不随机。

输入项

您可以使用对您的语言自然的矩阵的任何适当表示形式作为输入。例如，列表列表，用逗号分隔的值的字符串和用换行符分隔的行等。

输入矩阵将始终为正方形，并且仅包含非负整数。输入矩阵将始终至少为1×1。

您可以使用STDIN，作为函数参数或类似的参数传递输入。

输出量

您必须选择四个不同的输出，分别对应于右随机，左随机，双随机或全部都不输出。不管传递什么输入，这些输出必须是恒定的。对于相同的情况，您的程序可能不会返回不同的输出，例如，说任何负数对应于所有无效的输出。

简而言之，您的输出与四种可能的情况之间必须存在1对1的对应关系。这四个输出的一些示例为{1, 2, 3, 4}or {[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]

计分

这是代码高尔夫球，因此最短的答案以字节为单位。

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

Haskell，57 55字节

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

输入类型(Eq a, Num a) => [[a]]。输出布尔值列表[left-stochastic, right-stochastic]

感谢@proudhaskeller保存2个字节

R，55个字节

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

未命名函数，其中m假定为R矩阵。

输出：

• [1] TRUE FALSE：随机
• [1] FALSE TRUE：随机随机
• [1] TRUE TRUE：怀疑
• [1] FALSE FALSE： 没有

八度，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字节。

Mathematica 29字节

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

替换= U + F3C7 = [\ Transpose]字符。该代码段将正确粘贴到Mathematica中。

与{lefttruth，righttruth}相同的真实性约定作为输出

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-函数不需要包含在lambda中

编辑：减少字节数2-H / T @Simon Major

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

Mathematica，46 43个字节

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

与其他答案一样，输出为

{False, False} 非随机

{True, False} 对于左随机

{False, True} 随机随机

{True, True} 双重随机

通过切换到运算符形式保存了3个字节 AllTrue

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

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

C＃，205个 203 183字节

打高尔夫球：

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

编辑1：r=0;c=0;=>r=c=0;

EDIT2：嵌套三元运算符。积分转到@Yodle。

JavaScript（ES6），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]仍然意味着右侧的随机结果。

C＃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}对于双随机而言

复制演示

不打高尔夫球

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

Groovy，57岁

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

输出量

[0,0] 如果没有。

[1,0] 如果正确的话。

[0,1] 如果离开。

[1,1] 如果两者都有。

点子，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]

Dyalog APL，16 字节

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

{ } 直接函数定义（又名“ dfn”）， ⍵是自变量

⍵(⍉⍵) 矩阵及其转置

↑ 将它们混合成单个2×n×n数组

+/ 沿最后一个轴求和，得到2×n矩阵

100= 哪些元素是100（布尔值是0 1）

∧/ 沿最后一个轴进行“和”归约，随机获得2个布尔值

C ++ 14，139 136 133 130字节

-3个字节用于s=M.size()，-3个字节用于通过引用参数返回，-3个字节作为未命名的lambda

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

取消高尔夫：

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