介绍

每年，Dyalog有限公司都会举办一次学生比赛。面临的挑战是编写好的 APL代码。这是今年第八个问题的与语言无关的高尔夫版本。

我得到比赛原作者的明确许可，可以在此处发布此挑战。跟随提供的链接并与作者联系，以进行验证。

问题

给定布尔值列表，“关闭”第一个Truthy之后的所有Truthies。

没有真相吗？没问题！只需返回未修改的列表即可。

例子

[falsy,truthy,falsy,truthy,falsy,falsy,truthy] → [falsy,truthy,falsy,falsy,falsy,falsy,falsy]

[] → []

[falsy,falsy,falsy,falsy] → [falsy,falsy,falsy,falsy]

*您的所有真相必须相同，而您的所有虚假也必须相同。这包括输出。

Python 2，35个字节

while 1:b=input();print b;True&=b<1

在线尝试！输入和输出是对/错线。

基于Dennis的解决方案。重新定义变量True是False一个后True遇到输入。这样，的任何其他输入都True将评估为False原样并打印出来。

重定义为True&=b<1，即True = True & (b<1)。当输入b是True，则(b<1)是假的（因为True==1），所以True变得False。

APL，2个字节

<\

评估函数“使用小于扫描”。 在线尝试！

说明

在APL中，运算符\（扫描）使用提供的功能从右减少数组的每个非空前缀。例如，给定数组0 1 0，它计算0（长度为1的前缀），0<1（长度为2的0<(1<0)前缀）和（长度为2的前缀）并将结果放入新数组中；括号与右侧相关。<从右减少是1精确地确定数组的最后一个元素是什么时间1，其余元素是什么时候0，因此与最左边的前缀对应的前缀1减少为1，其余元素对应的前缀为0。

Aceto，19 17字节不竞争

新版本（17字节）：

此新版本一次只包含一个字符，最好使用该-F选项执行。它的工作原理与先前的解决方案相似，但并不相同：

 >,
Op0
p|1u
,ip^

旧答案（19个字节）：

（不竞争，因为我必须修复解释器中的两个错误）

|p1u
iOp<
|!`X
rd!r

我要说，这是Aceto的第一个回答，突出显示了它可以做得相对好。“列表”是输入流，每行一个输入，“ 1”代表真，“ 0”代表假，空字符串表示列表的末尾。

Aceto程序在希尔伯特曲线上运行，从左下角开始，到右下角结束。首先，我们遍历r一个字符串，d对它求偶，然后取反（!），将空字符串转换为True，将其他所有字符串转换为False。然后是一个有条件的水平镜像（|）：如果堆栈中的顶部元素是真实的，则水平镜像。当字符串为空时，会发生这种情况。如果我们进行镜像，我们将落在上X，这会杀死解释器。

否则，我们将堆栈上的剩余副本转换为integer并执行另一个条件水平镜像：这次，因为1为真，0为假，因此如果我们看到（第一个）真值，则进行镜像。如果我们不镜像（因此我们看到一个0）p，则将栈中的内容抹掉（由于栈为空，所以为零），然后跳转到O曲线的起点，从此处开始，再次开始整个过程​​。

否则，当我们看到1时，我们将镜像并着陆在上u，这会反转我们在希尔伯特曲线上移动的方向。1p打印一个1，现在我们继续前进，O如果我们看到一个0，我们将继续前进，但是由于我们处于“反转模式”，所以我们的原点在右下角，所以我们跳到那里。

现在，我们r吃掉另一个字符串，并将其取反。如果字符串为空，则顶部堆栈元素为true，`则不会转义下一个命令（X），使我们退出。

否则（如果字符串不为空），我们将转义X并忽略它。在这种情况下，我们转到左侧（<），为print 0（因为堆栈为空），然后跳回到Origin。

Java8，24 19个字节

Long::highestOneBit

希望这是合法的；我的印象是输入/输出不必在语言中评估为是/否。输入需要很长的时间，输出要输入一个，二进制表示中的一个为true，零为false。例如，二进制00101为5，将返回二进制4为100100。

五个字节感谢@puhlen

视网膜，6个字节

1>`1
0

在线尝试！

输入是0s（对于False）和1s（对于True）的列表。

匹配全部1并将第一个（1>）除外，每个都用替换0。

V，7个字节

f1òf1r0

在线尝试！

我的第一个V提交！\ o /

这个怎么运作

f1òf1r0
f1       "go to the next occurence of 1
  ò      "repeat the following until end:
   f1    "    go to the next occurence of 1
     r0  "    replace with 0

Haskell，25个字节

匿名函数获取并返回Bools 的列表。

用作(foldr(\x l->x:map(x<)l)[])[False,True,False,False]。

foldr(\x l->x:map(x<)l)[]

在线尝试！

这个怎么运作

• 从右边折叠一个列表，在新元素的前面加上可能修改的元素。
• x是要添加到子列表的元素l。
• 使用了False比较不足True，所以map(x<)l会变成任何TrueS IN l到False，如果x是True。

果冻，4字节

+\=a

在线尝试！

与大多数其他高尔夫语言解决方案相比，这是一种完全不同的算法（尽管在我发布它之后，我注意到R解决方案也使用此算法），并且与当前的Jelly唱片持有人并列。

说明

+\=a
+\    Cumulative sum of the input list
  =   Compare corresponding elements with the input
   a  Logical AND corresponding elements with the input

只要一个元素左侧的所有元素均为0，一个元素的累加总和就等于该元素本身。在第一个1的右边，这两个是不同的（因为我们现在在左边添加元素总数为非零）。因此，+\=给我们一个列表，其中包含1（即true）直到第一个true元素。最后，与原始列表进行逻辑与的操作只会为第一个真实元素提供1。

JavaScript（ES6），33 26字节

a=>a.map(e=>e&!(i-=e),i=1)

I / O为0和1的数组。

05AB1E，6个字节

码：

ā<s1kQ

说明：

ā         # External enumeration, get a and push [1 .. len(a)]
 <        # Decrement each
  s       # Swap to get the input
   1k     # Get the first index of 1
     Q    # Check for equality with the enumeration array

使用05AB1E编码。在线尝试！

图灵机模拟器，39个字节

0 0 0 r 0
0 1 1 r 1
1 0 0 r 1
1 1 0 r 1

在线尝试！

brainfuck，55个字节

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

在线尝试！

果冻，4字节

我的05AB1E答案的端口。

i1=J

说明（参数α）：

i1        # Index of 1 (1-indexed) in α
  =       # Check for equality with the array:
   J      # [1 .. len(α)]

在线尝试！

R，24个字节

cumsum(T<-scan(,F))==T&T

在线尝试！

例：

对于输入FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==T返回TRUE TRUE FALSE FALSE。扫描中的F确保逻辑输入。
FALSE TRUE TRUE FALSE并且TRUE TRUE FALSE FALSE是FALSE TRUE FALSE FALSE。单个&进行元素比较。

八度，23字节

@(a)diff([0 cummax(a)])

在线尝试！

列表的累积最大值的第一差。

J，3个字节

</\

定义单子动词。这是我的APL回答的一个小问题。 在线尝试！

Python，58个字节

lambda x:[x[i]and x.index(x[i])==i for i in range(len(x))]

如果x[i]为false，则输出为false；否则为false。否则，它给出元素是否是其自身数组中的第一个出现。

PHP，37字节

foreach($_GET as$v)echo$v*!$$v++,' ';

Perl 5，20个字节

sub{map$_&&!$x++,@_}

1Truthy 是，Falsey是''（一个空字符串）。

说明：

map循环遍历列表中的元素@_，并将参数传递给子例程，将每个元素本地设置为$ _，并返回从每个元素计算得出的返回值的数组。$_&&!$x++输出$_if是否$_为false和!$x++true。（请注意，&&短路，因此!$x++直到达到第一个真实值时才执行）。在第一次运行时$x++返回0（这是错误的），然后每次都递增（因此仍然是真实的）。该!则无效$x++，因此它返回truthy此后它被遇到并falsey第一次。

Pyth-9个字节

.e&b!s<Qk

在这里尝试

.e&b!s<Qk
.e          # Python's 'enumerate' (i.e., for each index k and each element b at that index)
      <Qk   # The first k elements of the input
     s      # 'Sum' these first k elements (with booleans, this is a logical 'or')
  &b!       # The value of the output at index k is [value of input @ index k]&&[the negation of the 'sum']

Python 2中，45 36个字节

r=0
while 1:n=input();print n>r;r+=n

输入和输出是每行一个布尔值（True或False）。

在线尝试！

C＃，77个字节

a=>{var b=1<0;for(int i=0;i<a.Length;){a[i]=b?1<0:a[i];b|=a[i++];}return a;};

编译为Func<bool[], bool[]>。真的没有什么聪明的，只是一个简单的解决方案。

sed，16 19字节

15 18个字节的源代码+ 1个字节用于-r标志（或-E标志用于BSD sed）。

:
s/1(0*)1/1\10/
t

在线尝试！

编辑：感谢赖利指出一个错误。

果冻，4 字节

TḊṬ^

在线尝试！

怎么样？

这确实是从字面意义上说的：

TḊṬ^ - Main link: list a   e.g. [0,1,0,1,0,0,1]  or  [0,1,0,1,0,1,0]
T    - get the truthy indexes   [  2,  4,    7]      [  2,  4,  6  ]
 Ḋ   - dequeue                  [      4,    7]      [      4,  6  ]
  T  - make a boolean array     [0,0,0,1,0,0,1]      [0,0,0,1,0,1  ]
   ^ - XOR that with a          [0,1,0,0,0,0,0]      [0,1,0,0,0,0,0]

c（含gcc内建程式），40

稍微不同的方法：

f(n){return!n?0:1<<31-__builtin_clz(n);}

这可能被裁定为无效-在这种情况下，我会很乐意将其标记为不竞争。

输入和输出“数组”是32位无符号整数-这将输入列表的大小限制为恰好为32-这可能是不合格的。如果输入少于32位长，则可以在末尾填充零位。

在线尝试。

批处理，85 73字节

:a
@(if %1.==. exit)&set/ar=(1-f)*%1
@echo %r%&set/af^|=%1&shift&goto a

将输入作为命令行参数。对于示例：1.bat 0 1 0 1 0 0 1

先前版本

@set f=1
:a
@(if %1.==. exit)&set/ar=f*%1
@echo %r%&(if %1==1 set f=)&shift&goto a

脑筋急转弯，230字节

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

我会尽快解释，但是我妈妈给我煮了一些炸土豆

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> Subtracts one from every item

({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{} Loops down stack until current item is zero and adds one

(([])<{{} (({})())({<{}>{}((<()>))}<{}{}>) ({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<> On every item of stack if it is 0 do nothing and if it is -1 add one

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

{}{} Remove the two zeros at top of stack

([]){{}({}<>)<>([])}{}<> Flip stack back

在线尝试！

特别感谢

特别感谢Wheat Wizard和Riley帮助我编写了大量代码！

Python 3，69 66 64 60 54 53字节

lambda i:[k==i.index(j)and j for k,j in enumerate(i)]

接受falses和trues 的数组。这是的列表理解，false除非当前迭代的值为，true并且它是true输入中的第一个。

这似乎有点长（这是我的第一个lambda），所以如果您能找到一种打高尔夫球的方法，将不胜感激！

Brain-Flak，146144字节

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

在线尝试！

# Reverse the stack and add a 1 between each to help with reversing later
([]){{}({}<>)(())<>([])}{}<>

# Add a 1 in case there aren't any truthy values (and another 1 like before)
((()))

# Reverse the stack back to it's original order using the 1s from earlier to know when to stop
{{}({}<>)<>}{}<>

# Push 1 to start the loop
(())

# Until we find the first 1
{

 # Pop the last value
 {}

 # Logical not
 ((){[()](<{}>)}{})

  # Put a 0 on the other stack
  (<>)<>

# end loop
}

# Put a 1 on the other stack
<>(())<>

# Push the stack height
([])

# While there are values on this stack
{

 # Move them to the other stack as a 0
 {}(<{}<>>)<>([])

# End while
}{}

# Pop an extra 0
{}

# Switch stacks
<>

# Copy everything back (to reverse it back to it's original)
([])
{
 {}({}<>)<>([])
}<>{}

Perl 5，12个字节

10个字节的代码+ 2个-pl。

$_&&=!$-++

在线尝试！