Ispirato e in ricordo del mio caro amico e collega,

Dan Baronet , 1956-2016. RIP

Ha trovato la soluzione APL più breve possibile per questo compito:

Compito

Dato un elenco booleano, conta il numero di valori di verità finali.

Casi di esempio

{} → 0

{0} → 0

{1} → 1

{0, 1, 1, 0, 0} → 0

{1, 1, 1, 0, 1} → 1

{1, 1, 0, 1, 1} → 2

{0, 0, 1, 1, 1} → 3

{1, 1, 1, 1, 1, 1} → 6

Dyalog APL, 6 2 byte

⊥⍨

Provalo su TryAPL .

Come funziona

⊥ (uptack, dyadic: decode) esegue la conversione di base. Se l'operando di sinistra è un vettore, esegue una conversione di base mista , il che è perfetto per questa attività.

Per un vettore di base b = b _n , ⋯, b ₀ e una cifra vettore a = a _n , ⋯, a ₀ , b ⊥ un converte un alla base mista b , cioè, calcola b ₀ ⋯ b _n-1 un _n + ⋯ + b ₀ b ₁ a ₂ + b ₀ a ₁ + a ₀ .

Ora, ⍨ (tilde dieresis, commute) modifica l'operatore a sinistra come segue. In un contesto monadico, chiama l'operatore con gli stessi argomenti sinistro e destro.

Ad esempio, ⊥⍨ a è definito come ⊥ a , che calcola uno ₀ ⋯ a _n + ⋯ + a ₀ a ₁ a ₂ + a ₀ a ₁ + a ₀ , la somma di tutti i prodotti cumulativi da destra a sinistra .

Per k trailing, i k prodotti più a destra sono 1 e tutti gli altri sono 0 , quindi la loro somma è uguale a k .

JavaScript (ES6), 21 byte

f=l=>l.pop()?f(l)+1:0

Casi test

f=l=>l.pop()?f(l)+1:0

console.log(f([])); // → 0
console.log(f([0])); // → 0
console.log(f([1])); // → 1
console.log(f([0, 1, 1, 0, 0])); // → 0
console.log(f([1, 1, 1, 0, 1])); // → 1
console.log(f([1, 1, 0, 1, 1])); // → 2
console.log(f([0, 0, 1, 1, 1])); // → 3
console.log(f([1, 1, 1, 1, 1, 1])); // → 6

Gelatina , 4 byte

ŒrṪP

Provalo online! oppure Verifica tutti i casi di test.

Nel caso in cui l'elenco sia vuoto, ci sono alcune curiose osservazioni. Innanzitutto, la codifica per lunghezza dell'elenco vuoto []restituisce un altro elenco vuoto []. Quindi riprendendo l'ultimo elemento da quello usando tail Ṫrestituisce 0invece di una coppia [value, count]che sono gli elementi regolari di una matrice codificata di lunghezza. Quindi, quando richiesto, il prodotto Prestituisce il risultato atteso.00

Spiegazione

ŒrṪP  Main link. Input: list M
Œr    Run-length encode
  Ṫ   Tail, get the last value
   P  Product, multiply the values together

Brachylog , 7 6 5 byte

@]#=+

Provalo online!

Spiegazione

@]        A suffix of the Input...
  #=      ...whose elements are all equal
    +     Sum its elements

Dal momento che @] - Suffixinizia dal suffisso più grande fino al più piccolo, troverà prima la corsa più lunga.

CJam (8 byte)

{W%0+0#}

Suite di test online

Dissezione

{    e# begin a block
  W%  e# reverse the array
  0+  e# append 0 so there's something to find
  0#  e# find index of first 0, which is number of nonzeros before it
}

Haskell, 26 25 byte

a%b|b=1+a|0<3=0
foldl(%)0

Uso:

Prelude> foldl(%)0 [True,False,True,True]
2

Versione senza punti (26 byte):

length.fst.span id.reverse

Utilizzando un elenco intero anziché un elenco bool (21 byte, grazie a Christian Sievers):

a%b=b*(a+1)
foldl(%)0

Uso:

Prelude> foldl(%)0 [1,0,1,1]
2

Versione senza punti (25 byte)

sum.fst.span(==1).reverse

Retina , 7 5 byte

r`1\G

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

La definizione del formato di input per Retina non è del tutto inequivocabile. Poiché Retina non ha alcun concetto di alcun tipo tranne le stringhe (e anche nessun valore che può essere usato per la nostra solita definizione di verità e falsità), di solito uso 0e 1(o qualcosa di positivo in generale) per corrispondere a verità e falsità, in quanto rappresentano zero o alcune corrispondenze, rispettivamente.

Con le rappresentazioni a carattere singolo, inoltre, non abbiamo bisogno di un separatore per l'elenco (che in un certo senso è più la rappresentazione dell'elenco più naturale per una lingua che ha solo stringhe). Adám ha confermato che si tratta di un formato di input accettabile.

Per quanto riguarda la regex stessa, si abbina da rdestra a sinistra e \Gancora ogni partita alla precedente. Quindi, questo conta quanti 1s possiamo abbinare dalla fine della stringa.

05AB1E , 12 10 6 5 byte

Salvato 1 byte grazie al carusocomputing .

Î0¡¤g

Provalo online!

Spiegazione

Î      # push 0 and input
 0¡    # split on 0
   ¤   # take last item in list
    g  # get length

Python, 31 byte

lambda a:(a[::-1]+[0]).index(0)

Gelatina , 4 byte

ṣ0ṪL

TryItOnline! o tutti i test

Come?

ṣ0ṪL - Main link: booleanList
ṣ0   - split on occurrences of 0 ([] -> [[]]; [0] -> [[],[]]; [1] -> [[1]]; ...)
  Ṫ  - tail (rightmost entry)
   L - length

MATL , 4 byte

PYps

Provalo online!

P       % Flip
 Yp     % Cumulative product
   s    % Sum

Mathematica, 25 24 byte

Fold[If[#2,#+1,0]&,0,#]&

Pyth, 6 byte

x_+0Q0

Provalo qui!

Aggiunge uno 0, inverte e trova l'indice del primo 0

C90 (gcc), 46 byte

r;main(c,v)int**v;{while(0<--c&*v[c])r++;c=r;}

L'input avviene tramite argomenti della riga di comando (un numero intero per argomento), output tramite il codice di uscita .

Provalo online!

Come funziona

r è una variabile globale. Il suo tipo di default è int e, essendo globale, il suo valore predefinito è 0 .

Anche l'argomento funzione c viene impostato su int . Conterrà l'intero n + 1 per le matrici di n booleani; il primo argomento di main è sempre il percorso dell'eseguibile.

L'argomento della funzione v è dichiarato come int**. Il tipo effettivo di v sarà char**, ma poiché esamineremo solo il bit meno significativo di ogni argomento per distinguere i caratteri 0 (punto di codice 48 ) e 1 (punto di codice 49 ), questo non importerà su little-endian macchinari.

Il ciclo while decrementa c e lo confronta con 0 . Una volta che c raggiunge 0 , usciremo dal ciclo. Ciò è necessario solo se l'array non contiene 0 .

Finché 0<--ci rendimenti 1 , si prende la c ^° argomento della riga di comando ( v[c]) ed estrarre il suo primo personaggio con dereferenziando il puntatore ( *). Prendiamo il bit bit AND del booleano 0<--ce il punto di codice del carattere (e tre byte di immondizia che lo seguono), quindi la condizione restituirà 0 una volta che si incontra uno 0 , uscendo dal ciclo.

Nel resto del caso, mentre gli argomenti della riga di comando sono 1 , r++incrementa r di 1 , contando così il numero di 1 finali .

Infine, c=rmemorizza il valore calcolato di r in c . Con le impostazioni predefinite, il compilatore ottimizza e rimuove l'assegnazione; in realtà genera l' movl %eax, -4(%rbp)istruzione. Poiché retrestituisce il valore del registro EAX, questo genera l'output desiderato.

Si noti che questo codice non funziona con C99, che restituisce 0 da main se viene raggiunta la fine di main .

k, 6 byte

+/&\|:

Questa composizione di funzioni si traduce in sum mins reversein q, il fratello più leggibile della lingua, dove min è un minimo continuo.

J, 9 3 byte

#.~

Questa è una conversione di base mista riflessiva. Perché è uguale alla conversione di base mista. Ancora.

Casi test

   v =: #.~
   ]t =: '';0;1;0 1 1 0 0;1 1 1 0 1;1 1 0 1 1;0 0 1 1 1;1 1 1 1 1 1
++-+-+---------+---------+---------+---------+-----------+
||0|1|0 1 1 0 0|1 1 1 0 1|1 1 0 1 1|0 0 1 1 1|1 1 1 1 1 1|
++-+-+---------+---------+---------+---------+-----------+
   v&.> t
+-+-+-+-+-+-+-+-+
|0|0|1|0|1|2|3|6|
+-+-+-+-+-+-+-+-+
   (,. v&.>) t
+-----------+-+
|           |0|
+-----------+-+
|0          |0|
+-----------+-+
|1          |1|
+-----------+-+
|0 1 1 0 0  |0|
+-----------+-+
|1 1 1 0 1  |1|
+-----------+-+
|1 1 0 1 1  |2|
+-----------+-+
|0 0 1 1 1  |3|
+-----------+-+
|1 1 1 1 1 1|6|
+-----------+-+

R, 40 39 25 byte

Soluzione completamente rielaborata grazie a @Dason

sum(cumprod(rev(scan())))

Leggi l'input da stdin, inverti il ​​vettore e se il primo elemento di viene !=0quindi emesso la prima lunghezza della codifica run-length ( rle), altrimenti 0.

Haskell, 24 byte

foldl(\a b->sum[a+1|b])0

Scorre l'elenco, aggiungendone uno per ogni elemento, ripristinandolo 0dopo che ha colpito a False.

16 byte con input 0/1:

foldl((*).(+1))0

Se l'elenco fosse garantito non vuoto, potremmo ottenere 14 byte:

sum.scanr1(*)1

Questo calcola il prodotto cumulativo dal retro, quindi li somma. Il prodotto cumulativo rimane 1 fino a quando non viene colpito uno 0, quindi diventa 0. Quindi, 1 corrisponde a 1 finali.

Pyke, 10 6 byte

_0+0R@

Provalo qui!

C # 6, 103 72 byte

using System.Linq;
int a(bool[] l)=>l.Reverse().TakeWhile(x=>x).Count();

L'uso dell'elenco non generico batte l'elenco generico di 1 byte lol

-31 byte grazie a Scott

Python, 37 byte

f=lambda l:len(l)and-~f(l[:-1])*l[-1]

DASH , 16 byte

@len mstr"1+$"#0

Non è la soluzione DASH più breve possibile, ma la soluzione DASH più breve possibile mi sta prendendo in giro. Sto pubblicando questo nuovo approccio al suo posto.

Uso:

(@len mstr"1+$"#0)"100111"

Spiegazione

@(                 #. Lambda
  len (            #. Get the length of the array after...
    mstr "1+$" #0  #. ... matching the argument with regex /1+$/
  )                #. * mstr returns an empty array for no matches
)

Scala, 25 byte

l=>l.reverse:+0 indexOf 0

Ungolfed:

l=>(l.reverse :+ 0).indexOf(0)

Inverte l'elenco, aggiunge uno 0 e trova il primo indice di 0, che è il numero di elementi prima del primo 0

Lotto, 57 byte

@set n=0
@for %%n in (%*)do @set/an=n*%%n+%%n
@echo %n%

Accetta input come parametri della riga di comando. Funziona moltiplicando l'accumulatore per il valore corrente prima di aggiungerlo, in modo che eventuali zeri nella riga di comando ripristinino il conteggio. Si noti che %%nnon è uguale alla variabile no %n%.

GolfSharp, 14 byte

n=>n.V().O(F);

Java 7, 62 byte

int c(boolean[]a){int r=0;for(boolean b:a)r=b?r+1:0;return r;}

Codice non testato e test:

Provalo qui.

class M{
  static int c(boolean[] a){
    int r = 0;
    for (boolean b : a){
      r = b ? r+1 : 0;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.print(c(new boolean[]{}) + ", ");
    System.out.print(c(new boolean[]{ false }) + ", ");
    System.out.print(c(new boolean[]{ true }) + ", ");
    System.out.print(c(new boolean[]{ false, true, true, false, false }) + ", ");
    System.out.print(c(new boolean[]{ true, true, true, false, true }) + ", ");
    System.out.print(c(new boolean[]{ true, true, false, true, true }) + ", ");
    System.out.print(c(new boolean[]{ false, false, true, true, true }) + ", ");
    System.out.print(c(new boolean[]{ true, true, true, true, true, true }));
  }
}

Produzione:

0, 0, 1, 0, 1, 2, 3, 6

Perl 5,10, 22 byte

21 byte + 1 byte per -aflag. Poiché l'espressione basata su regex è stata eseguita ...: p

I valori di input per l'array devono essere separati da uno spazio.

$n++while pop@F;say$n

Provalo online!

Perl, 22 byte

21 byte di codice + 1 byte per -pflag.

s/.(?=.*0)//g;$_=y;1;

Per eseguirlo:

perl -pE 's/.(?=.*0)//g;$_=y;1;' <<< "0 1 1 0 1 1 1"

(In realtà, il formato dell'ingresso non importa molto: 0110111, 0 1 1 0 1 1 1, [0,1,1,0,1,1,1]ecc sarebbe tutto il lavoro)

perl -pE '/1*$/;$_=length$&' <<< '0110111'

PHP, 50 byte

<?=strlen(preg_filter('/.*[^1]/','',join($argv)));

Stranamente il mio primo tentativo con un regex si è rivelato più breve del mio tentativo con array ...
Usa come:

php tt.php 1 1 0 1 1

Ruby 37 32 byte

->n{n.size-1-(n.rindex(!0)||-1)}

Crea una funzione anonima che trova l'istanza più a destra di un valore falso e conta la dimensione del subarray a partire da quel valore.

Usa !0come falso, poiché 0 sono valori di verità in Ruby. rindextrova l'ultimo indice di un valore in un array.

Utilizzo :

boolean_list = [true, false, false, true]
->n{n.size-1-(n.rindex(!0)||-1)}[boolean_list]

Restituisce 1

Se mi fosse permesso di passare una stringa di 0 e 1 come parametri della riga di comando (che non è il modo in cui ruby ​​rappresenta elenchi di booleani), potrei arrivare a 24:

$*[0]=~/(1*)\z/;p$1.size

Questo utilizza espressioni regolari e stampa la lunghezza della stringa restituita dall'espressione regolare /(1*)\z/, dove si \ztrova la fine della stringa. $*[0]è il primo argomento passato ed è una stringa di 0 e 1 secondi.

Uso:

trailing_truths.rb 011101

Restituisce 1.