Stochastyczny macierzy jest macierz prawdopodobieństw stosowane w kontekście łańcuchów Markowa.

Prawo stochastyczny matryca jest matrycą w którym każdy rząd z sumy 1.

Opuścił matrycę stochastyczne jest macierzą gdzie każda kolumna do sumy 1.

Podwójnie stochastyczny macierz jest macierzą, gdzie każdy rządek oraz każda kolumienka kwot 1.

W tym wyzwaniu będziemy reprezentować prawdopodobieństwa w procentach przy użyciu liczb całkowitych . W takim przypadku wiersz lub kolumna musi być sumą do, 100a nie sumą 1.

Twoim celem jest napisanie programu lub funkcji, która, biorąc pod uwagę kwadratową macierz liczb całkowitych jako dane wejściowe, wyprowadza jedną z czterech wartości wskazujących, że macierz jest albo prawa stochastyczna, lewa stochastyczna, podwójnie stochastyczna lub żadna z nich.

Wkład

Do wprowadzenia możesz użyć dowolnej właściwej reprezentacji macierzy naturalnej dla twojego języka. Na przykład lista list, ciąg wartości oddzielonych przecinkami z wierszami oddzielonymi podziałami wierszy itp.

Matryca wejściowa zawsze będzie kwadratowa i będzie zawierać tylko nieujemne liczby całkowite. Matryca wejściowa zawsze będzie co najmniej 1×1.

Możesz przekazać dane wejściowe, używając STDINjako argumentu funkcji lub czegoś podobnego.

Wydajność

Musisz wybrać cztery różne wyniki, które odpowiadają prawemu stochastycznemu , lewemu stochastycznemu , podwójnie stochastycznemu lub żadnemu z nich . Wyjścia te muszą być stałe niezależnie od przekazywanych danych wejściowych. Twój program może nie zwracać różnych wyników dla tego samego przypadku, np. Mówiąc, że jakakolwiek liczba ujemna nie odpowiada żadnej z tych wartości, jest niepoprawna.

Krótko mówiąc, musi być korespondencja 1 do 1 między twoimi wynikami a czterema możliwymi przypadkami. Niektóre przykłady tych czterech wyjść byłoby {1, 2, 3, 4}albo {[1,0], [0,1], [1,1], [0,0]}nawet {right, left, doubly, none}.

Proszę wskazać w swojej odpowiedzi cztery wyjścia, z których korzysta program.

Jeśli macierz jest podwójnie stochastyczna, musisz zwrócić wynik odpowiadający podwójnie stochastycznemu, a nie prawemu lub lewemu stochastycznemu.

Możesz wydrukować dane wyjściowe STDOUT, zwrócić je z funkcji lub coś podobnego.

Przypadki testowe

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

Punktacja

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

05AB1E , 13 11 10 bajtów

Prawa stochastyczna: [0,1]
Lewa stochastyczna: [1,0]
Podwójnie stochastyczna: [1,1]
Żadna z tych: [0,0]

Dø2FOTnQPˆ

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Podanie typu (Eq a, Num a) => [[a]]. Wyświetla listę wartości logicznych[left-stochastic, right-stochastic]

Dzięki @proudhaskeller za oszczędność 2 bajtów

R, 55 bajtów

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

Funkcja bez nazwy, gdzie mprzyjmuje się, że jest to macierz R.

Wydajność:

• [1] TRUE FALSE: Lewy stochastyczny
• [1] FALSE TRUE: Prawo stochastyczny
• [1] TRUE TRUE: Podwójnie
• [1] FALSE FALSE: Żaden

Oktawa, 35 34 32 31 bajtów

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

Nazwij to tak:

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

Sprawdź to tutaj.

Początkowo zapisałem 2 bajty dzięki flawr, ale wybrałem inne podejście, które było o 1 bajt krótsze.

To daje następujące wyniki dla różnych przypadków:

0    Doubly
0    

1    None
1

0    Left
1

1    Right
0

Ostatni ,2byłby niepotrzebny, gdyby nie uwzględniono pojedynczych cyfr. Ponadto, jeśli sumuje się to 1zamiast 100(jak mogłoby to mieć), zapisuje kolejne 4bajty.

Mathematica 29 bajtów

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

podstawianie znaku  = U + F3C7 = [\ Transpose]. Ten fragment kodu wklei się poprawnie w Mathematica.

Ta sama konwencja prawdomówności z {lefttruth, righttruth} jako wyjście

k, 21 19 bajtów

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

Wydajność

• 00b Żaden
• 10b lewo
• 01b dobrze
• 11b obie

Przykład:

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

edycja: zmniejsz liczbę bajtów o 3 - funkcja nie musi być zawarta w lambda

edycja: zmniejsz liczbę bajtów o 2 - H / T @Simon Major

MATL , 12 bajtów

sG!sv!100=XA

Wyjście to dwie wartości zero / jeden. Pierwszy wskazuje, czy matryca jest lewostochastyczna, a drugi, jeśli jest prawoskrętna.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe

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 bajty

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

Podobnie jak w przypadku innych odpowiedzi, wyniki są

{False, False} dla niestochastycznych

{True, False} dla lewoskrętnych

{False, True} dla prawej stochastycznej

{True, True} dla podwójnie stochastycznego

Zaoszczędzono 3 bajty, przechodząc do postaci operatora AllTrue

PHP, 104 bajty

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

Anonimowa funkcja, która echo 0 => oba, 1 => lewy, 2 => prawy, 3 => żaden.
Użyj jak:

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

Wersja programu wiersza poleceń o długości 114 bajtów:

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

Używany jak:

 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 bajtów

Nie ma tu nic szalonego, tylko splatanie się zip do transponowania matrycy :) Wyniki są następujące:

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

A oto kod :)

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

C #, 205 203 183 bajtów

Gra w golfa:

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

Niegolfowany z komentarzami:

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

Klucz wyjściowy: 1 - prawy stochastyczny 2 - lewy stochastyczny 3 - podwójny stochastyczny 4 - brak

Wypróbuj: http://rextester.com/PKYS11433

EDYCJA 1: r=0;c=0;=>r=c=0;

EDYCJA 2: Zagnieżdżone operatory trójskładnikowe. Kredyty trafiają do @Yodle.

JavaScript (ES6), 83 bajty

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

Przeciwnie, ten wynik nie tylko daje wynik po prawej stronie stoachistycznej po lewej, ale również booleany są odwrócone, więc wynik [false, true]nadal oznacza prawy stoachistyczny.

C # 6, 130 bajtów

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}dla nie-stochastycznego
{True, False}dla lewego-stochastycznego
{False, True}dla prawego-stochastycznego
{True, True}dla podwójnie stochastycznego

repl.it demo

Bez golfa

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

Wydajność

[0,0] jeśli żaden.

[1,0] jeśli dobrze.

[0,1] jeśli pozostanie.

[1,1] Jeśli oba.

Pip , 17 bajtów

W nieoczekiwany zwrot ten przekaz jest funkcją.

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

Zwraca listę dwóch 0/ 1wartości: [0 0]= nie stochastyczny, [0 1]= lewy stochastyczny, [1 0]= prawy stochastyczny, [1 1]= podwójnie stochastyczny.Wypróbuj online!

Wyjaśnienie

{               }  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 bajtów

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

{ }⍵argumentem jest bezpośrednia definicja funkcji (aka „dfn”)

⍵(⍉⍵) matryca obok jej transpozycji

↑ zmieszaj je w jedną tablicę 2 × n × n

+/ sumując wzdłuż ostatniej osi, uzyskaj macierz 2 × n

100= które elementy to 100 (booleany to 0 1)

∧/ „i” - redukcja wzdłuż ostatniej osi, zdobądź 2 booleany dla lewego, prawego stochastycznego

C ++ 14, 139 136 133 130 bajtów

-3 bajty na s=M.size(), -3 bajty na powrót przez parametr referencyjny, -3 bajty jako nienazwana 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);}}

Zakłada, że ​​dane wejściowe są podobne vector<vector<int>>. Zwraca 3,2,1,0 dla podwójnie, lewo, prawo, brak stochastyczny.

Nie golfowany:

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