成为第一个(仅留下第一个Truthy)


47

介绍

每年,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]


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


2
我们可以使用我们选择的语言中更自然的位列表或其他真假列表表示吗?
马丁·恩德

1
是的,如果您在挑战中谈论“真实”和“虚假”,而不是“布尔值”,“真”和“假”。;)
Martin Ender's

1
我不清楚布尔值。即使我们的语言有对/错,我们也可以使用0/1吗?
xnor

1
@xnor啊,好点。我认为允许选择输入是公平的,但是输出必须匹配,您不这样认为吗?
阿达姆(Adám)'17年

1
@xnor,我听到了,但是如果Haskell无法将数字视为布尔值,或者不能对布尔值进行算术运算,那么这就是Haskell高尔夫能力的真正限制,应该通过进行转换或其他工作反映在字节数中-解决方法。您如何看待脚注的提法?
阿达姆(Adám)'17年

Answers:


36

Python 2,35个字节

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

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

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

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


19
您可以重新定义True ??? 仅仅因为hax> _>
HyperNeutrino,

1
@HyperNeutrino是的,但不是在Python 3中。(这很好,因为这里的语言是Python2。)
Brian McCutchon

@BrianMcCutchon好的,谢谢。不过,那真是奇怪……
HyperNeutrino

@HyperNeutrino您可以做的值得一提True, False = False, True
布赖恩·麦卡顿

1
@HyperNeutrino-不。内建函数仍会返回“真实”值,只是您键入的“ True”会发生变化。(或模块,在某些情况下...)。所以bool(1)返回True,但是bool(1)== True返回False。
TLW

30

APL,2个字节

<\

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

说明

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


最后!我一直在想。
2015年

现在我想你也可以用J回答,不是吗?
2015年

@Adám是的,在J中是3个字节:</ \ Jelly可能也有类似的2字节解决方案。
Zgarb

不,我不这么认为,因为果冻是从左到右。
阿达姆(Adám)'17年

您应该将单独的语言答案发布为单独的帖子。
2015年

22

Aceto19 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。


2
恭喜您在Aceto中解决了第一个适当的挑战。
2015年

2
看图。右...
亚当

1
@Adám单独使用它可能不会有所帮助(如果您不了解Aceto),但是我认为最好能与文本一起阅读以便更好地遵循它。
L3viathan '17

15

Java8,24 19个字节

Long::highestOneBit

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

五个字节感谢@puhlen


4
好的方法。Java具有竞争力

3
哇,JAVA是一个有竞争力的答案‽
Zacharý17年

不能完全确定这对于codegolf规则是否有效,但是可以通过使用方法引用将其提高到19个字符:Long::highestOneBit这将以较短的语法产生相同的结果
puhlen

允许对匿名函数求值的@puhlen表达式。
Cyoce

2
@NathanMerrill java.lang默认情况下导入软件包。在语言规范中, “编译单元可以自动访问其程序包中声明的所有类型,还可以自动导入预定义程序包java.lang中声明的所有公共类型。”
JollyJoker

12

视网膜,6个字节

1>`1
0

在线尝试!

输入是0s(对于False)和1s(对于True)的列表。

匹配全部1并将第一个(1>)除外,每个都用替换0


现在我可以看到它。您在某些操作系统的办公室中工作。一位经理大喊大叫,用正则表达式编写整个操作系统。
Christopher

10

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

这是如何运作的?
Brian McCutchon '17

@BrianMcCutchon添加了说明。
Leaky Nun

这对于第一个位置的1失败:(
nmjcman101 '17

@ nmjcman101已修复。
Leaky Nun

既然你改变了输入格式,你可以换r0<C-x>递减的人并保存一个字节。
nmjcman101

9

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 lFalse,如果xTrue

9

果冻,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。


8

JavaScript(ES6),33 26字节

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

I / O为0和1的数组。


8

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编码。在线尝试!


1k>sƶ-_是另一个,但更糟。这个lift想法可能有潜力。
魔术章鱼缸



4

果冻,4字节

我的05AB1E答案的端口。

i1=J

说明(参数α):

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

在线尝试!


4

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 FALSEFALSE TRUE FALSE FALSE。单个&进行元素比较。


@rturnbull不幸的是,输入格式必须与输出相同。
MickyT



3

Python,58个字节

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

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



3

Perl 5,20个字节

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

1Truthy 是,Falsey是''(一个空字符串)。

说明:

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


您的怀疑是合理的:您需要提交完整的功能(或完整的程序);这只是一个摘要(因此,如果没有,则无效sub{...})。
达达

2

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

1
这似乎是更有效地使用一个变量,只是映射在它正常:m&!~|Z
FryAmTheEggman'5


2

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[]>。真的没有什么聪明的,只是一个简单的解决方案。



2

果冻,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]

2

c(含gcc内建程式),40

稍微不同的方法:

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

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

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

在线尝试


2

批处理,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

2

脑筋急转弯,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帮助我编写了大量代码!


2

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),所以如果您能找到一种打高尔夫球的方法,将不胜感激!


你可以解释吗?
阿达姆(Adám)'17年

哦,糟糕,这个问题曲解了。
OldBunny2800'5

未删除和固定答案
OldBunny2800

您可以通过设置来保存一个字节0 for 0for
扎卡里

它适用于1if和1else,对吗?谢谢!
OldBunny2800 '17

2

Brain-Flak146144字节

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

在线尝试!

# 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)
([])
{
 {}({}<>)<>([])
}<>{}

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.