소개

매년 Dyalog Ltd. 는 학생 경쟁을 개최합니다. 좋은 APL 코드 를 작성 해야 합니다. 이것은 올해 여덟 번째 문제의 언어에 구애받지 않는 코드-골프 판입니다.

본인은 대회의 원저자로부터이 과제를 게시 할 수있는 명시적인 허가를 받았습니다. 제공된 링크 를 따르고 저자에게 연락하여 자유롭게 확인 하십시오.

문제

부울 * 목록이 주어지면 첫 번째 Truthy 이후의 모든 진실을 "끄십시오".

진실이 없습니까? 문제 없어요! 수정되지 않은 목록을 반환하십시오.

예

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

[] → []

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

* 모든 진실은 동일해야하며 모든 거짓은 동일해야합니다. 여기에는 출력이 포함됩니다.

파이썬 2 , 35 바이트

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

온라인으로 사용해보십시오! 입력과 출력은 True / False 라인입니다.

Dennis의 솔루션을 기반으로 합니다 . 입력이 발생한 후의 변수 True를 재정의합니다 . 이렇게하면 추가 입력 이 평가되어 인쇄됩니다.FalseTrueTrueFalse

재정의는 True&=b<1즉 True = True & (b<1). 입력 b이 True이면 (b<1)False (이후 True==1) True가됩니다 False.

APL , 2 바이트

<\

"미만으로 스캔"기능을 평가합니다. 온라인으로 사용해보십시오!

설명

APL에서 연산자 \(스캔)는 제공된 함수를 사용하여 비어 있지 않은 각 배열 접두사를 오른쪽에서 줄입니다. 예를 들어, 배열이 주어지면 (길이 1의 접두사), (길이 2의 접두사 ) 및 ( 길이 2의 접두사 )를 0 1 0계산 하여 결과를 새 배열에 넣습니다. 괄호는 오른쪽에 연결됩니다. 하여 감소 의 결과에서 오른쪽 배열의 마지막 요소가 정확히 하고 나머지는 가장 좌측에 대응하는 프리픽스는 그래서 로 감소 하고 타인 .00<10<(1<0)<110110

Aceto , 19 17 바이트 비경쟁

새 버전 (17 바이트) :

이 새 버전은 한 번에 하나씩 문자를 사용하며 -F옵션으로 실행하는 것이 가장 좋습니다 . 이전 솔루션과 유사하지만 동일하지는 않습니다.

 >,
Op0
p|1u
,ip^

이전 답변 (19 바이트) :

(인터프리터에서 두 가지 버그를 수정해야했기 때문에 비 경쟁적)

|p1u
iOp<
|!`X
rd!r

이것은 상대적으로 잘 할 수있는 일을 강조하는 첫 번째 Aceto 답변입니다. "lists"는 입력 스트림이며, 줄당 하나의 입력, "1"은 true, "0"은 false이며 빈 문자열은 목록의 끝을 나타냅니다.

Aceto 프로그램은 왼쪽 하단에서 시작하여 오른쪽 하단에서 끝나는 Hilbert 곡선에서 실행됩니다. 먼저, 우리는 빈 문자열을 True로, 다른 모든 것을 False로 바꾸어 r문자열을 d만들고 , 복제하고, 부정합니다 ( !). 그런 다음 조건부 수평 미러 ( |)가 있습니다. 스택의 맨 위 요소가 사실이라면 수평으로 미러합니다. 이것은 문자열이 비어있을 때 발생합니다. 미러링을 수행하면에 착륙 X하여 통역사가 사망합니다.

그렇지 않으면 스택의 나머지 사본을 integer 로 변환하고 또 다른 조건부 수평 미러를 수행합니다. 이번에는 1이 true이고 0이 false이므로 (첫 번째) true 값이 표시되면 미러링합니다. 우리가 미러링하지 않으면 (0을 보았습니다) p스택에있는 것을 찢어 버리고 (스택이 비어 있기 때문에 0) O곡선 의 가장자리로 점프하여 시작하여 전체 프로세스를 다시 시작합니다.

그렇지 않으면, 우리가 1을 보았을 때, 우리 u는 힐버트 커브에서 움직이는 방향과 반대 인을 미러링하고 착륙했습니다 . 1p1을 인쇄하고 이제 O0을 보았을 때와 똑같이 진행하지만 "역방향 모드"이므로 원점이 오른쪽 하단 에 있으므로 점프합니다.

이제 우리는 r다른 문자열을 제거하고 무효화합니다. 문자열이 비어, 따라서 상위 스택 요소가 truthy 경우 `것 없는 다음 명령을 (탈출 X우리가 종료하게).

(문자열이 비어 있지 않은 경우) 그렇지 않으면, 우리는 할 을 탈출 X하고 무시합니다. 이 경우 왼쪽 ( <), print 0 (스택이 비어 있기 때문에 )으로 이동하여 다시 Origin으로 건너 뜁니다 .

자바 8, 24 19 바이트

Long::highestOneBit

이것이 합법적이기를 바랍니다. 입력 / 출력이 언어에서 참 / 거짓으로 평가할 필요가 없다는 인상을 받았습니다. 이진 표현에서 입력은 오래 걸리고 하나는 출력으로, 하나는 참이고 0은 거짓입니다. 예를 들어 이진 00101은 5이고 이진 00100 인 4를 반환합니다.

@puhlen 덕분에 5 바이트

레티 나 , 6 바이트

1>`1
0

온라인으로 사용해보십시오!

입력은 0s (거짓) 및 1s (참) 목록입니다.

모두 일치 1하고 첫 번째 항목 ( 1>)을 제외한 각각 을 a로 바꿉니다 0.

V , 7 바이트

f1òf1r0

온라인으로 사용해보십시오!

나의 첫번째 V 제출! \영형/

작동 원리

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

하스켈 , 25 바이트

익명 기능을 복용하고 목록 반환 Bool들.

로 사용하십시오 (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어떤 바뀝니다 True에들 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의 오른쪽에는 두 개가 다릅니다 (이제 왼쪽에 0이 아닌 요소의 합계를 추가하기 때문에). 따라서 +\=첫 번째 진리 요소까지 1을 포함하는 목록 (즉, 참)을 제공합니다. 마지막으로, 원래 목록을 가진 논리 AND 는 첫 번째 진실 요소 에 대해서만 1을 제공합니다 .

자바 스크립트 (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 답변 의 사소한 포트입니다 . 온라인으로 사용해보십시오!

파이썬, 58 바이트

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

경우 x[i]거짓 출력 거짓이고; 그렇지 않으면 요소 자체의 배열에서 첫 번째 요소인지 여부를 제공합니다.

PHP, 37 바이트

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

펄 5, 20 바이트

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

진실은 거짓 1이고 거짓은 ''(빈 문자열)입니다.

설명:

map리스트 it의 요소를 반복하고 @_, 인수는 서브 루틴에 전달되어 각 요소를 $ _로 로컬로 설정하고 각 요소에서 계산하는 반환 값의 배열을 반환합니다. 거짓 인 경우 와 사실 인 경우 $_&&!$x++출력 $_합니다 . (&&는 단락이므로 첫 번째 값이 될 때까지 실행되지 않습니다). 반환 (falsey이다) 그 다음 실행되는 첫 번째 시간마다 증가 (그래서 truthy 남아있다). 을 Negate , 그리고 그것이 falsey 이후 발생하고 처음 truthy 반환 그래서.$_!$x++!$x++$x++0!$x++

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

파이썬 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 플래그 (또는 BSD sed -E 플래그)

:
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 비트보다 작 으면 끝에 0 비트로 채워질 수 있습니다.

온라인으로 사용해보십시오 .

배치, 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

Brain-Flak , 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에게 특별한 감사를드립니다!

파이썬 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에서 첫 번째 값인 경우를 제외하고 s 의 목록 이해입니다 true.

이것은 조금 길어 보입니다 (그리고 그것은 나의 첫 번째 람다입니다). 골프하는 방법을 찾을 수 있다면 크게 감사하겠습니다!

뇌 - 플랙 , 146 144 바이트

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

온라인으로 사용해보십시오!

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

펄 5 , 12 바이트

10 바이트 코드 + 2 -pl.

$_&&=!$-++

온라인으로 사용해보십시오!