เมทริกซ์สุ่มเป็นเมทริกซ์ของความน่าจะใช้ในบริบทของโซ่มาร์คอฟ

ขวา1เมทริกซ์สุ่มเป็นเมทริกซ์ที่แต่ละเงินก้อนแถว

ซ้าย1เมทริกซ์สุ่มเป็นเมทริกซ์ที่แต่ละเงินก้อนคอลัมน์

ทวีคูณ1เมทริกซ์สุ่มเป็นเมทริกซ์ที่แต่ละแถวและแต่ละเงินก้อนคอลัมน์

ในความท้าทายนี้เราจะเป็นตัวแทนของความน่าจะเป็นในการใช้ร้อยละจำนวนเต็ม แถวหรือคอลัมน์ต้องในกรณีที่จำนวนเงินนั้นไปและไม่ได้1001

เป้าหมายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นซึ่งกำหนดให้เมทริกซ์จตุรัสของจำนวนเต็มเป็นอินพุตเอาต์พุตหนึ่งในสี่ค่าที่บ่งชี้ว่าเมทริกซ์นั้นเป็นแบบสุ่มขวา, สุ่มซ้าย, สุ่มสองเท่าหรือไม่มีเลย

อินพุต

คุณอาจใช้การแทนค่าที่เหมาะสมของเมทริกซ์ที่เป็นธรรมชาติสำหรับภาษาของคุณสำหรับอินพุต ตัวอย่างเช่นรายการของรายการสตริงของค่าที่คั่นด้วยเครื่องหมายจุลภาคโดยมีแถวคั่นด้วย linebreaks เป็นต้น

เมทริกซ์อินพุตจะเป็นสี่เหลี่ยมจัตุรัสเสมอและจะมีจำนวนเต็มไม่เป็นลบเท่านั้น เมทริกซ์อินพุตจะมีอย่างน้อยที่สุด1×1เสมอ

คุณสามารถส่งผ่านอินพุตโดยใช้STDINเป็นอาร์กิวเมนต์ฟังก์ชันหรือสิ่งอื่นที่คล้ายกัน

เอาท์พุต

คุณต้องเลือกสี่ผลที่แตกต่างกันที่ตรงกับสุ่มขวา , ซ้ายสุ่ม , ทวีคูณสุ่มหรือไม่มีผู้ เอาต์พุตเหล่านั้นต้องคงที่โดยไม่คำนึงว่าอินพุตใดถูกส่งผ่าน โปรแกรมของคุณอาจไม่ส่งคืนผลลัพธ์ที่แตกต่างกันสำหรับกรณีเดียวกันเช่นการพูดว่าจำนวนลบใด ๆ ที่ตรงกับสิ่งเหล่านั้นไม่ถูกต้อง

ในระยะสั้นจะต้องมีการติดต่อแบบ 1 ต่อ 1 ระหว่างการส่งออกของคุณเป็นกรณีที่เป็นไปได้ทั้งสี่ ตัวอย่างบางส่วนของบรรดาสี่เอาท์พุทจะเป็น{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]

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

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-matrix

เอาท์พุท:

• [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 - ฟังก์ชันไม่จำเป็นต้องอยู่ในแลมบ์ดา

แก้ไข:ลดจำนวนโดย 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;}

ฟังก์ชั่นที่ไม่ระบุชื่อที่ echos 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 Bytes

ไม่มีอะไรบ้าที่นี่เพียงแค่ใช้การกระจาย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

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

เพื่อที่จะตรงกันข้ามไม่เพียง แต่ผลลัพธ์นี้จะทำให้เกิดผลลัพธ์เชิงโวหารที่ถูกต้องทางด้านซ้าย แต่ booleans ก็กลับด้านด้วยเช่น[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}สำหรับ non-stochastic
{True, False}สำหรับซ้าย stochastic
{False, True}สำหรับ right-stochastic
{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)
    };

Groovy, 57

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

เอาท์พุต

[0,0] ถ้าไม่มี

[1,0] ถ้าถูกต้อง

[0,1] ถ้าทิ้งไว้

[1,1] ถ้าทั้งคู่

Pip , 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=+/↑⍵(⍉⍵)}

{ }นิยามฟังก์ชั่นโดยตรง (aka "dfn") ⍵เป็นอาร์กิวเมนต์

⍵(⍉⍵) เมทริกซ์ข้างขนย้าย

↑ ผสมลงในอาร์เรย์ 2 × n × n เดียว

+/ หาผลรวมตามแกนสุดท้ายได้เมทริกซ์ 2 × n

100= องค์ประกอบใดคือ 100 (บูลีนคือ 0 1)

∧/ "และ" - ลดตามแกนสุดท้ายได้รับ 2 booleans สำหรับซ้ายและขวาสุ่ม

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