Count trailing truths

Question

Inspired by, and in memory of, my dear friend and colleague,

Dan Baronet, 1956 – 2016. R.I.P.

He found the shortest possible APL solution to this task:

Task

Given a Boolean list, count the number of trailing truth values.

Example cases

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

Answer 1

Dyalog APL, 6 2 bytes

⊥⍨

Test it on TryAPL.

How it works

⊥ (uptack, dyadic: decode) performs base conversion. If the left operand is a vector, it performs mixed base conversion, which is perfect for this task.

For a base vector b = b_n, ⋯, b₀ and a digit vector a = a_n, ⋯, a₀, b ⊥ a converts a to the mixed base b, i.e., it computes b₀⋯b_n-1a_n + ⋯ + b₀b₁a₂ + b₀a₁ + a₀.

Now, ⍨ (tilde dieresis, commute) modifies the operator to the left as follows. In a monadic context, it calls the operator with equal left and right arguments.

For example, ⊥⍨ a is defined as a ⊥ a, which computes a₀⋯a_n + ⋯ + a₀a₁a₂ + a₀a₁ + a₀, the sum of all cumulative products from the right to the left.

For k trailing ones, the k rightmost products are 1 and all others are 0, so their sum is equal to k.

Answer 2

JavaScript (ES6), 21 bytes

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

Test cases

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

Answer 3

Jelly, 4 bytes

ŒrṪP

Try it online! or Verify all test cases.

For the case where the list is empty, there are some curious observations. First, run-length encoding the empty list [] returns another empty list []. Then retreiving the last element from that using tail Ṫ returns 0 instead of a pair [value, count] which are the regular elements of a run-length encoded array. Then product P returns 0 when called on 0 which is the expected result.

Explanation

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

Answer 4

Haskell, 26 25 bytes

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

Usage:

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

Pointfree version (26 bytes):

length.fst.span id.reverse

---

Using an integer list instead of a bool list (21 bytes, thanks to Christian Sievers):

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

Usage:

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

Pointfree version (25 bytes)

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

Answer 5

Brachylog, 7 6 5 bytes

@]#=+

Try it online!

Explanation

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

Since @] - Suffix starts from the biggest suffix all the way up to the smallest one, it will find the longest run first.

Answer 6

CJam (8 bytes)

{W%0+0#}

Online test suite

Dissection

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

Answer 7

05AB1E, 12 10 6 5 bytes

Saved 1 byte thanks to carusocomputing.

Î0¡¤g

Try it online!

Explanation

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

Answer 8

Retina, 7 5 bytes

r`1\G

Try it online! (The first line enables a linefeed-separated test suite.)

Defining the input format for Retina isn't entirely unambiguous. Since Retina has no concept of any type except strings (and also no value that can be used for our usual definition of truthy and falsy), I usually use 0 and 1 (or something positive in general) to correspond to truthy and falsy, as they represent zero or some matches, respectively.

With single-character representations, we also don't need a separator for the list (which in a way, is more the more natural list representation for a language that only has strings). Adám confirmed that this is an acceptable input format.

As for the regex itself, it matches from right to left and \G anchors each match to the previous one. Hence, this counts how many 1s we can match from the end of the string.

Answer 9

Python, 31 bytes

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

Answer 10

Mathematica, 25 24 bytes

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

Answer 11

Jelly, 4 bytes

ṣ0ṪL

TryItOnline!, or all tests

How?

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

Answer 12

MATL, 4 bytes

PYps

Try it online!

P       % Flip
 Yp     % Cumulative product
   s    % Sum

Answer 13

Pyth, 6 bytes

x_+0Q0

Try it here!

Appends a 0, reverses and finds the index of the first 0

Answer 14

C90 (gcc), 46 bytes

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

Input is via command-line arguments (one integer per argument), output via exit code.

Try it online!

How it works

r is a global variable. Its type defaults to int and, being global, it value defaults to 0.

The function argument c defaults to int as well. It will hold the integer n + 1 for arrays of n Booleans; the first argument of main is always the path of the executable.

The function argument v is declared as int**. The actual type of v will be char**, but since we'll only examine the least significant bit of each argument to tell the characters 0 (code point 48) and 1 (code point 49) apart, this won't matter on little-endian machines.

The while loop decrements c and compares it to 0. Once c reaches 0, we'll break out of the loop. This is needed only if the array contains no 0's.

As long as 0<--c returns 1, we takes the c^th command-line argument (v[c]) and extract its first character with by dereferencing the pointer (*). We take the bitwise AND of the Boolean 0<--c and the code point of the character (and three garbage bytes that follow it), so the condition will return 0 once a 0 is encountered, breaking out of the loop.

In the remaining case, while the command-line arguments are 1, r++ increments r by 1, thus counting the number of trailing 1's.

Finally, c=r stores the computed value of r in c. With default settings, the compiler optimize and remove the assignment; it actually generates the movl %eax, -4(%rbp) instruction. Since ret returns the value of the EAX register, this generates the desired output.

Note that this code does not work with C99, which returns 0 from main if the end of main is reached.

Answer 15

R, 40 39 25 bytes

Completely reworked solution thanks to @Dason

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

Read input from stdin, reverse the vector and if the first element of is !=0 then output the the first length of the run-length encoding (rle), else 0.

Answer 16

k, 6 bytes

+/&\|:

This function composition translates to sum mins reverse in q, the language's more readable sibling, where mins is a rolling minimum.

Answer 17

J, 9 3 bytes

#.~

This is reflexive mixed base conversion. Because this is the same as mixed base conversion. Again.

Test cases

   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|
+-----------+-+

Answer 18

Pyke, 10 6 bytes

_0+0R@

Try it here!

Answer 19

Haskell, 24 bytes

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

Iterates over the list, adding one for each element, resetting to 0 after it hits a False.

16 bytes with 0/1 input:

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

If the list were guaranteed non-empty, we could get 14 bytes:

sum.scanr1(*)1

This computes the cumulative product from the back, then sums them. The cumulative product remains 1 until a 0 is hit, and then becomes 0. So, the 1's correspond to trailing 1's.

Answer 20

C#6, 103 72 bytes

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

Using non-generic list beats generic list by 1 byte lol

-31 bytes thanks to Scott

Answer 21

Pip, 8 bytes

WDQg++ii

Takes input as command-line arguments of 0 and 1 (or any truthy value). Try it online!

Explanation

          g is cmdline args, i is 0
 DQg      Dequeue item from end of g
W   ++i   While this is truthy, increment i
       i  Print i

(Dequeueing from an empty list gives nil, which is falsey.)

Answer 22

PHP, 40 34 bytes

Along with $argv comes $argc ... and both are variable.
Either one of the arguments or +$argv[0]==+"-" is 0.

while(+$argv[--$argc])$i++;echo$i;

takes input from command line arguments. Empty output for 0.
Run with php -nr '<code>' <space separated values>

unary output, 35 29 bytes

while(+$argv[--$argc])echo 1;

Answer 23

brainfuck, 99 bytes

Takes input like 11011. Output is a single byte/character value.

-[>+<-----]>---[>>,]<-[>+<-----]>---[-<+>>>+<<]<[->+<]>+>>+[<+[-<<+>>]<<<[-<+>>>-<<]<[->+<]>>>-]<-.

Try it online - Run with input, then click "view memory" to see the value under the pointer that was printed.

Explanation:

-[>+<-----]>---             put constant 48 (ASCII '0') at start of list
[>>,]                       receive all input, with an empty cell between each
<-[>+<-----]>---            constant 48 near end of list
[-<+>>>+<<]<[->+<]>+>>      move to right and copy right, add one to make 49 (ASCII '1')
                            TAPE: 48 _ i0 _ i1 _ ... in _ 49 _ 48< (pointer)

+[<+[-<<+>>]<<              LOOP. Put counter+=1 in empty cell. Move it left 2 cells.
<[-<+>>>-<<]<[->+<]>        Subtract value from value 2 cells right.
>>-]<-.                     Subtract one more. If zero, print counter-1, Else loop again.

---

Close, but must contain a zero, and it doesn't handle trailing zeros or an empty list. (49 bytes)

,[>>,]>>+[<+[-<<+>>]<<<[-<+>>>-<<]<[->+<]>>>-]<-.

Answer 24

Pushy, 6 bytes

$v;FL#

Arguments given a list on command line: $ pushy truths.pshy 0,1,1,0,0. Like my binary conversion program, this takes advantage of the second stack in an interesting way. Here's how it works:

         \ Implicit: Input on stack
$        \ While last item is not 0:
 v;      \   Move last item to auxiliary stack
   FL#   \ Output length of auxiliary stack.

Note that the loop will not run if the list is empty, so the output will be 0.

Answer 25

PHP, 38 bytes

a totally different approach

<?=strpos(strrev(join([0]+$argv)),48);

takes input from command line arguments. Save to file.

[0]+$argv sets the first element (script name) to 0.
Join that without a delimiter, reverse and find the first occurence of the 0 character.

While my first solution works with any truthy and falsy values, this one obviously depends on single characters: 0 is falsy, every other character (apart from maybe the 0 byte) truthy.

Answer 26

Japt -hx, 3 bytes

i ô

Try it online!

Japt's flag combinations rock.

How it works

Ui ô

Ui  Insert `undefined` at index 0
ô   Split at falsy items

-h  Take last element
-x  Sum

If we didn't have to handle the special case [], we could get away with 1 byte ô, winning over APL.

Answer 27

Taxi, 1580 1576 1564 bytes

-4 bytes because of a less complex route to the Crime Lab (string equality checker). Also, you don't run out of gas for a sufficiently large number of truthy values anymore!

-12 bytes by getting rid of the quotes.

Go to the Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to Chop Suey.
Go to Chop Suey:n 1 r 1 l 4 r 1 l.
[B]
Switch to plan C if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone:n 1 l 3 l.
Pickup a passenger going to Narrow Path Park.
Pickup a passenger going to Joyless Park.
Go to Zoom Zoom:n.
Go to Narrow Path Park:w 1 l 1 l 1 r.
Go to Joyless Park:e 1 r 3 l.
Go to Chop Suey:w 1 r 1 r 1 l.
Switch to plan B.
[C]
0 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 3 l 3 l 2 r.
Pickup a passenger going to Sunny Skies Park.
Go to Sunny Skies Park:w 1 r.
Go to Narrow Path Park:n 1 r 1 r 1 l 1 r.
[D]
Switch to plan F if no one is waiting.
Pickup a passenger going to Crime Lab.
1 is waiting at Writer's Depot.
Go to Writer's Depot:w 1 l 1 r 2 l.
Pickup a passenger going to Crime Lab.
Go to Zoom Zoom:n.
Go to Crime Lab:w 1 l 2 r.
Switch to plan E if no one is waiting.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s.
Pickup a passenger going to Addition Alley.
Go to Sunny Skies Park:n 1 l 1 l 1 r.
Pickup a passenger going to Addition Alley.
Go to Addition Alley:n 1 r 1 r 1 r.
Pickup a passenger going to Sunny Skies Park.
Go to Sunny Skies Park:n 1 l 1 l 1 l.
Go to Narrow Path Park:n 1 r 1 r 1 l 1 r.
Switch to plan D.
[E]
Go to Narrow Path Park:n 5 l.
[F]
Go to Sunny Skies Park:w 1 l 1 r 2 l 1 l.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s 1 l 1 r 1 r.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 l 1 r.
Go to Taxi Garage:n 1 r 1 l 1 r.

Input is in the form of a string of 0's and 1's (for example: 11101).

Try it online!

Taxi is an esolang in which all programming is done by picking up and dropping off passengers at various stops in the fictional town of Townsburg. Of course, your taxicab will sometimes run out of gas, so you also need to visit gas stations every so often, and pay using the credits you receive as fare.

I had to do some strange management of fuel in this program. Specifically, I have a loop at the beginning (between plans B and C) which pushes each character of the input to Narrow Path Park (which is a LIFO queue, or a stack) by going back and forth between Narrow Path Park and Chop Suey (which split the input string into characters in the first place). However, for sufficiently large inputs, this can cause me to run out of gas. Simply going to a gas station every iteration is insufficient, because I'm not earning enough money from actually bringing passengers to their destinations. The best way I've figured out to earn enough money to make going to a gas station every iteration "worth it" is bringing each new passenger to Cyclone (which clones them), and taking one of those clones to Narrow Path Park while leaving one forever trapped at Joyless Park (which is a FIFO queue, but for the purposes of this program is a dumping ground).

(Note: Bringing passengers to Riverview Bridge is a good way to get rid of them, but they don't pay you - because they always seem to fall off the bridge into the river before they can pay - so I couldn't do this either.)

Answer 28

Brain-Flak, 30 bytes

(()){{}({}{{}}<><{}>)<>([])}<>

Try it online!

Explanation

(()) #{ Start Loop.  Used instead of ([]) so that the loop will run at least once on empty input. }
{{}  #{Remove the stack height. }
 (
  {}{{}}  #{ Add the TOS with any 1s below it (until a zero). }
  <><{}>  #{ Remove a value on the other stack if there. }
 )     #{ Push the result (# of 1s just removed) to the other stack. } 
 <>    #{ Switch stacks back. }
 ([])  #{ Push stack height for the loop. }
}  #{ Once the loop is done (stack is empty)... }
<> #{ Switch stacks to the most recent # of 1s removed. }

Answer 29

Perl, 22 bytes

21 bytes of code + 1 byte for -p flag.

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

To run it :

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

(Actually, the format of the input doesn't matter a lot : 0110111, 0 1 1 0 1 1 1, [0,1,1,0,1,1,1] etc. would all work)

---

18 bytes version from @Dom Hastings but it requires to supply the input as a string of 0 and 1, which isn't allowed :

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

Answer 30

Python, 37 bytes

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

Answer 31

DASH, 16 bytes

@len mstr"1+$"#0

It's not the shortest possible DASH solution, but the shortest possible DASH solution is bugging out on me. I'm posting this novel approach in its place.

Usage:

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

Explanation

@(                 #. 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
)

Answer 32

Scala, 25 bytes

l=>l.reverse:+0 indexOf 0

Ungolfed:

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

Reverses the list, appends a 0 and find the first index of 0, which is the number of elements before the first 0

Answer 33

Batch, 57 bytes

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

Takes input as command-line parameters. Works by multiplying the accumulator by the current value before adding it on, so that any zeros in the command line reset the count. Note that %%n is not the same as the n or %n% variable.

Answer 34

GolfSharp, 14 bytes

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

Answer 35

Java 7, 62 bytes

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

Ungolfed & test code:

Try it here.

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

Output:

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

Answer 36

Perl 5.10, 22 bytes

21 bytes + 1 byte for -a flag. Since the regex-based expression was done... :p

The input values for the array must be separated by a space.

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

Try it online!

Answer 37

Ruby 37 32 bytes

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

Creates an anonymous function that finds the right-most instance of a false value, and counts the size of the subarray starting at that value.

It uses !0 as false, as 0 are truthy values in Ruby. rindex finds the last index of a value in an array.

Usage:

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

Returns 1

---

If I was allowed to be passed a string of 0s and 1s as command line parameters (which is not how ruby represents lists of booleans), I could get it down to 24:

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

This uses regular expressions and prints the length of the string returned by the regular expression /(1*)\z/, where \z is the end of the string. $*[0] is the first argument passed and is a string of 0s and 1s.

Usage:

trailing_truths.rb 011101

Returns 1.

Answer 38

C++17, 82 66 bytes

int f(){return 0;}int f(int H,auto... L){return(H*...*L)+f(L...);}

Uses the C++17 template parameter fold expression and essentially the same idea as Dennis. Saving 16 bytes by using Generic Variadic Lambda.

Explanation:

int f(){return 0;} //base case for empty list

int f(int H, auto... L) { //first element, variadic arguments
    return (H*...*L)      //a_0*a_1*a_2*...
         + f(L...);       //+ f(a_1,a_2,...)
}

Usage:

f(1,1,0,1,1,0,1,1,1,1,1) -> 5
f() -> 0
f(1,0,1,0) -> 0

Non competing

Albeit longer, this also works with template constants:

template <int...L> int C=0;
template <int H, int...L> int C<H,L...> = (H*...*L)+C<L...>;

Usage:

std::cout << C<1,0,1,1>  << std::endl;
std::cout << C<1,0,1,0,1>  << std::endl;
std::cout << C<1,1,1,0,1,0,1,1>  << std::endl;
std::cout << C<1,1,1,0,1,0,1,1,1,1,1,1>  << std::endl;
std::cout << C<> << std::endl;

Answer 39

PHP, 50 bytes

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

Weirdly my first try with a regex turned out shorter than my try with arrays...
Use like:

php tt.php 1 1 0 1 1

Answer 40

Swift 3, 49 bytes

func a(b:[Bool]){print(b.reduce(0,{$1 ?$0+1:0}))}

Answer 41

Minkolang, 32 bytes

0$nI1-[1=?v0g1+1R]N.
      .Ng0<

Try it online!

Explanation

0                             pushes 0 (this is the number that will keep track of the number of 1s)
 $n                           pushes all of input as numbers (pushes -1 if there is no input)
   I1-                        pushes stack minus 1 (to exclude the 0)
      [          ]            for loop with the previous number as the number of iterations
       1=?                     check equality with 1 (this is for the empty input testcase)
                               where -1 will be pushed by the interpreter

If number is not 1 (ie 0 or -1[-1 will be pushed if there is no input]):

         <                     start going left
       g0                      gets the first element in stack
     .N                       output it as number and stop program

If number is 1:

          v                    gets jumped over by ? since true has been evaluated
           0g1+                gets the first element and adds 1 to it
               1R              rotates stack once clockwise
                  N.          outputs as number and stops program

Answer 42

Clojure, 39 36 bytes

#(count(take-while{1 1}(reverse %)))

Input as integers [1 0 1 1 0 1 1 1], anything other than 1 is falsy. {1 1} is a hash-map with key 1 and value 1 which can also used as a function. For example ({1 999} 1) is 999 (truthy) whereas ({1 999} 0) is nil (falsy).

Original, based on booleans:

#(count(take-while(fn[i]i)(reverse %)))

Amazing how (fn[i]i) is shorter than identity and also doesn't force you to put a space after take-while. Must take a list or vector of booleans, integers can be converted like this: (map #(= 1 %) [1 0 1 1 0 1 1 1])

Answer 43

PHP, 33 Bytes

<?=strspn(strrev(join($_GET)),1);

Online Version

strspn

Answer 44

Pari/GP, 30 bytes

p->valuation(Pol(p)*(x-1)+1,x)

Converts the list to a polynomial, say p, then finds the valuation of p*(x-1)+1 with respect to x, i.e., the minimal degree of its nonzero terms.

For example, if we take [1, 0, 1, 1, 1] as input, then the polynomial p is x^4 + x^2 + x + 1, and p*(x-1)+1 is x^5 - x^4 + x^3, whose valuation is 3.

Try it online!

Answer 45

brainfuck, 33 bytes

,[+++>-[<->-----],]<[>[-<+>]<<]>.

Try it online!

Takes input via a string like 101011, and then outputs via byte value. I've added some code in the footer to add 48 to the value to output a digit.

 ,[  Loop over input
   +++>-[<->-----]  Subtract 48 from each value to form a tape of 0s and 1s
 ,]
 <[>[-<+>]<<]   Add up all the trailing ones
 >.             And print the value

Answer 46

Python2, 42 41 Byes

t=input()[::-1];print len(t[:t.index(0)])

takes input as [1, 1, 0, 1, 1]

Answer 47

ABCR, 14 bytes

c7iA)7a!xcx!Bp

Accepts the formatting [0,1,0,1,0, where any non-numeric character can be replaced with any other non-numeric character. Empty input is the empty list.

Explanation: Every 7 input number i is queued up A; every "0" input number (or rather, non-"1") )7 will pop from the queue until it's empty 7a!x; before another input number is queued, a delimiter character is grabbed cx to check for the end of queue. After all the integers are grabbed, !Bp prints the length of the queue of input numbers (which will be all the trailing "1" values.)

Answer 48

PHP, 58 54 53 bytes

function f($a){while(array_pop($a))$i++;return+$i;}

Since PHP has no list I use an array instead

-4 bytes thanks to user59178

All tests

Answer 49

Braingolf, 7 bytes

!?&gGL|

Try it online!

Explanation

!?&gGL|  Implicit input from commandline args
!?       If last item on stack is > 0..
  &g     ..Combine all items into single number (1, 1, 0, 1 becomes 1101)
    G    ..Split into digit runs (1101 becomes 11, 0, 1)
     L   ..Pop last item and push length of item (111 becomes 3)
      |  Endif
         Implicit output of last item on stack, either number of trailing ones, or zero

Answer 50

Backhand, 17 bytes

v I^: ]|{]1$|{O @

Try it online!

Explanation:

v I^: ]|{]1$|{O @
v                  Decrease step value to 2
  I                Get input as a number
    : ]|{          Reflect if not EOF
   ^               Increase step value to 3
v                  Decrease to 2 and repeat the loop
         ]         The leftover EOF (-1) is now our counter. Increment it to 0
           $|{     Reflect if the top value is truthy
       |{ 1        Reflect and repeat
         ]         Increment the counter for every truthy value
              O @  Output the final state of the counter

Answer 51

Ohm v2, 5 bytes

Ö⁾ì]*

RLE encodes the string, takes the last element, flattens, and multiplies

Try it online!

Answer 52

Mathematica, 36 bytes

Length[#/.({___,0,x___/;x==1}:>{x})]&

Not the shortest, but short enough where I was proud to submit it :)

Answer 53

V, 7 bytes

Ó1*0
ø1

Try it online! Takes input as a string of 0 and 1.

Explanation

Ó1*0     Remove all occurences of any number of ones followed by a zero
ø1       Count the number of remaining ones

Answer 54

MBASIC, 112 bytes

1 INPUT B$:T=0:FOR I=LEN(B$) TO 1 STEP -1:C$=MID$(B$,I,1):IF C$="0" THEN 4
2 IF C$="1" THEN T=T+1
3 NEXT
4 PRINT T

Just wanted to see if I could do it.

Explanation

Input is a string of 1's and 0's. String is traversed from right to left. If the current digit is a 0, bail out and print the total. If the digit is a 1, increment the total and continue to loop.

Output

? 01100
 0

? 11011
 2

? 11101
 1

? 111111
 6