È una matrice stocastica?


24

Una matrice stocastica è una matrice di probabilità utilizzata nel contesto delle catene di Markov.

Una matrice stocastica destra è una matrice in cui ogni riga si somma 1.

Una matrice stocastica sinistra è una matrice in cui ogni colonna si somma a 1.

Una matrice doppiamente stocastica è una matrice in cui ogni riga e ogni colonna si sommano 1.

In questa sfida, rappresenteremo le probabilità in percentuale usando numeri interi . In questo caso una riga o colonna deve essere sommata 100e non 1.

Il tuo obiettivo è quello di scrivere un programma o una funzione che, data una matrice quadrata di numeri interi come input, emetta uno dei quattro valori che indicano che la matrice è stocastica destra, stocastica sinistra, doppiamente stocastica o nessuna di queste.

Ingresso

È possibile utilizzare qualsiasi rappresentazione corretta di una matrice naturale per la propria lingua per l'input. Ad esempio, un elenco di elenchi, una stringa di valori separati da virgola con righe separate da interruzioni di riga, ecc.

La matrice di input sarà sempre quadrata e conterrà solo numeri interi non negativi. La matrice di input sarà sempre almeno 1×1.

È possibile passare l'input utilizzando STDIN, come argomento di funzione o qualcosa di simile.

Produzione

Devi scegliere quattro uscite distinte che corrispondono a destra stocastica , sinistra stocastica , doppiamente stocastica o nessuna di queste . Tali uscite devono essere costanti indipendentemente dall'ingresso passato. Il tuo programma potrebbe non restituire output diversi per lo stesso caso, ad esempio dire che un numero negativo corrisponde a nessuno di questi non è valido.

In breve, ci deve essere una corrispondenza 1 a 1 tra l'output e i quattro casi possibili. Alcuni esempi di queste quattro uscite sarebbero {1, 2, 3, 4}o {[1,0], [0,1], [1,1], [0,0]}o addirittura {right, left, doubly, none}.

Indica nella tua risposta i quattro output utilizzati dal tuo programma.

Se una matrice è doppiamente stocastica, è necessario restituire l'output corrispondente a doppiamente stocastica e non destra o sinistra stocastica.

È possibile stampare l'output STDOUT, restituirlo da una funzione o qualcosa di simile.

Casi test

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

punteggio

Questo è , quindi vince la risposta più breve in byte.


Posso prendere un input determinando prima la dimensione della matrice?
HyperNeutrino,

@AlexL. No, a questo punto sarebbe ingiusto cambiare le specifiche.
Fatalizza il

Risposte:


9

05AB1E , 13 11 10 byte

Stocastico destro [0,1]
: [1,0]
Stocastico sinistro: Doppio stocastico: [1,1]
Nessuno di quelli: [0,0]

Dø2FOTnQPˆ

Provalo online!

Spiegazione

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

14

Haskell, 57 55 byte

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

Input di tipo (Eq a, Num a) => [[a]]. Emette un elenco booleano[left-stochastic, right-stochastic]

Grazie a @proudhaskeller per aver salvato 2 byte


Non è possibile salvare alcuni byte rendendo la funzione priva di punti? ad es. con [transpose,id]<*>(quindi è possibile omettere le s a=funzioni non consentite)
flawr

@flawr probabilmente, ma [transpose,id]<*>ha un tipo di [[[a]]]->[[[a]]], che ha bisogno di un altro livello di mape un pure/ return/ (:[])o un input di tipo [[[Int]]], che non è naturale. La cosa migliore che ho èmap(all(==100).map sum).(<$>[transpose,id]).flip id
Angs,

Ah giusto, grazie per la spiegazione!
flawr

Che ne dici all((==100).sum)invece di all(==100).map sum?
orgoglioso haskeller il

@proudhaskeller ovviamente! allfa una mappatura in sé.
Ang

11

R, 55 byte

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

Funzione senza nome in cui msi presume che sia una matrice R.

Produzione:

  • [1] TRUE FALSE: Sinistra stocastica
  • [1] FALSE TRUE: Giusto stocastico
  • [1] TRUE TRUE: Doppiamente
  • [1] FALSE FALSE: Nessuna

any(colSums(m)-100)e allo stesso modo per rowSumsfarti cadere due byte durante l'inversione di tutti gli output, quindi se desideri mantenerli, puoi sempre mettere un !fronte per net -1byte.
Giuseppe,

7

Ottava, 35 34 32 31 byte

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

Chiamalo così:

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

Provalo qui.

Salvato 2 byte grazie a flawr inizialmente, ma è andato per un altro approccio che era 1 byte più corto.

Ciò genera quanto segue per i diversi casi:

0    Doubly
0    

1    None
1

0    Left
1

1    Right
0

L'ultimo non ,2sarebbe necessario se non fossero incluse le singole cifre. Inoltre, se sommato a 1invece di 100(come avrebbe potuto), salverebbe un altro 4byte.


6

Mathematica 29 byte

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

sostituendo il carattere  = U + F3C7 = [\ Transpose]. Questo frammento di codice verrà incollato correttamente in Mathematica.

Stessa convenzione di verità con {lefttruth, righttruth} dell'output


{}⋃salva un byteUnion@
A Simmons

@ASimmons, grazie per il suggerimento! Inseriscilo e corretto un errore nel mio byte totale.
Kelly Lowder,

Inoltre penso che se fai il tuo output {righttruth, lefttruth}, la sostituzione Total@con Tr/@salverà altri 2 byte.
A Simmons,

O invertire in modo equivalente le due matrici in modo che la soluzione diventi{}⋃Tr/@#=={100}&/@{#,#}&
A Simmons,

@ASimmons, Sì, che ha salvato un altro 2. Grazie!
Kelly Lowder,

6

k, 21 19 byte

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

Produzione

  • 00b nessuna
  • 10b sinistra
  • 01b destra
  • 11b tutti e due

Esempio:

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

modifica: riduce il conteggio dei byte di 3 - la funzione non deve essere racchiusa in un lambda

modifica: ridurre il conteggio di 2 - H / T @Simon Major


1
Puoi effettivamente salvare un byte racchiudendolo in un lambda: {min'100 = + / '(x; +: x)}
Simon Major

5

MATL , 12 byte

sG!sv!100=XA

L'output è due valori zero / uno. In primo luogo indica se la matrice è stocastica di sinistra, in secondo luogo se è stocastica di destra.

Provalo online! Oppure verifica tutti i casi di test

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

L'uomo che 100 era costoso, buona risposta però.
Magic Octopus Urn,

5

Mathematica, 46 43 byte

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

Come con altre risposte, le uscite sono

{False, False} per non stocastico

{True, False} per sinistro-stocastico

{False, True} per stocastico di destra

{True, True} per doppiamente stocastico

Salvato 3 byte passando alla forma operatore di AllTrue


Usa U + F3C7 (uso privato) per\[Transpose]
u54112

L'ho considerato, ma ho pensato che fosse meno illuminante
A Simmons,

Inoltre c'è un extra @alla fine
u54112

4

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

Una funzione anonima che echos 0 => both, 1 => left, 2 => right, 3 => nessuno dei due.
Usa come:

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

Una versione del programma della riga di comando a 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;

Usato come:

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

4

Python 2, 70 64 byte

Niente di pazzo qui, solo facendo uso di splatting zipper trasporre la matrice :) Le uscite sono le seguenti:

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

Ed ecco il codice :)

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

La stella è (* na errore?
hhh

1
@hhh No, questo è l' splatoperatore :) In sostanza è quello che mi sta permettendo di trasporre la matrice :)
Kade,

4

C #, 205 203 183 byte

golfed:

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 con commenti:

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

Tasto di uscita: 1 - destra stocastica 2 - sinistra stocastica 3 - doppia stocastica 4 - nessuna

Provalo: http://rextester.com/PKYS11433

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

EDIT2: operatori ternari nidificati. I crediti vanno a @Yodle.


2
if(e==1&&w==1)return 3;if(e==1)return 1;return w==1?2:4;Poiché ee wpuò essere solo 1 o 0, può essere modificato return w<<1|e;e ridefinire none == 0.
Link ng

1
Puoi abbreviare le tue di 30 se trasformi alcune di queste ifaffermazioni in operazioni ternarie e alla fine restituisci un intero. Idunno se dovessi pubblicare la mia soluzione poiché è così simile.
Yodle,

@LinkNg Molto bello. Non voglio scrivere codice senza capire. Non ho familiarità con gli operatori binari.
paldir,

@Yodle Grazie, ho cambiato la mia soluzione. Sentiti libero di pubblicare il tuo anche se è molto simile.
paldir,

3

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

Giusto per essere contrario, questo non solo produce il risultato stoachistico destro sulla sinistra, ma anche i booleani sono invertiti, quindi un output di [false, true]significa ancora stoachistico giusto.


3

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}per non stocastico
{True, False}per sinistro-stocastico
{False, True}per destro-stocastico
{True, True} per doppiamente stocastico

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

3

Groovy, 57

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

Produzione

[0,0] se nessuno dei due.

[1,0] se giusto.

[0,1] se lasciato.

[1,1] se entrambi.


2

seme , 17 byte

In una svolta inaspettata, questa presentazione è una funzione.

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

Restituisce un elenco di due 0/ 1valori: [0 0]= non stocastico, [0 1]= sinistro stocastico, [1 0]= destro stocastico, [1 1]= doppiamente stocastico. Provalo online!

Spiegazione

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

2

Dyalog APL , 16 byte

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

{ }definizione di funzione diretta (aka "dfn"), è l'argomento

⍵(⍉⍵) la matrice accanto alla sua trasposizione

mescolarli in un singolo array 2 × n × n

+/ somma lungo l'ultimo asse, ottieni una matrice 2 × n

100= quali elementi sono 100 (i booleani sono 0 1)

∧/ "e" -riduzione lungo l'ultimo asse, ottieni 2 booleani per lo stocastico sinistro, destro


2

C ++ 14, 139 136 133 130 byte

-3 byte per s=M.size(), -3 byte per la restituzione per parametro di riferimento, -3 byte come lambda senza nome

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

Suppone che l'input sia simile vector<vector<int>> . Restituisce 3,2,1,0 per doppiamente, a sinistra, a destra, nessuna stocastica.

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);
  }
}
;
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.