Một ma trận ngẫu nhiên là một ma trận xác suất được sử dụng trong bối cảnh của chuỗi Markov.

Một ma trận ngẫu nhiên đúng là một ma trận trong đó mỗi hàng tính tổng 1.

Một ma trận ngẫu nhiên bên trái là một ma trận trong đó mỗi cột tính tổng 1.

Một ma trận ngẫu nhiên kép là một ma trận trong đó mỗi hàng và mỗi cột tính tổng 1.

Trong thử thách này, chúng tôi sẽ đại diện cho xác suất tính bằng phần trăm bằng cách sử dụng số nguyên . Một hàng hoặc cột phải trong trường hợp đó tổng hợp 100và không 1.

Mục tiêu của bạn là viết một chương trình hoặc hàm, đưa ra một ma trận vuông các số nguyên làm đầu vào, đưa ra một trong bốn giá trị chỉ ra rằng ma trận là ngẫu nhiên phải, ngẫu nhiên trái, ngẫu nhiên hoặc không có giá trị nào.

Đầu vào

Bạn có thể sử dụng bất kỳ biểu diễn thích hợp nào của ma trận tự nhiên cho ngôn ngữ của bạn cho đầu vào. Ví dụ: danh sách các danh sách, một chuỗi các giá trị được phân tách bằng dấu phẩy với các hàng được phân tách bằng dấu ngắt dòng, v.v.

Ma trận đầu vào sẽ luôn là hình vuông và sẽ chỉ chứa các số nguyên không âm. Ma trận đầu vào sẽ luôn luôn ít nhất 1×1.

Bạn có thể chuyển đầu vào bằng cách sử dụng STDIN, làm đối số hàm hoặc bất cứ thứ gì tương tự.

Đầu ra

Bạn phải chọn bốn đầu ra riêng biệt tương ứng với stochastic phải , stochastic trái , stochastic đôi hoặc không có cái nào trong số đó . Những đầu ra đó phải là hằng số bất kể đầu vào nào được thông qua. Chương trình của bạn có thể không trả về các đầu ra khác nhau cho cùng một trường hợp, ví dụ: nói rằng bất kỳ số âm nào tương ứng với không có số nào không hợp lệ.

Nói tóm lại, phải có sự tương ứng 1-1 giữa đầu ra của bạn trong bốn trường hợp có thể xảy ra. Một số ví dụ về bốn kết quả đầu ra sẽ {1, 2, 3, 4}hay {[1,0], [0,1], [1,1], [0,0]}hoặc thậm chí {right, left, doubly, none}.

Vui lòng cho biết trong câu trả lời của bạn bốn kết quả đầu ra mà chương trình của bạn sử dụng.

Nếu một ma trận là ngẫu nhiên kép, thì bạn phải trả lại đầu ra tương ứng với ngẫu nhiên kép, và không phải ngẫu nhiên phải hoặc trái.

Bạn có thể in đầu ra STDOUT, trả lại từ một chức năng hoặc bất cứ thứ gì tương tự.

Các trường hợp thử nghiệm

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

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

05AB1E , 13 11 10 byte

Stochastic phải: Stochastic [0,1]
trái: [1,0]
Stochastic nghi ngờ: [1,1]
Không ai trong số đó: [0,0]

Dø2FOTnQPˆ

Hãy thử trực tuyến!

Giải trình

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 byte

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

Đầu vào của loại (Eq a, Num a) => [[a]]. Đầu ra danh sách boolean[left-stochastic, right-stochastic]

Cảm ơn @proudhaskeller đã lưu 2 byte

R, 55 byte

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

Hàm không tên mđược giả sử là ma trận R.

Đầu ra:

• [1] TRUE FALSE: Ngẫu nhiên trái
• [1] FALSE TRUE: Đúng ngẫu nhiên
• [1] TRUE TRUE: Nghi ngờ
• [1] FALSE FALSE: Không ai

Octave, 35 34 32 31 byte

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

Gọi nó như thế này:

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

Kiểm tra nó ở đây.

Đã lưu 2 byte nhờ flawr ban đầu, nhưng đã đi đến một cách tiếp cận khác ngắn hơn 1 byte.

Điều này xuất ra sau đây cho các trường hợp khác nhau:

0    Doubly
0    

1    None
1

0    Left
1

1    Right
0

Cuối cùng ,2sẽ là không cần thiết nếu không bao gồm các chữ số duy nhất. Ngoài ra, nếu điều này được tóm tắt 1thay vì 100(như nó có thể), nó sẽ lưu một 4byte khác .

Toán học 29 byte

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

thay thế ký tự = U + F3C7 = [\ Transpose]. Đoạn mã này sẽ dán chính xác vào Mathicala.

Quy ước về tính trung thực tương tự với {lefttruth, righttruth} là đầu ra

k, 21 19 byte

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

Đầu ra

• 00b không ai
• 10b trái
• 01b đúng
• 11b cả hai

Thí dụ:

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

chỉnh sửa: giảm số byte xuống 3 - chức năng không cần phải được đặt trong lambda

chỉnh sửa: giảm bytecount xuống 2 - H / T @Simon Major

MATL , 12 byte

sG!sv!100=XA

Đầu ra là hai giá trị 0 / một. Đầu tiên cho biết nếu ma trận là stochastic trái, thứ hai nếu nó là stochastic phải.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm

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

Toán học, 46 43 byte

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

Cũng như các câu trả lời khác, kết quả đầu ra là

{False, False} cho không ngẫu nhiên

{True, False} cho stochastic trái

{False, True} cho stochastic phải

{True, True} cho stochastic đôi

Đã lưu 3 byte bằng cách chuyển sang dạng toán tử của AllTrue

PHP, 104 byte

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

Một hàm ẩn danh có tiếng vang 0 => cả hai, 1 => trái, 2 => phải, 3 => không.
Sử dụng như:

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

Một phiên bản chương trình dòng lệnh ở 114 byte:

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

Được sử dụng như:

 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 byte

Không có gì điên rồ ở đây, chỉ cần sử dụng tính năng ghép hình zipđể hoán đổi ma trận :) Các kết quả đầu ra như sau:

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

Và đây là mã :)

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

C #, 205 203 183 byte

Chơi gôn

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

Ungolfed với ý kiến:

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

Phím đầu ra: 1 - stochastic phải 2 - stochastic trái 3 - double stochastic 4 - none

Hãy dùng thử: http://rextester.com/PKYS11433

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

EDIT2: Toán tử ternary lồng nhau. Tín dụng vào @Yodle.

JavaScript (ES6), 83 byte

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

Ngược lại, điều này không chỉ tạo ra kết quả khắc kỷ bên phải, mà các booleans cũng được đảo ngược, do đó, một đầu ra [false, true]vẫn có nghĩa là chủ nghĩa khắc kỷ.

C # 6, 130 byte

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}không ngẫu nhiên
{True, False}cho stochastic trái
{False, True}cho stochastic phải
{True, True}cho stochastic đôi

thay thế bản demo

Bị đánh cắp

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

Đầu ra

[0,0] nếu không.

[1,0] nếu đúng

[0,1] nếu còn lại

[1,1] nếu cả hai.

Pip , 17 byte

Trong một bước ngoặt bất ngờ, đệ trình này là một chức năng.

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

Trả về danh sách hai 0/ 1giá trị: [0 0]= not stochastic, [0 1]= left stochastic, [1 0]= right stochastic, [1 1]= nghi ngờ stochastic. Hãy thử trực tuyến!

Giải trình

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

APL Dyalog , 16 byte

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

{ }định nghĩa hàm trực tiếp (còn gọi là "dfn"), ⍵là đối số

⍵(⍉⍵) ma trận cùng với sự chuyển vị của nó

↑ trộn chúng thành một mảng 2 × n × n

+/ tính tổng theo trục cuối cùng, lấy ma trận 2 × n

100= yếu tố nào là 100 (booleans là 0 1)

∧/ "và" - giảm giá dọc theo trục cuối cùng, nhận 2 booleans cho stochastic trái, phải

C ++ 14, 139 136 133 130 byte

-3 byte cho s=M.size(), -3 byte để trả về bởi tham số tham chiếu, -3 byte dưới dạng lambda không tên

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

Giả sử đầu vào là như thế vector<vector<int>>. Trả về 3,2,1,0 cho gấp đôi, trái, phải, không ngẫu nhiên.

Ung dung:

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