Giới thiệu và tín dụng

Hôm nay không có khúc dạo đầu lạ mắt: Hãy thực hiện takewhile.

Một biến thể của điều này (trên một cấu trúc dữ liệu không tầm thường) là một bài tập tại khóa học lập trình chức năng của trường đại học của tôi. Nhiệm vụ này hiện đang đóng cửa và đã được thảo luận trong lớp và tôi được sự cho phép của giáo sư của tôi để đăng nó ở đây (tôi đã hỏi rõ ràng).

Đặc điểm kỹ thuật

Đầu vào

Đầu vào sẽ là một danh sách (hoặc khái niệm tương đương với ngôn ngữ của bạn) về các số nguyên dương.

Đầu ra

Đầu ra phải là một danh sách (hoặc khái niệm tương đương với ngôn ngữ của bạn) về các số nguyên dương.

Phải làm sao

Nhiệm vụ của bạn là triển khai takewhile(ngôn ngữ tích hợp được cho phép) với vị từ rằng số đang được xem xét là chẵn (để tập trung vào thời gian).

Vì vậy, bạn lặp lại danh sách từ đầu đến cuối và trong khi điều kiện (là chẵn) giữ, bạn sao chép vào danh sách đầu ra và ngay khi bạn nhấn một phần tử không làm cho điều kiện đúng, bạn hủy bỏ thao tác và đầu ra (một ví dụ từng bước dưới đây). Chức năng bậc cao này cũng được gọi là TakeWhile ( takewhile).

Trường hợp góc tiềm năng

Thứ tự của danh sách đầu ra so với danh sách đầu vào có thể không được thay đổi, ví dụ [14,42,2]có thể không trở thành [42,14].

Danh sách trống là một đầu vào và đầu ra hợp lệ.

Ai thắng?

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Quy tắc tiêu chuẩn áp dụng tất nhiên.

Kiểm tra vectơ

[14, 42, 2324, 97090, 4080622, 171480372] -> [14, 42, 2324, 97090, 4080622, 171480372]
[42, 14, 42, 2324] -> [42, 14, 42, 2324]
[7,14,42] -> []
[] -> []
[171480372, 13, 14, 42] -> [171480372]
[42, 14, 42, 43, 41, 4080622, 171480372] -> [42, 14, 42]

Ví dụ từng bước

Example Input: [42, 14, 42, 43, 41, 4080622, 171480372]

Consider first element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42]

Consider second element: 14
14 is even (7*2)
Put 14 into output list, output list is now [42,14]

Consider third element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42,14,42]

Consider fourth element: 43
43 is not even (2*21+1)
Drop 43 and return the current output list

return [42,14,42]

Toán học, 18 byte

#~TakeWhile~EvenQ&

Một tích hợp vinh quang khác bị đánh bại bởi hệ số 3 bằng các ngôn ngữ chơi gôn mà không có ...

Haskell, 13 byte

fst.span even

spanchia danh sách đầu vào thành một cặp danh sách ngay trước phần tử đầu tiên có vị ngữ (-> even) sai. fstlấy yếu tố đầu tiên của cặp.

Phiên bản thay thế, 13 byte:

fst.break odd

breaklà đối diện của span, tức là nó phân chia danh sách ở phần tử đầu tiên trong đó vị từ là đúng.

Tất nhiên là có

takeWhile even

nhưng đó là 14 byte.

MATL , 6 byte

toYs~)

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

Giải trình

t    % Input array implicitly. Duplicate
o    % Parity of each entry. Gives 0 for even entries, 1 for odd
Ys   % Cumulative sum
~    % Logical negate. Gives true for the first run of even entries, and then false
)    % Use this as logical index into the original array. Implicitly display

Lục giác , 19

2.}<@>%?<{>$"/\M!8;

Có thể đọc được

  2 . }
 < @ > %
? < { > $
 " / \ M
  ! 8 ;

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

Điều này có thể được chơi bằng một hoặc hai byte, nhưng điều đó có thể đòi hỏi một bố cục thực sự khéo léo, có thể dễ dàng tìm thấy hơn thông qua lực lượng vũ phu (ngay cả khi có thể mất nhiều thời gian để tìm thấy nó).

Giải thích cấp cao

Chương trình chủ yếu tuân theo mã giả này:

while (read number is not zero) 
{
    if (number is even) 
        print number;
} 

Việc lạm dụng làm thế nào Hexagony cố đọc một số khi STDIN trống (nó trả về số 0). Cảm ơn rất nhiều vì Martin đã giúp đỡ với cách tiếp cận này.

Giải thích đầy đủ

Tôi vẫn chưa từng loay hoay với Mono để có được IDE bí truyền tuyệt vời của Timwi chạy , vì vậy tôi đã nhờ Martin cung cấp cho tôi một số hình ảnh đẹp hữu ích!

Đầu tiên, một chút mồi về dòng điều khiển cơ bản trong Hexagony. Con trỏ lệnh đầu tiên (IP), là con trỏ duy nhất được sử dụng trong chương trình này, bắt đầu ở phía trên bên trái của mã nguồn hình lục giác và bắt đầu di chuyển về phía bên phải. Bất cứ khi nào IP rời khỏi cạnh của hình lục giác, nó sẽ di chuyển side_length - 1các hàng về phía giữa của hình lục giác. Vì chương trình này sử dụng một hình lục giác có ba cạnh dài, IP sẽ luôn luôn di chuyển hai hàng khi điều này xảy ra. Ngoại lệ duy nhất là nếu nó di chuyển ra khỏi hàng giữa, nơi nó di chuyển có điều kiện về phía trên hoặc dưới của hình lục giác, tùy thuộc vào giá trị của cạnh bộ nhớ hiện tại.

Bây giờ một chút về điều kiện. Các điều kiện duy nhất trong Hexagony cho luồng điều khiển là >,< và cạnh giữa của hình lục giác. Tất cả đều tuân theo một quy tắc không đổi: nếu giá trị trên cạnh bộ nhớ hiện tại bằng 0 hoặc luồng điều khiển âm di chuyển sang trái và nếu dương thì điều khiển chảy sang phải. Giá trị lớn hơn và nhỏ hơn dấu ngoặc chuyển hướng IP ở góc sáu mươi độ, trong khi cạnh của hình lục giác điều khiển hàng IP nhảy tới.

Hexagony cũng có một mô hình bộ nhớ đặc biệt, trong đó tất cả dữ liệu được lưu trữ trên các cạnh của lưới lục giác vô hạn. Chương trình này chỉ sử dụng ba cạnh: một để lưu trữ hai, một cho số hiện đang đọc và một cho số modulo hai. Nó trông giống như:

Mod  \ / Input
      |
      2

Tôi sẽ không giải thích cẩn thận về vị trí của chúng ta trong bộ nhớ tại mỗi thời điểm trong quá trình giải thích chương trình, vì vậy hãy quay lại đây nếu bạn bị nhầm lẫn bởi nơi chúng ta đang ở trong bộ nhớ.

Với tất cả những điều đó, cách giải thích thực tế có thể bắt đầu. Đầu tiên, chúng ta điền vào cạnh "2" trong bộ nhớ bằng 2, sau đó chúng ta thực hiện lệnh cấm và di chuyển con trỏ bộ nhớ sang phải ( 2.}).

Tiếp theo, chúng tôi bắt đầu vòng lặp chương trình chính. Chúng tôi đọc số đầu tiên từ STDIN và sau đó chúng tôi nhấn một điều kiện ( ?<). Nếu không còn số nào trong STDIN, số này sẽ đọc số 0 vào cạnh bộ nhớ hiện tại, vì vậy chúng tôi rẽ trái vào @, kết thúc chương trình. Mặt khác, chúng ta bật ra một tấm gương, di chuyển con trỏ bộ nhớ về phía sau và sang trái, quấn quanh hình lục giác để tính phần còn lại của việc chia đầu vào cho 2 và sau đó nhấn một điều kiện khác ( /"%>).

Nếu phần còn lại là một (tức là số là số lẻ), chúng ta rẽ phải theo đường dẫn màu xanh bên trên bắt đầu bằng cách thực hiện lại lệnh no-op, sau đó chúng ta quấn quanh dưới cùng của hình lục giác, nhân cạnh hiện tại với 10 rồi thêm tám, bật ra một vài gương, thực hiện cùng một phép nhân và thêm lần nữa, nhận được 188 trên cạnh hiện tại, quay trở lại đỉnh của hình lục giác, thực hiện lại lệnh không hoạt động và cuối cùng kết thúc chương trình ( .8/\8.@). Kết quả phức tạp này là một tai nạn hạnh phúc, ban đầu tôi đã viết một chút logic đơn giản hơn nhiều, nhưng nhận thấy rằng tôi có thể loại bỏ nó theo hướng có lợi cho no-op, mà tôi nghĩ là theo tinh thần Hexagony hơn.

Nếu phần còn lại bằng không, thay vào đó chúng ta rẽ trái theo con đường màu đỏ, ở trên. Điều này khiến chúng ta di chuyển con trỏ bộ nhớ sang trái, sau đó in giá trị ở đó (giá trị đầu vào) dưới dạng số. Chiếc gương mà chúng ta bắt gặp hoạt động như một no-op vì hướng chúng ta đang di chuyển ( ). Vì 77 là dương, chúng tôi di chuyển sang phía dưới của hình lục giác và vì tấm bạt lò xo bỏ qua hướng dẫn đầu tiên ( ). Sau đó, chúng tôi nhân cạnh bộ nhớ hiện tại với 10 và thêm 8, nhận 778. Sau đó, chúng tôi xuất giá trị này mod 256 (10) dưới dạng ký tự ASCII, đây là dòng mới. Cuối cùng, chúng ta thoát khỏi hình lục giác và quay trở lại cái đầu tiên ghi đè lên 778 bằng giá trị đầu vào tiếp theo.{/! ). Sau đó, chúng tôi chạm vào cạnh của hình lục giác hoạt động có điều kiện chỉ có một kết quả, vì giá trị đầu vào từ trước đã được kiểm tra là dương, vì vậy chúng tôi luôn di chuyển về phía bên phải (nếu bạn tưởng tượng mình phải đối mặt với hướng IP) . Sau đó, chúng tôi nhân nhiều đầu vào với 10 và thêm hai, chỉ để thay đổi hướng, quấn quanh và ghi đè giá trị mới bằng giá trị ascii của chữ in hoa M, 77. Sau đó, chúng tôi nhấn một số gương và thoát ra khỏi rìa giữa hình lục giác với tấm bạt lò xo (2<M\>$!?

Pyth, 13 9 7 byte

uPWs%R2

Tín dụng cho @FryAmTheEggman cho 2 byte (khá khó khăn)!

Giải trình:

u       Q    keep applying to input until invariant:
 PW          drop last element if...
   s%R2G     ...any one is odd, G is the argument originally given the value of input

Kiểm tra nó ở đây .

Thạch , 5 byte

Ḃœp⁸Ḣ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

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

Ḃœp⁸Ḣ  Main link. Argument: A (array)

Ḃ      Bit; yield 1 for odd integers, 0 for even ones.
   ⁸   Yield A.
 œp    Partition A, splitting at 1's in the bit array.
       This yields a 2D array of runs of even integers.
    Ḣ  Head; extract the first chunk.

Python 2, 43 42 byte

def f(x):
 while"1'"in`map(bin,x)`:x.pop()

Hàm sửa đổi đối số của nó tại chỗ .

Cảm ơn @xnor vì đã chơi golf một byte theo cách thực sự thông minh!

Kiểm tra nó trên Ideone .

chủ biên, 13

/[13579]$/,$d

Bởi vì các lập trình viên thực sự sử dụng Trình soạn thảo văn bản tiêu chuẩn .

Lấy đầu vào là một số nguyên trên mỗi dòng; đầu ra trong cùng định dạng.

Điều này chỉ đơn giản là tìm số lẻ đầu tiên (số kết thúc bằng một chữ số lẻ) và xóa từ dòng đó cho đến khi kết thúc tập tin.

Clojure, 21 byte

#(take-while even? %)

Clojure gần như là cạnh tranh cuối cùng! (nhờ tác vụ được tích hợp sẵn) Xem trực tuyến https://ideone.com/BEKmez

Python, 45 44 byte

f=lambda x:x and~x[0]%2*x and x[:1]+f(x[1:])

Kiểm tra nó trên Ideone .

R, 25 byte

x=scan()
x[!cumsum(x%%2)]

Hoặc tương đương

(y=scan())[!cumsum(y%%2)]

05AB1E, 8 7 byte

[DÉO_#¨

Giải trình

[        # infinite loop start
 DÉO     # count odd numbers
    _    # push negative bool (turning 0->1, X->0)
     #   # if true (no odd numbers exist), break out of loop and implicitly print
      ¨  # else, remove last element from list

Dùng thử trực tuyến

Giải pháp 8 byte trước đó

vyÈiyˆëq

Giải trình

v         # for each y in input
 yÈi      # if y is even
    yˆ    # push y to global array
      ëq  # else terminate program
          # implicitly print global array

Dùng thử trực tuyến

Brainf ***, 263 byte

Tôi lấy một đoạn nhỏ từ đây

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

Tôi sẽ đưa ra một lời giải thích nhưng thậm chí tôi không biết cách thức hoạt động của nó nữa.

Yêu cầu đầu vào dưới dạng các số cách nhau không gian (ví dụ 2 432 1)

Bình thường, 7 byte

<x%R2Q1

Hãy thử nó ở đây!

Những gì tôi đã cố gắng làm ở Pyke nhưng chỉ số bị phá vỡ trong atm đó

Vợt, 22 byte

(λ(n)(takef n even?))

Ký λtự được tính là 2 byte.

Tôi chưa từng thấy Vợt được sử dụng trước đây trong bất kỳ câu trả lời đánh gôn nào tôi từng thấy, vì vậy tôi phải làm điều đó ít nhất một lần!

Mê cung , 14 byte

?:
"`#
"@%
\!;

Đầu vào và đầu ra là các danh sách được phân tách theo dòng (mặc dù về nguyên tắc, đầu vào có thể sử dụng bất kỳ dấu tách không có chữ số nào).

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

Đây có lẽ là chương trình Labyrinth nhỏ gọn nhất tôi từng viết.

Thật thú vị, takewhile(odd)đơn giản hơn nhiều:

?:#
" %
\!/

Giải trình

Các mồi Labyrinth thông thường:

• Mô hình bộ nhớ là một ngăn xếp (thực tế có hai, nhưng chúng ta sẽ chỉ cần một cho chương trình này), chứa các số nguyên có độ chính xác tùy ý và ban đầu giữ một số lượng không giới hạn (ẩn).
• Không có hướng dẫn dòng điều khiển. Thay vào đó, chuyển động của con trỏ lệnh (IP) được xác định bởi cách bố trí mã (khoảng trắng được coi là "tường" và không thể đi qua IP). Thông thường , mã được cho là giống với một mê cung, trong đó IP đi theo các hành lang thẳng và uốn cong, nhưng bất cứ khi nào nó đến một ngã ba, điều này hoạt động như một điều kiện trong đó hướng mới của IP được xác định dựa trên trạng thái hiện tại. Các quy tắc để chọn hướng đi theo hướng này: nếu đỉnh của ngăn xếp bằng 0, IP sẽ tiếp tục di chuyển về phía trước; nếu đỉnh là dương, IP rẽ phải; nếu đỉnh là âm thì IP rẽ trái. Nếu một trong những hướng này bị chặn bởi một bức tường, IP sẽ đi theo hướng ngược lại. Điều này có nghĩa là các chương trình không có hành lang rõ ràng thường cực kỳ khó khăn để làm việc, bởi vì mỗi lệnh đơn lẻ sẽ hoạt động như một ngã ba. Thực tế là điều này đã làm việc trong trường hợp này là một chút phép lạ.
• IP bắt đầu ở ký tự không phải không gian đầu tiên theo thứ tự đọc ( ?trong trường hợp này), di chuyển về phía đông.

Luồng chính qua chương trình là một vòng đơn quanh chu vi:

>v
^>v
^@v
^<<

Khi điều đó xảy ra, chúng ta biết rằng đỉnh của ngăn xếp bằng 0 sau đó !và "do đó IP được đảm bảo không quay về hướng trung tâm. `và %mặt khác được sử dụng như các điều kiện trong đó IP có thể di chuyển về phía trung tâm sao cho@ kết thúc chương trình hoặc nó có thể tiếp tục di chuyển xung quanh chu vi.

Hãy xem mã trong vòng lặp:

?   Read decimal integer N from STDIN, or 0 at EOF.
:   Duplicate. Since this is just a corner, the IP always turns south.
`   Negate the copy of the input (i.e. multiply by 1). At EOF, the result
    is still zero and the IP keeps moving south into the @. Otherwise, the
    top of the stack is now negative, and the IP turns east.
#   Push the stack depth (i.e. 2). Again, this is a corner, and the IP
    is forced to turn south.
%   Computer (-N % 2), which is identical to (N % 2) to determine the
    parity of the input. If input was odd, this gives 1, and the IP turns
    west into the @. Otherwise, the result is 0 and the IP keeps moving
    south, continuing the loop.
;   Discard the 0. This is a corner, so the IP is forced to turn west.
!   Print (and discard) N. The top of the stack is now one of the implicit
    zeros at the bottom, so the IP keeps moving west.
\   Print a linefeed. The IP is forced to turn north in the corner.
""  Two no-ops. The top of the stack is still zero, so the IP keeps moving north.

Và sau đó vòng lặp bắt đầu lại.

Điều đó đặt ra câu hỏi tại sao takewhile(odd)đơn giản hơn nhiều. Có hai lý do:

• Vì EOF được trả về là 0(chẵn), chúng tôi không cần kiểm tra EOF riêng. Danh sách này sẽ bị cắt ở thời điểm đó.
• Bây giờ chúng ta muốn chấm dứt khi N % 2là 0(như trái ngược với 1), mà có nghĩa là thay vì kiểm soát điều kiện dòng chảy, chúng tôi chỉ có thể chia các bản sao khác Nbằng cách N % 2: nếu đầu vào là số lẻ, mà chỉ lá Nvà chúng tôi thậm chí đã thoát khỏi sự N % 2(vì vậy chúng tôi don' t cần ;), nhưng nếu đầu vào là chẵn, điều đó chỉ đơn giản là chấm dứt chương trình với lỗi chia hết (im lặng).

Do đó, mã khác là một vòng lặp đơn giản không cho phép bất kỳ phân nhánh nào cả.

Brachylog , 19 16 byte

hH: 2% 0 ,? b & ~ b.hH; [].

s.:Mc?,.: nd: 2% 0 Bologa

Giải trình

s.                 Output is an ordered subset of Input
  :Mc?,            The concatenation of Output with a list M is Input
       .:{:2%0}a   All elements of Output are even

Hôm nay tôi đã học được một mẹo gọn gàng (được sử dụng trong câu trả lời 19 byte): ~b.hHngắn hơn so :[H]rc.với nối một phần tử ở đầu danh sách. Cái đầu tiên có nghĩa là "Đầu ra là kết quả với một mục bổ sung ở đầu và mục đầu tiên của Đầu ra là H" , trong khi mục còn lại thì đơn giản là "Đầu ra là nối của [[H], Result]".

J, 10 byte

{.~2&|i.1:

Giải trình

{.~2&|i.1:  Input: s
   2&|      Take each value in s mod 2
      i.1:  Find the index of the first 1
{.~         Take that many values from s and return

Python, 41 byte

lambda l:l[:[x%2for x in l+[1]].index(1)]

Cắt ngắn lđến chỉ số của lần xuất hiện đầu tiên của một số lẻ. Chỉ số được tìm thấy bằng cách tìm kiếm một 1trong các giá trị modulo 2. Để bảo vệ chống lại không tìm thấy số lẻ, a 1được đặt ở cuối.

C #, 50 byte

int[]f(int[]a)=>(a.TakeWhile(x=>x%2<1).ToArray());

CJam , 11 byte

Cảm ơn @Dennis vì đã sửa hai lần và tắt một byte!

{1+_2f%1#<}

Đây là một khối mã (tương đương với một hàm; được cho phép theo mặc định) dự kiến ​​mảng đầu vào trên ngăn xếp và để lại mảng đầu ra trên ngăn xếp.

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

Giải trình

{         }    e# define code block
 1+            e# attach 1 at the end of the array
   _           e# duplicate
    2f%        e# modulo 2 of each entry
       1#      e# find index of first occurrence of 1
         <     e# slice before

Võng mạc , 17 byte

 ?\d*[13579]\b.*

Các linefeed trailing là đáng kể. Đầu vào và đầu ra là các danh sách được phân tách bằng dấu cách.

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

Đây là một thay thế regex đơn giản, nó khớp với số lẻ đầu tiên (nghĩa là một số kết thúc bằng một chữ số lẻ) và nếu có thể, không gian trước nó cũng như mọi thứ sau nó và thay thế nó bằng một chuỗi rỗng, tức là tất cả các phần tử từ đó trở đi được loại bỏ khỏi đầu vào.

Như Leaky Nun chỉ ra, lấy danh sách ở dạng nhị phân, chúng ta có thể lưu 6 byte, nhưng có vẻ hơi gian lận, vì vậy có lẽ tôi sẽ tiếp tục đếm phiên bản thập phân:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 byte

a=>[for(x of a)if(!(a|=x&1))x]

V , 13 byte

íä*[13579]¾.*

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

Giải trình:

í              "search for, on every line
 ä*            "Any number of digits
   [13579]     "Followed by an odd digit
          ¾    "Then the end of a word,
           .*  "Followed by anything
               "(implicit) and replace it with nothing.

Thuận tiện, cùng một mã hoạt động để xác minh đồng thời tất cả các trường hợp thử nghiệm.

APL Dyalog , 11 byte

{⍵/⍨∧\~2|⍵}

2| phần còn lại từ chia cho 2

~ phủ định

∧\ AND-scan (tắt từ 0 đầu tiên)

/⍨ chọn nơi

Ruby, 25 byte

->a{a.take_while &:even?}

Tôi nghĩ tôi thua ...

Pyke, 8 byte

0+2L%fhO

Phiên dịch cố định, sử dụng các liên kết khác

Sử dụng phương thức của Dennis ngoại trừ hàm split_at của tôi bao gồm thay đổi - có thể là một lỗi

Hoặc với lỗi, 7 byte

2L%1R@<

Hãy thử nó ở đây!

2L%     -   map(%2, input)
   1R@  -  ^.index(1)
      < - input[:^]

Hoặc sau lỗi thứ 2, 6 byte

2L%fhO

Hãy thử nó ở đây!

Giải trình:

2L%    -   map(%2, input)
   f   -  split_at(input, ^)
    hO - ^[0][:-1]

GolfScript, 11 byte

Đây là một chương trình GolfScript đầy đủ để đọc một mảng GolfScript được xâu chuỗi bằng chữ (ví dụ [28 14 7 0]) và in ra cùng một mảng với phần tử lẻ đầu tiên và mọi thứ sau khi loại bỏ:

~1\{~&.},p;

Hãy thử trực tuyến. (Ngoài ra: Phiên bản mở rộng với khai thác thử nghiệm. )

Phiên bản bỏ chơi golf với ý kiến:

~     # evaluate input
1\    # push the number 1 onto the stack and move it under then input array
{     # start of loop body
  ~   #  bitwise negate the input number (making odd numbers even and vice versa)
  &   #  take bitwise AND of input and the saved number (0 or 1) on stack 
  .   #  duplicate result; filter loop will pop off the duplicate
},    # run loop above over input array, select elements for which it returns true
p     # stringify and print filtered array
;     # pop the number 0/1 off the stack

Giải pháp này dựa trên { },toán tử bộ lọc GolfScript , chạy nội dung của khối mã trên mỗi phần tử của một mảng và chọn các phần tử của mảng mà mã trong khối trả về giá trị đúng (tức là khác không) đầu ngăn xếp.

Do đó, ví dụ, {1&},sẽ chọn tất cả các số lẻ trong một mảng và {~1&},sẽ chọn tất cả các số chẵn. Sau đó, thách thức là tạo ra một bộ lọc chọn các số chẵn cho đến khi tìm thấy số lẻ đầu tiên và sau đó không chọn số nào cả.

Giải pháp tôi đã sử dụng là thay thế mặt nạ bit không đổi 1(được sử dụng để trích xuất bit thấp nhất của mỗi số đầu vào) bằng một biến trên ngăn xếp lưu trữ kết quả (0 hoặc 1) của lần lặp vòng lặp bộ lọc trước đó (và được khởi tạo thành 1 trước vòng lặp). Do đó, ngay khi bộ lọc trả về 0 một lần, bitmask cũng được đặt thành 0, ngăn bộ lọc không bao giờ quay lại 1 lần nữa.

Forth, 114 byte

Forth không thực sự có danh sách. Các tham số phải được đẩy lên ngăn xếp theo thứ tự ngược lại, như điển hình trong Forth. Kết quả sẽ được để lại trên ngăn xếp theo cùng một thứ tự. Điều này không hoạt động trên Ideone vì một số lý do, nhưng nó hoạt động trên thay thế. Dòng mới là cần thiết để loại bỏ sự mơ hồ của một số loại?

: D DEPTH ;
: f D IF 1 D 1 DO D 1- ROLL LOOP D 0 DO I PICK 2 MOD IF D I LEAVE THEN LOOP
DO I ROLL DROP LOOP THEN ;

Dùng thử trực tuyến

Ungolfed, với ý kiến:

: f DEPTH IF                                ( if stack not empty )
        1 DEPTH 1 DO DEPTH 1- ROLL LOOP     ( put 1 on bottom of stack )
        DEPTH 0 DO                          ( loop over entire stack )
            I PICK 2 MOD IF                 ( if stack[i] is odd )
                DEPTH I LEAVE               ( put range and exit loop )
            THEN
        LOOP
        DO I ROLL                           ( roll eyes )
            DROP
        LOOP                                ( iterate that range and remove )
    THEN
;

Chương trình này (lần thử trước của tôi) in kết quả cho đến khi nó đạt một số lẻ. Tất cả mọi thứ còn lại (không được thực hiện) sẽ được để lại trên ngăn xếp.

: f DEPTH IF BEGIN DUP 2 MOD DUP 1- IF SWAP . THEN UNTIL THEN ;

Thất bại nếu chỉ có số nguyên

Befunge, 35 byte

Mã này xử lý các số từ 0 đến 65535

1&:v
v-1_@#:@#<
>\:&:2%|
 \+1p4\< ^

Định dạng đầu vào :

number_of_values    values(separated by a space)

Đây là phiên bản hiển thị các giá trị ở cuối quá trình:

1&:v>::   v                >00g1+:4g.v
v-1_^#:>#<>$$\$1-:10p000p0-| -g01p00:<
>\:&:2%|                   @
 \+1p4\< ^

Bạn có thể kiểm tra mã ở đây , nhưng bạn sẽ phải thêm một dòng dấu với các khoảng trắng ở cuối, vì cách diễn giải này chỉ định:

«Hình xuyến mã chỉ lớn bằng chương trình ban đầu. Chèn thêm dòng hoặc dấu cách nếu dữ liệu sẽ được đặt ngoài phần cuối của mã. »

Tôi không biết điều này có được chấp nhận hay không, vì tôi đã không đếm dấu vết này trong số byte
nb: có vẻ như vì tôi đang lưu trữ số trong mã, trình thông dịch sẽ không để chương trình này chạy hai lần đúng đường. Bạn sẽ phải tải lại nó.

Cách thức hoạt động: Trình thông dịch theo các mũi tên và bỏ qua một hướng dẫn khi vượt qua '#'

Các chấm màu xám đang thử nghiệm và đường màu đỏ loại bỏ các biến không cần thiết khỏi ngăn xếp

Sử dụng ở đây trong trình thông dịch ở trên, các giá trị đã lưu được hiển thị trong mã bằng cách sử dụng các biểu diễn của chúng (tôi không biết định dạng). Vâng, Befunge là một ngôn ngữ khá phản chiếu