Giới thiệu

Hàng năm, Dyalog Ltd. tổ chức một cuộc thi sinh viên. Thách thức ở đây là viết mã APL tốt . Đây là một phiên bản golf- bất khả tri ngôn ngữ của vấn đề thứ tám trong năm nay.

Tôi có sự cho phép rõ ràng để đăng thử thách này ở đây từ tác giả ban đầu của cuộc thi. Vui lòng xác minh bằng cách theo liên kết được cung cấp và liên hệ với tác giả.

Vấn đề

Đưa ra một danh sách Boolean *, "tắt" tất cả các Sự thật sau Sự thật đầu tiên.

Không có sự thật? Không vấn đề gì! Chỉ cần trả lại danh sách không thay đổi.

Ví dụ

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

[] → []

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

* Tất cả các sự thật của bạn phải giống hệt nhau và tất cả các giả mạo của bạn phải giống hệt nhau. Điều này bao gồm đầu ra.

Python 2 , 35 byte

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

Hãy thử trực tuyến! Đầu vào và đầu ra là các dòng True / false.

Dựa trên giải pháp của Dennis . Xác định lại biến Truelà Falsesau khi Truegặp đầu vào. Bằng cách đó, bất kỳ đầu vào tiếp theo nào Truesẽ đánh giá Falsevà được in như vậy.

Định nghĩa lại là True&=b<1, tức là True = True & (b<1). Khi đầu vào blà True, sau đó (b<1)là Sai (kể từ đó True==1), do đó Truetrở thành False.

APL , 2 byte

<\

Đánh giá chức năng "quét sử dụng ít hơn". Hãy thử trực tuyến!

Giải trình

Trong APL, toán tử \(quét) giảm từng tiền tố không trống của một mảng từ bên phải bằng cách sử dụng hàm được cung cấp. Ví dụ, đưa ra mảng0 1 0 , nó tính toán 0(tiền tố của độ dài 1), 0<1(tiền tố của độ dài 2) và 0<(1<0)(tiền tố của độ dài 2) và đặt kết quả vào một mảng mới; các dấu ngoặc đơn liên kết với bên phải. Việc giảm <từ bên phải dẫn đến kết quả 1chính xác khi phần tử cuối cùng của mảng 1và phần còn lại là 0, do đó tiền tố tương ứng với ngoài cùng bên trái 1được giảm xuống 1và các phần tử khác 0.

Aceto , 19 17 byte không cạnh tranh

Phiên bản mới (17 byte):

Phiên bản mới này lấy từng ký tự một và được thực hiện tốt nhất với -F tùy chọn. Nó hoạt động tương tự, nhưng không giống với giải pháp trước đó:

 >,
Op0
p|1u
,ip^

Câu trả lời cũ (19 byte):

(Không cạnh tranh vì tôi phải sửa hai lỗi trong trình thông dịch)

|p1u
iOp<
|!`X
rd!r

Đây là câu trả lời Aceto đầu tiên nêu bật những gì nó có thể làm tương đối tốt, tôi muốn nói. "Danh sách" là các luồng đầu vào, với một đầu vào trên mỗi dòng, "1" cho đúng và "0" cho sai, với một chuỗi trống biểu thị phần cuối của danh sách.

Các chương trình Aceto chạy trên đường cong Hilbert, bắt đầu ở phía dưới bên trái và kết thúc ở phía dưới bên phải. Đầu tiên, chúng ta đọc rmột chuỗi d, tăng và phủ định (! ) nó, biến các chuỗi rỗng thành True, mọi thứ khác thành Sai. Sau đó, có một gương ngang có điều kiện ( |): Nếu phần tử trên cùng của ngăn xếp là trung thực, hãy nhân bản theo chiều ngang. Điều này xảy ra khi chuỗi rỗng. Nếu chúng ta phản chiếu, chúng ta sẽ hạ cánh X, cái đó giết chết người phiên dịch.

iMặt khác, chúng tôi chuyển đổi bản sao còn lại trên ngăn xếp thành nteger và thực hiện một gương ngang có điều kiện khác: Lần này, vì 1 là trung thực và 0 là giả, chúng tôi phản chiếu nếu chúng ta thấy giá trị thật (đầu tiên). Nếu chúng ta không phản chiếu (vì vậy chúng ta đã thấy 0), chúng tap xé những gì trên ngăn xếp (vì ngăn xếp trống, không) và nhảy đến Ođường cong gốc, nơi chúng ta bắt đầu, bắt đầu lại toàn bộ quá trình.

Mặt khác, khi chúng ta nhìn thấy 1, chúng ta phản chiếu và hạ cánh trên u, đảo ngược hướng chúng ta di chuyển trên đường cong Hilbert. 1pin 1 và bây giờ chúng ta sẽ tiếp tục như vậy Onếu chúng ta đã thấy 0, nhưng vì chúng ta đang ở "chế độ đảo ngược", nguồn gốc của chúng ta ở phía dưới bên phải , vì vậy chúng ta nhảy đến đó.

Bây giờ chúng tôi đọc rmột chuỗi khác, và phủ nhận nó. Nếu chuỗi trống và do đó, phần tử ngăn xếp trên cùng là trung thực, `sẽ không thoát lệnh tiếp theo ( X), khiến chúng ta thoát.

Nếu không (nếu chuỗi không có sản phẩm nào), chúng tôi làm thoát khỏi Xvà bỏ qua nó. Trong trường hợp đó, chúng ta đi sang trái ( <), print 0 (vì ngăn xếp trống) và nhảy trở lại Origin.

Java8, 24 19 byte

Long::highestOneBit

Hy vọng điều này là hợp pháp; Tôi có ấn tượng rằng đầu vào / đầu ra không phải đánh giá là đúng / sai trong ngôn ngữ. Mất một thời gian dài như đầu vào và đưa ra một đầu ra, với đầu ra là đúng và các số 0 là sai trong biểu diễn nhị phân. Ví dụ: nhị phân 00101 là 5 và sẽ trả về nhị phân 00100 là 4.

Năm byte nhờ @puhlen

Võng mạc , 6 byte

1>`1
0

Hãy thử trực tuyến!

Đầu vào là danh sách 0s (cho Sai) và 1s (cho True).

Khớp tất cả 1và thay thế từng cái trừ cái đầu tiên ( 1>) bằng a 0.

V , 7 byte

f1òf1r0

Hãy thử trực tuyến!

Trình V đầu tiên của tôi! \ o /

Làm thế nào nó hoạt động

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 byte

Hàm ẩn danh lấy và trả về một danh sách Bools.

Sử dụng như (foldr(\x l->x:map(x<)l)[])[False,True,False,False].

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

• Gấp qua một danh sách từ bên phải, chuẩn bị các yếu tố mới và có thể sửa đổi những yếu tố sau.
• xlà yếu tố được thêm vào danh sách phụ l.
• Sử dụng Falseso sánh ít hơn True, vì vậy map(x<)lsẽ biến bất kỳ Trues lthành Falsenếu xcó True.

Thạch , 4 byte

+\=a

Hãy thử trực tuyến!

Đây là một thuật toán khá khác biệt với hầu hết các giải pháp ngôn ngữ chơi gôn khác (mặc dù sau khi tôi đăng nó, tôi nhận thấy rằng giải pháp R cũng sử dụng thuật toán này) và buộc với người giữ bản ghi Jelly hiện tại.

Giải trình

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

Miễn là tất cả các phần tử ở bên trái của một phần tử là 0, tổng tích lũy cho đến một phần tử sẽ bằng chính phần tử đó. Ở bên phải của 1 đầu tiên, hai cái này khác nhau (vì chúng ta hiện đang thêm tổng số phần tử khác không vào bên trái). Do đó, +\=cung cấp cho chúng tôi một danh sách chứa 1 (tức là đúng) cho đến và bao gồm cả phần tử trung thực đầu tiên. Cuối cùng, logic VÀ với danh sách ban đầu sẽ cho chúng ta 1 chỉ cho yếu tố trung thực đầu tiên.

JavaScript (ES6), 33 26 byte

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

I / O nằm trong mảng 0 và 1.

05AB1E , 6 byte

Mã số:

ā<s1kQ

Giải trình:

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Trình mô phỏng máy Turing , 39 byte

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

Hãy thử trực tuyến!

Brainfuck , 55 byte

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

Hãy thử trực tuyến!

Thạch , 4 byte

Một cổng của câu trả lời 05AB1E của tôi.

i1=J

Giải thích (đối số α ):

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

Hãy thử trực tuyến!

R , 24 byte

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

Hãy thử trực tuyến!

Thí dụ:

Đối với FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tlợi nhuận đầu vào TRUE TRUE FALSE FALSE. F trong quá trình quét đảm bảo đầu vào hợp lý.
FALSE TRUE TRUE FALSEvà TRUE TRUE FALSE FALSElà FALSE TRUE FALSE FALSE. Một đơn &làm một so sánh yếu tố.

Octave, 23 byte

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

Hãy thử trực tuyến!

Sự khác biệt đầu tiên của tích lũy tối đa của danh sách.

J , 3 byte

</\

Xác định một động từ đơn âm. Đây là một cổng tầm thường trong câu trả lời APL của tôi . Hãy thử trực tuyến!

Python, 58 byte

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

Nếu x[i]sai, đầu ra là sai; mặt khác, nó cho biết phần tử có xuất hiện đầu tiên trong mảng của chính nó hay không.

PHP, 37 byte

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

Perl 5, 20 byte

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

Truthy là 1và falsey là ''(một chuỗi trống).

Giải trình:

maplặp lại các phần tử của danh sách @_, các đối số được truyền cho chương trình con, đặt từng phần tử thành $ _ cục bộ và trả về một mảng các giá trị trả về mà nó tính toán từ mỗi phần tử. $_&&!$x++đầu ra $_nếu $_là falsey và !$x++nếu nó là sự thật. (Lưu ý rằng && là ngắn mạch, do đó !$x++không được thực thi cho đến khi đạt được giá trị trung thực đầu tiên). $x++trả về 0(đó là falsey) lần đầu tiên nó được chạy và sau đó tăng dần mỗi lần (và do đó vẫn còn đúng). Các !phủ định $x++, và do đó, nó trở lại sự thật ngay lần đầu tiên gặp phải và falsey sau đó.

Pyth - 9 byte

.e&b!s<Qk

Hãy thử nó ở đây

.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 byte

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

Đầu vào và đầu ra là một Boolean ( Đúng hoặc Sai ) trên mỗi dòng.

Hãy thử trực tuyến!

C #, 77 byte

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

Biên dịch thành a Func<bool[], bool[]>. Không có gì thông minh thực sự, chỉ là một giải pháp thẳng về phía trước.

sed , 16 19 byte

15 mã nguồn 18 byte + 1 byte cho cờ -r (hoặc cờ -E cho BSD sed).

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

Hãy thử trực tuyến!

Chỉnh sửa: Cảm ơn Riley đã chỉ ra một sai lầm.

Thạch , 4 byte

TḊṬ^

Hãy thử trực tuyến!

Làm sao?

Điều này thực hiện những gì đã được hỏi theo nghĩa đen:

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 (với nội dung gcc), 40

Một cách tiếp cận hơi khác:

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

Điều này có thể bị quy định không hợp lệ - trong trường hợp đó tôi sẽ vui vẻ đánh dấu điều này là không cạnh tranh.

"Mảng" đầu vào và đầu ra là các số nguyên không dấu 32 bit - điều này giới hạn kích thước danh sách đầu vào là chính xác 32 - đây có thể là một bộ khử. Nếu đầu vào dài dưới 32 bit, thì nó có thể được đệm bằng 0 bit ở cuối.

Hãy thử trực tuyến .

Hàng loạt, 85 73 byte

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

Đưa đầu vào làm đối số dòng lệnh. Đối với eample:1.bat 0 1 0 1 0 0 1

Phiên bản trước

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

Brain-Flak , 230 byte

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

Tôi sẽ giải thích sớm nhưng mẹ tôi nấu cho tôi vài củ khoai tây chiên

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

Hãy thử trực tuyến!

Cảm tạ

Đặc biệt cảm ơn Wheat Wizard và Riley đã giúp tôi rất nhiều với mã!

Python 3, 69 66 64 60 54 53 byte

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

Có một mảng falses và trues. Đây là một sự hiểu biết danh sách của falses trừ khi giá trị của lần lặp hiện tại là truevà nó là lần đầu tiêntrue trong đầu vào.

Điều này có vẻ hơi dài (và đó là lambda đầu tiên của tôi), vì vậy nếu bạn có thể tìm cách chơi golf, nó sẽ được đánh giá rất cao!

Brain-Flak , 146 144 byte

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

Hãy thử trực tuyến!

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

Mã 10 byte + 2 cho -pl.

$_&&=!$-++

Hãy thử trực tuyến!