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

He found the shortest possible APL solution to this 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

• Can we take the list as a string of zeros and ones? e.g. 01100? Nov 6, 2016 at 12:57
• @Adnan only if that is the most normal way for your language to represent boolean lists.
Nov 6, 2016 at 15:42
• Sorry for your loss. Nov 6, 2016 at 17:03
• @MartinEnder Thank you. It will be tough going forward. Dan taught me all I needed to know to work for Dyalog.
Nov 6, 2016 at 17:32
• Farewell to Dan. RIP... Nov 7, 2016 at 12:46

# 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. • Once you have the index of the last false value, why do you need to retrieve elements from the array again? Nov 7, 2016 at 16:14 • You're right, I don't. Thanks. 5 bytes off! – IMP1 Nov 8, 2016 at 8:48 ## 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.) # 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) ,[>>,]>>+[<+[-<<+>>]<<<[-<+>>>-<<]<[->+<]>>>-]<-.  • ,[>,]-[>+<-----]>---[-<<[<]>[->]>]<<[>[-<+>]<<]>. – Jo King Oct 4, 2018 at 9:30 • @JoKing Go ahead and create your own answer. That doesn't resemble mine at all. Oct 4, 2018 at 16:28 # 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. • -4 Bytes for using $_GET May 3, 2017 at 13:32
• @JörgHülsermann That would have empty output for any list full of 1s. May 3, 2017 at 14:50
• Okay now I have realize it May 3, 2017 at 16:48

# 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. • How many stacks does Pushy have? Dec 7, 2016 at 17:09 • @KritixiLithos Two, input is automatically on stack 1 and that's where main operations take place. Stack 2 is just for storing counters / variables that need to be kept out of the way. Dec 7, 2016 at 17:15 # 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;


# 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. }


# Taxi, 15801576 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.)

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


# Vyxals, 2 bytes

Ġt


Try it Online!

Tied with first!

### Explained

Ġt∑
Ġ   # group by consecutive
t  # tail


s flag does sum.

# 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 $$\(x-1)p+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 $$\(x-1)p+1\$$ is $$\x^5 - x^4 + x^3\$$, whose valuation is $$\3\$$.

Try it online!

• Well, that is truly an original method. +1
Jul 13, 2017 at 5:47

# Raku, 17 bytes

{sum [\R*] 0,|@_}


Try it online!

• 0, |@_ is the input list of boolean values with a zero prepended to the front.
• R* is the Reversed multiplication operator. It's the same as the regular multiplication operator *, except that it's right-associative.
• [\R*] is the "triangular reduction" of the list to the right, using the R* operator. Given a list $$\x_0, x_1, ... x_n\$$, it produces $$\x_n, x_n \cdot x_{n-1}, x_n \cdot x_{n-1} \cdot x_{n-2}, ..., x_n \cdot x_{n-1} \cdot x_{n-2} \cdot ... \cdot x_0\$$. Raku's arithmetic operators treat boolean true values as 1 and false values as 0, so this produces a list that starts with as many ones as there are true values at the end of the list, followed by as many zeroes as there are remaining values in the list.
• sum adds up those values.

It's necessary to paste a leading zero onto the front of the input list, or else an empty list would produce the multiplicative identity element 1.

# Python2, 42 41 Byes

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


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

• No joy with the empty list test case. Nov 6, 2016 at 15:11

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

# Swift 3, 49 bytes

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


# 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


## PHP, 5854 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

• Assigning $i=0; is unnecessary if you echo/return +$i. Having this as a command line program rather than a function is much shorter as well, though you need to account for the fact that $argv[0] is truthy. With both of these you could save 19 bytes. Nov 7, 2016 at 16:50 • return+$i; needs no space. Dec 7, 2016 at 16:08

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

<?=strspn(strrev(join($_GET)),1);  Online Version strspn # Mathematica, 36 bytes Length[#/.({___,0,x___/;x==1}:>{x})]&  Not the shortest, but short enough where I was proud to submit it :) # 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  # Rust, 44 bytes |a|a.iter().rev().take_while(|&&i|i).count()  Try it online! explanation: |a|a.iter().rev().take_while(|&&i|i).count() //anonymous function |a|a.iter() //iterate over the input .rev() //reverse the iterator .take_while(|&&i|i) //take while **self is true .count() //Count the elements in the iterator  # Factor, 18 bytes [ [ ] count-tail ]  Attempt This Online! # Fig, $$\5\log_{256}(96)\approx\$$ 4.116 bytes Lt@x$


Try it online!

No "group consecutive," unlike most other golfing languages.

Lt@x # Reverse the list
t    # Take while
@x  # The identity function
L     # Return the length


# Nekomata + -1, 3 bytes

sP∑


Attempt This Online!

s       Find a suffix of the input
P      that contains only positive integers
∑     and sum them.


-1 prints the first solution.

# Thunno 2tS, 1 byte

ġ


Attempt This Online!

Or, if you want it flagless:

## Thunno 2, 3 bytes

ġtS


Attempt This Online!

#### Explanation

ġtS  # Implicit input
ġ    # Group consecutive
t   # Last item
S  # Sum
# Implicit output


# 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

• You use 3 chars for the conditional. Could you maybe multiply by the parity instead?
Jul 13, 2017 at 9:46
• @Adám that would still be 3 bytes, 2 bytes to get the parity (2%) and one byte to multiply (*) Jul 13, 2017 at 9:49

# 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


# Ohm v2, 5 bytes

Ö⁾ì]*


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

Try it online!

# 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