Eine stochastische Matrix ist eine Matrix von Wahrscheinlichkeiten, die im Zusammenhang mit Markov-Ketten verwendet werden.

Eine rechte stochastische Matrix ist eine Matrix, in der jede Zeile summiert 1.

Eine linke stochastische Matrix ist eine Matrix, in der jede Spalte summiert 1.

Eine doppelt stochastische Matrix ist eine Matrix, in der sich jede Zeile und jede Spalte summiert 1.

In dieser Herausforderung werden wir die Wahrscheinlichkeiten in Prozent mit ganzen Zahlen darstellen . In diesem Fall muss eine Zeile oder Spalte die Summe aus 100und nicht 1.

Ihr Ziel ist es, ein Programm oder eine Funktion zu schreiben, die bei einer quadratischen Matrix von Ganzzahlen als Eingabe einen von vier Werten ausgibt, die anzeigen, dass die Matrix entweder rechtsstochastisch, linksstochastisch, doppeltstochastisch oder keine davon ist.

Eingang

Sie können für die Eingabe jede geeignete Darstellung einer Matrix verwenden, die für Ihre Sprache natürlich ist. Zum Beispiel eine Liste von Listen, eine Folge von durch Kommas getrennten Werten mit durch Zeilenumbrüchen getrennten Zeilen usw.

Die Eingabematrix ist immer quadratisch und enthält nur nicht negative ganze Zahlen. Die Eingabematrix wird immer mindestens sein 1×1.

Sie können die Eingabe mit STDIN, als Funktionsargument oder ähnlichem übergeben.

Ausgabe

Sie müssen vier verschiedene Ausgänge auswählen , die der rechten , der linken , der doppelten oder keiner Stochastik entsprechen . Diese Ausgaben müssen unabhängig von der übergebenen Eingabe konstant sein. Ihr Programm kann möglicherweise keine unterschiedlichen Ausgaben für denselben Fall zurückgeben, z. B. ist die Aussage, dass eine negative Zahl keiner dieser Ausgaben entspricht, ungültig.

Kurz gesagt, es muss eine 1-zu-1-Entsprechung zwischen Ihrer Ausgabe und den vier möglichen Fällen geben. Einige Beispiele für diese vier Ausgänge wären {1, 2, 3, 4}oder {[1,0], [0,1], [1,1], [0,0]}oder sogar {right, left, doubly, none}.

Bitte geben Sie in Ihrer Antwort die vier Ausgänge an, die Ihr Programm verwendet.

Wenn eine Matrix doppelt stochastisch ist, müssen Sie die Ausgabe zurückgeben, die doppelt stochastisch und nicht rechts oder links stochastisch ist.

Sie können die Ausgabe an drucken STDOUT, von einer Funktion zurückgeben oder etwas Ähnliches.

Testfälle

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

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

05AB1E , 13 11 10 Bytes

Rechte Stochastik: [0,1]
Linke Stochastik: [1,0]
Doppelte Stochastik: [1,1]
Keine davon: [0,0]

Dø2FOTnQPˆ

Probieren Sie es online!

Erläuterung

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 Bytes

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

Eingabe des Typs (Eq a, Num a) => [[a]]. Gibt eine boolesche Liste aus[left-stochastic, right-stochastic]

Vielen Dank an @proudhaskeller für das Speichern von 2 Bytes

R, 55 Bytes

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

Unbenannte Funktion, bei der mangenommen wird, dass es sich um eine R-Matrix handelt.

Ausgabe:

• [1] TRUE FALSE: Links stochastisch
• [1] FALSE TRUE: Richtig stochastisch
• [1] TRUE TRUE: Zweifach
• [1] FALSE FALSE: Keiner

Oktave, 35 34 32 31 Bytes

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

Nenne es so:

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

Teste es hier.

2 Bytes wurden zunächst dank flawr eingespart, es wurde jedoch ein um 1 Byte kürzerer Ansatz gewählt.

Dies gibt für die verschiedenen Fälle Folgendes aus:

0    Doubly
0    

1    None
1

0    Left
1

1    Right
0

Der letzte ,2wäre unnötig, wenn einzelne Ziffern nicht enthalten wären. Wenn dies 1anstelle von 100(wie es hätte sein können) aufsummiert wird , würden weitere 4Bytes gespart .

Mathematica 29 Bytes

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

Ersetzen des Zeichens  = U + F3C7 = [\ Transpose]. Dieses Code-Snippet wird korrekt in Mathematica eingefügt.

Gleiche Wahrheitskonvention mit {lefttruth, righttruth} als Ausgabe

k, 21 & ndash; 19 Bytes

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

Ausgabe

• 00b keiner
• 10b links
• 01b Recht
• 11b beide

Beispiel:

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

edit: Bytezahl um 3 reduzieren - Funktion muss nicht in ein Lambda eingeschlossen werden

bearbeiten: bytecount um 2 reduzieren - H / T @Simon Major

MATL , 12 Bytes

sG!sv!100=XA

Es werden zwei Null / Eins-Werte ausgegeben. Erstens, wenn die Matrix linksstochastisch ist, zweitens, wenn sie rechtsstochastisch ist.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle

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 Bytes

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

Wie bei anderen Antworten sind die Ausgaben

{False, False} für nicht stochastisch

{True, False} für linksstochastisch

{False, True} für rechtsstochastisch

{True, True} für doppelt stochastisch

Eingesparte 3 Bytes durch Umschalten auf die Operatorform von AllTrue

PHP, 104 Bytes

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

Eine anonyme Funktion, die 0 => beide, 1 => links, 2 => rechts, 3 => weder echos.
Verwenden Sie wie:

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

Eine Befehlszeilenprogrammversion mit 114 Bytes:

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

Gebraucht wie:

 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

Hier ist nichts verrücktes, nur das Einspringen zip, um die Matrix zu transponieren :) Die Ausgaben sind wie folgt:

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

Und hier ist der Code :)

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

C # 205 203 183 Bytes

Golf gespielt:

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 mit Kommentaren:

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

Ausgabetaste: 1 - rechts stochastisch 2 - links stochastisch 3 - doppelt stochastisch 4 - keine

Probieren Sie es aus: http://rextester.com/PKYS11433

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

EDIT2: Verschachtelte ternäre Operatoren. Credits gehen an @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))]

Um genau zu sein, gibt dies nicht nur das rechte stoachistische Ergebnis auf der linken Seite aus, sondern die Booleschen Werte werden auch invertiert. Eine Ausgabe von [false, true]bedeutet also immer noch recht stoachistisch.

C # 6, 130 Bytes

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}für nichtstochastisch
{True, False}für linksstochastisch
{False, True}für rechtsstochastisch
{True, True}für doppeltstochastisch

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

Groovy, 57 Jahre alt

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

Ausgabe

[0,0] wenn auch nicht.

[1,0] wenn richtig.

[0,1] wenn links.

[1,1] wenn beides.

Pip , 17 Bytes

In einer unerwarteten Wendung ist diese Vorlage eine Funktion.

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

Gibt eine Liste mit zwei 0/ 1Werten zurück: [0 0]= nicht stochastisch, [0 1]= links stochastisch, [1 0]= rechts stochastisch, [1 1]= doppelt stochastisch. Probieren Sie es online!

Erläuterung

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

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

{ }direkte Funktionsdefinition (aka "dfn") ⍵ist das Argument

⍵(⍉⍵) die Matrix neben ihrer Umsetzung

↑ mische sie zu einem einzigen 2 × n × n-Array

+/ Summe entlang der letzten Achse ergibt eine 2 × n Matrix

100= Welche Elemente sind 100 (Boolesche Werte sind 0 1)

∧/ "und" -Reduktion entlang der letzten Achse, 2 Boolesche Werte für linkes und rechtes Stochastikum

C ++ 14, 139 136 133 130 Bytes

-3 Bytes für s=M.size(), -3 Bytes für die Rückgabe per Referenzparameter, -3 Bytes als unbenanntes 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);}}

Nimmt an, dass die Eingabe ähnlich ist vector<vector<int>>. Gibt 3,2,1,0 für doppelt, links, rechts und nicht stochastisch zurück.

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