受我亲爱的朋友和同事的启发，并为之缅怀，

Dan Baronet，1956年-2016年。RIP

他为该任务找到了最短的APL解决方案：

任务

给定一个布尔列表，计算尾随真值的数量。

案例案例

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

⊥⍨

在TryAPL上进行测试。

这个怎么运作

⊥（uptack，dyadic：decode）执行基本转换。如果左操作数是向量，它将执行混合基数转换，非常适合此任务。

对于基本向量b = b _n，⋯，b ₀和一个数字向量a = a _n，⋯，a ₀，b⊥a将a转换为混合基b，即，计算b ₀ ⋯b _n-1 a _n +⋯+ b ₀ b ₁ a ₂ + b ₀ a ₁ + a ₀。

现在，⍨（波浪号降噪，上下班）将操作符修改为左侧，如下所示。在单子上下文中，它使用相等的左右参数调用运算符。

例如，⊥⍨一个被定义为一个⊥一个，它计算一个₀ ⋯一个_Ñ +⋯+一个₀一个₁一₂ +α ₀一个₁ +α ₀，所有累积的产品从向左右侧的总和。

对于k个尾随的乘积，k个最右边的乘积为1，所有其他乘积为0，因此它们的总和等于k。

JavaScript（ES6），21个字节

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

测试用例

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

果冻，4字节

ŒrṪP

在线尝试！或验证所有测试用例。

对于列表为空的情况，有一些奇怪的发现。首先，对空列表进行游程编码会[]返回另一个空列表[]。然后retreiving从使用尾部的最后一个元素Ṫ返回0，而不是一对[value, count]，其是一个游程长度编码的阵列中的常规元件。然后产品在被调用时P返回0，0这是预期的结果。

说明

Œ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字节

@]#=+

在线尝试！

说明

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

由于@] - Suffix从最大的后缀一直到最小的后缀，它将首先找到最长的运行时间。

CJam（8字节）

{W%0+0#}

在线测试套件

解剖

{    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字节

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

用法：

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

无点版本（26字节）：

length.fst.span id.reverse

使用整数列表而不是布尔列表（21个字节，感谢Christian Sievers）：

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

用法：

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

无点版本（25字节）

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

视网膜，7 5字节

r`1\G

在线尝试！（第一行启用换行分隔的测试套件。）

定义Retina的输入格式并非一模一样。由于视网膜除字符串外没有任何类型的概念（也没有可用于我们对真假的常规定义的值），因此我通常使用0和1（或通常是肯定的东西）来表示真假的，因为它们代表零或一些匹配项。

使用单字符表示形式时，我们也不需要列表的分隔符（从某种意义上说，对于只包含字符串的语言，列表分隔符更自然）。Adám确认这是可接受的输入格式。

至于正则表达式本身，它r从右到左\G匹配，并将每个匹配锚定到前一个。因此，这计算了1我们可以从字符串末尾匹配多少个s。

05AB1E，12 10 6 5字节

由于使用了carusocomputing，因此节省了1个字节。

Î0¡¤g

在线尝试！

说明

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

Python，31个字节

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

果冻，4 字节

ṣ0ṪL

TryItOnline！或所有测试

怎么样？

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

MATL，4个字节

PYps

在线尝试！

P       % Flip
 Yp     % Cumulative product
   s    % Sum

Mathematica，25个 24字节

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

Pyth，6个字节

x_+0Q0

在这里尝试！

附加一个0，反向查找前0的索引

C90（gcc），46个字节

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

输入是通过命令行参数（每个参数一个整数），输出是通过退出代码。

在线尝试！

这个怎么运作

r是全局变量。它的类型默认为int，并且是全局的，它的值默认为0。

函数参数c也默认为int。对于n个布尔数组，它将保存整数n +1。main的第一个参数始终是可执行文件的路径。

函数参数v声明为int**。的实际类型v会char**，但由于我们只检查每个参数的最低显著位告诉字符0（代码点48）和1（代码点49）分开，这并不重要的小尾数机器。

while循环递减c并将其与0比较。一旦c达到0，我们就会跳出循环。仅当数组不包含0时才需要。

只要0<--c返回1，我们就使用第c ^个命令行参数（v[c]），并通过取消引用指针（*）来提取其第一个字符。我们采取的按位与布尔的0<--c和字符（和随后的三项垃圾字节）的代码点，这样的情况会返回0一旦0遇到，打破循环。

在剩余的情况下，在命令行参数是1，r++递增- [R由1，从而计算后的次数1的。

最后，c=r将r的计算值存储在c中。使用默认设置，编译器将优化并删除分配。它实际上会生成movl %eax, -4(%rbp)指令。由于ret返回EAX寄存器的值，因此会生成所需的输出。

请注意，此代码并不能与C99，返回工作0从主如果年底主要到达。

k，6个字节

+/&\|:

该函数组合转换为sum mins reversein q，这是语言更易读的同级形式，其中mins是滚动最小值。

J，9 3个字节

#.~

这是自反的混合碱基转换。因为这与混合基准转换相同。 再次。

测试用例

   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字节

借助@Dason，完全重新设计了解决方案

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

从stdin读取输入，反转向量，如果!=0输出的第一个元素，则输出游程编码（rle）的第一个长度，否则输出0。

Haskell，24个字节

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

遍历列表，添加一个用于每个元素，复位到0它击中后False。

16个字节（使用0/1输入）：

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

如果列表被保证为非空，我们将获得14个字节：

sum.scanr1(*)1

这将从背面计算累积乘积，然后对其求和。累积乘积保持为1，直到命中0，然后变为0。因此，1对应于尾随的1。

Pyke，10 6个字节

_0+0R@

在这里尝试！

C＃6，103 72字节

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

使用非通用列表比通用列表快1字节大声笑

-31字节感谢Scott

Python，37个字节

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

DASH，16字节

@len mstr"1+$"#0

这不是最短的DASH解决方案，但是最短的DASH解决方案却困扰着我。我将这种新颖的方法代替了它。

用法：

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

说明

@(                 #. 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个字节

l=>l.reverse:+0 indexOf 0

取消高尔夫：

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

反转列表，追加一个0并找到第一个索引0，即第一个0之前的元素数

批次，57个字节

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

将输入作为命令行参数。通过将累加器乘以当前值然后再将其累加来工作，以便命令行中的任何零都将重置计数。请注意，%%n该变量与n或%n%变量不同。

GolfSharp，14个字节

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

Java 7，62字节

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

取消测试代码：

在这里尝试。

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

输出：

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

Perl 5.10，22个字节

21个字节+ 1个字节的-a标志。由于基于正则表达式的表达式已完成...：p

数组的输入值必须用空格分隔。

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

在线尝试！

Perl，22个字节

21个字节的代码+ 1个字节的-p标志。

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

运行它：

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

（实际上，输入的格式并不重要了很多：0110111，0 1 1 0 1 1 1，[0,1,1,0,1,1,1]等一切都能解决）

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

PHP，50个字节

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

古怪我第一次尝试用正则表达式比我尝试用数组原来短...
使用，如：

php tt.php 1 1 0 1 1

Ruby 37 32字节

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

创建一个匿名函数，该函数查找错误值的最右边实例，并计算从该值开始的子数组的大小。

它使用!0false，因为Ruby中的true值为0。rindex查找数组中值的最后一个索引。

用法：

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

返回 1

如果允许我将0和1的字符串作为命令行参数传递（这不是ruby表示布尔值列表的方式），我可以将其降低到24：

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

这使用正则表达式和打印由正则表达式返回字符串的长度/(1*)\z/，其中，\z是字符串的结尾。$*[0]是传递的第一个参数，是0和1的字符串。

用法：

trailing_truths.rb 011101

返回1。