In questa sfida determinerai quanto sia controverso un voto, data una serie di altri voti, capendo un numero chiamato fattore C. Qual è il fattore C, chiedi?

Bene, immagina di avere più voti per un'elezione. Useremo 1e 0per il bene della sfida per rappresentare due diversi candidati in un'elezione. Ecco i dieci voti nelle nostre elezioni campione:

0110111011

Ora, supponiamo di voler trovare il fattore C di qualsiasi voto per candidato 0. Possiamo farlo con la seguente funzione:

In , è il voto per il quale vogliamo determinare il fattore C, ed è un array di voti. Quindi, usando la nostra funzione, per ottenere il fattore C di qualsiasi voto per candidato :$f$ov0

Un fattore C inferiore mostra che il voto è stato meno controverso rispetto agli altri voti. Pertanto, un voto per candidato 0è più diverso dagli altri voti rispetto a un voto per candidato 1. In confronto, il fattore C per il 1voto di un candidato è , quindi è meno controverso perché è più simile agli altri voti.$0.3$

La sfida

Scrivi una funzione per determinare il fattore C di un voto dati i risultati di un voto .$f(o,v)$ov

• odeve essere un numero intero, o 0o 1.

• v deve essere un array (o un tipo di contenitore simile a seconda delle specifiche della lingua) di lunghezza arbitraria contenente zero e uno.

• La funzione dovrebbe restituire o stampare sulla console il fattore C risultante dati i parametri della funzione, usando la formula sopra o un metodo modificato.

In bocca al lupo! Vince il minor numero di byte (vincitore scelto tra cinque giorni).

Gelatina , 3 byte

ạÆm

Provalo online!

Letteralmente "differenza assoluta da significare".

ạÆm  Main link
ạ    Absolute difference
 Æm  Arithmetic Mean

Se inverti gli argomenti puoi invertire gli atomi.

R , 23 byte

function(o,v)mean(o!=v)

Provalo online!

La sfida si riduce a calcolare la proporzione di valori vdiversi da o(cioè mean(xor(o,v))). Possiamo quindi evitare di usare abs.

APL (Dyalog Unicode) , 9 8 5 byte

≠⌹⊢=⊢

Provalo online!

Treno anonimo. Grazie a @Adám per un byte salvato e grazie a @ngn per 3 byte!

Come:

≠⌹⊢=⊢ ⍝ Anonymous Train
    ⊢ ⍝ The right argument (⍵)
  ⊢=  ⍝ Equals itself. Generates an array of 1s
≠     ⍝ XOR left (⍺) and right args; generates ⍵ or (not ⍵), depending on ⍺.
 ⌹    ⍝ Divide these matrices.

In realtà , 3 byte

♀^æ

Provalo online!

Spiegazione:

♀^æ
♀^   XOR each vote with candidate (0 if matches, 1 if not)
  æ  mean of the list

05AB1E , 3 byte

ÅAα

Provalo online!

Ottava , 16 byte

@(a,b)mean(a!=b)

Provalo online!

Attache , 11 8 byte

Mean@`/=

Provalo online! Prende argomenti come f[o, v].

Niente di terribilmente originale.

Approcci alternativi

11 byte: Average@`/=

11 byte: ${1-x~y/#y} conta le occorrenze di xin ydivise per la lunghezza di y, quindi sottrae da 1.

11 byte: {1-_2~_/#_} (gli argomenti sono invertiti per questo)

15 byte: ${Sum[x/=y]/#y} una versione più esplicita di quanto sopra, senza Average.

JavaScript, 38 byte

n=>a=>a.map(x=>n-=x/a.length)|n<0?-n:n

Provalo

Proton , 26 byte

(o,v)=>1-v.count(o)/len(v)

Provalo online!

L'output è una frazione perché Proton usa sympy invece dei normali numeri Python per una migliore precisione.

(-7 byte; abs-diff a media è più breve della media di abs-diff; in realtà sono stupido)

-1 byte grazie a Rod

Perl 6 , 20 byte

{@_.sum/@_}o(*X!= *)

Provalo online!

* X!= *è una funzione anonima che prende il non-uguale prodotto incrociato dei suoi due argomenti. Produce una sequenza di booleani; ad esempio, 1 X!= (1, 0, 1)valuta (False, True, False).

{ @_.sum / @_ }è un'altra funzione anonima che restituisce la media dei suoi argomenti. Boolean Truevaluta 1numericamente e Falsea 0.

L' ooperatore compone queste due funzioni in una.

Enlist , 3 byte

nÆm

Provalo online!

nÆm  Main Link
n    Not Equals (returns a list of whether or not each element is unequal to to the value)
 Æm  Arithmetic Mean

Il linguaggio è fortemente ispirato da Jelly al punto che probabilmente è più come me che sto sperimentando per provare a ricreare la struttura di come Jelly viene analizzata con il mio codice.

-1 byte grazie a Mr. Xcoder

Retina 0.8.2 , 27 byte

(.),((?(\1)|()).)*$
$#3/$#2

Provalo online! Emette una frazione. Spiegazione: Il primo gruppo acquisisce oe il secondo gruppo cattura ogni voce di v, mentre il condizionale garantisce che il terzo gruppo effettui una cattura solo quando il voto è diverso. La $#costruzione quindi restituisce il conteggio delle acquisizioni rilevanti come desiderato.

Perl 5 -MList::Util=sum , 30 byte

sub f{abs((shift)-sum(@_)/@_)}

Provalo online!

K (Kona) , 17 byte

{_abs+/y-x%.0+#x}

Provalo online!

Olmo 0,19, 48 byte

f a v=abs(v-(List.sum a/toFloat(List.length a)))

Demo online qui .

C (gcc) , 62 byte

float f(o,v,l,k)int*v;{float r=0;for(k=l;k;)r+=v[--k]^o;r/=l;}

Provalo online!

Chiama come f(int o, int *v, int length_of_v).

Japt v2.0a0, 6 byte

aVx÷Vl

Provalo

JavaScript (Node.js) , 47 42 byte

-5 byte da @arnauld

a=>b=>Math.abs(a-eval(b.join`+`)/b.length)

Provalo online!

Java 8, 47 byte

v->o->(o-=v.get().sum()/v.get().count())<0?-o:o

Provalo online.

o in alternativa:

v->o->Math.abs(o-v.get().sum()/v.get().count())

Provalo online.

Per entrambi gli input sono a Supplier<DoubleStream>per l'elenco dei voti ve doubleper il voto o.

Spiegazione:

v->o->                 // Method with DoubleStream-Supplier & double parameters and double return
  (o-=v.get().sum()    //  Get the sum of the DoubleStream-Supplier
      /v.get().count() //  Divide it by the amount of items in the DoubleStream-Supplier
      )                //  Subtract this from `o`
       <0?-o:o         //  And get the absolute value of this updated value `o`

Lisp comune 49 byte

Soluzione:

(defun c(o v)(abs(- o(/(reduce'+ v)(length v)))))

Provalo online

Spiegazione:

(defun c(o v)
  (abs (- o (/ (reduce '+ v) (length v)))))

• ridurre applica una funzione su tutti gli elementi dell'elenco (+ in questo caso)
• il resto è solo la funzione base, abs (o - mean (v))

Rubino , 31 byte

->o,v{v.count(1-o)/v.size.to_f}

Provalo online!

Pyth, 4 byte

aE.O

Spiegazione:

       ( implicitly set Q = eval(input()) )
a      Absolute difference between
 E     eval(input()) (this is the second line of input taken)
  .O   and the average of
    Q  (implicit) Q (the first line of input)

L'input è nel formato di:

[0,1,1,0,1,1,1,0,1,1]
0

con la serie di voti prima e il secondo candidato.

Provalo online!