บทนำและเครดิต

วันนี้ได้โดยไม่ต้องโหมโรงแฟนซี: takewhileโปรดดำเนินการ

ความแตกต่างของสิ่งนี้ (ในโครงสร้างข้อมูลที่ไม่สำคัญ) เป็นการกำหนดหลักสูตรการเขียนโปรแกรมเชิงปฏิบัติการของมหาวิทยาลัย ตอนนี้งานนี้ปิดและมีการพูดคุยกันในชั้นเรียนและฉันได้รับอนุญาตจากอาจารย์ให้โพสต์ไว้ที่นี่ (ฉันถามอย่างชัดเจน)

สเปค

อินพุต

อินพุตจะเป็นรายการ (หรือแนวคิดที่เทียบเท่ากับภาษาของคุณ) ของจำนวนเต็มบวก

เอาท์พุต

ผลลัพธ์ควรเป็นรายการ (หรือแนวคิดที่เทียบเท่ากับภาษาของคุณ) ของจำนวนเต็มบวก

จะทำอย่างไร?

งานของคุณคือการนำไปใช้takewhile(อนุญาตให้ใช้ภาษาที่มีอยู่ในเครื่อง) พร้อมคำอธิบายว่าหมายเลขที่อยู่ระหว่างการพิจารณาจะเท่ากัน (เพื่อเน้นไปที่ takewhile)

ดังนั้นคุณจึงวนซ้ำรายการตั้งแต่ต้นจนจบและในขณะที่เงื่อนไข (เท่ากับ) คุณคัดลอกไปยังรายการผลลัพธ์และทันทีที่คุณกดองค์ประกอบที่ไม่ทำให้เงื่อนไขเป็นจริงคุณจะยกเลิกการดำเนินการและเอาท์พุท (ตัวอย่างทีละขั้นตอนอยู่ด้านล่าง) ฟังก์ชันการสั่งซื้อที่สูงกว่านี้เรียกว่า takeWhile ( takewhile)

กรณีมุมที่อาจเกิดขึ้น

ลำดับของรายการที่ส่งออกเมื่อเทียบกับรายการการป้อนข้อมูลที่อาจจะไม่สามารถเปลี่ยนแปลงได้เช่นอาจจะไม่กลายเป็น[14,42,2][42,14]

รายการที่ว่างเปล่าคือ in- and output ที่ถูกต้อง

ใครชนะ?

นี่คือ code-golf ดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ!

ใช้กฎมาตรฐานแน่นอน

ทดสอบเวกเตอร์

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

ตัวอย่างทีละขั้นตอน

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]

Mathematica ขนาด 18 ไบต์

#~TakeWhile~EvenQ&

อีกตัวในตัวที่รุ่งโรจน์ที่ถูกตีด้วยปัจจัย 3 โดยภาษากอล์ฟโดยไม่ต้องมีในตัว ...

Haskell ขนาด 13 ไบต์

fst.span even

spanแยกรายการอินพุตเป็นคู่ของรายการก่อนอิลิเมนต์แรกที่เพรดิเคต (-> even) เป็นเท็จ fstใช้องค์ประกอบแรกของคู่

รุ่นทางเลือกขนาด 13 ไบต์:

fst.break odd

breakเป็นสิ่งที่ตรงกันข้ามspanคือกล่าวแยกรายการที่องค์ประกอบแรกที่ภาคแสดงเป็นจริง

แน่นอนว่ายังมี

takeWhile even

แต่นั่นคือ 14 ไบต์

MATL , 6 ไบต์

toYs~)

ลองออนไลน์!

คำอธิบาย

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

Hexagony , 19

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

อ่านได้:

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

ลองออนไลน์!

สิ่งนี้อาจจะเล่นโดยใช้ไบท์หนึ่งหรือสอง แต่อาจต้องมีเลย์เอาต์ที่แยบยลอย่างแท้จริงซึ่งอาจพบได้ง่ายกว่าด้วยกำลังดุร้าย (แม้ว่ามันอาจใช้เวลาค่อนข้างนานในการค้นหา)

คำอธิบายระดับสูง

โปรแกรมส่วนใหญ่ติดตาม pseudocode นี้:

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

ซึ่งเป็นการละเมิดวิธีที่ Hexagony พยายามอ่านตัวเลขเมื่อ STDIN ว่างเปล่า (ส่งกลับศูนย์) ขอบคุณมาร์ตินอย่างมากสำหรับความช่วยเหลือในการหาวิธีนี้

คำอธิบายแบบเต็ม

ฉันยังไม่ได้เล่นกับโมโนเพื่อรับของ Timwi IDE ที่ลึกลับทำงานได้ดังนั้นฉันจึงได้ไว้ที่ Martin เพื่อให้ฉันได้ภาพสวย ๆ ที่เป็นประโยชน์!

ขั้นแรกให้รองพื้นเล็ก ๆ น้อย ๆ เกี่ยวกับการควบคุมขั้นพื้นฐานใน Hexagony ตัวชี้คำสั่งแรก (IP) ซึ่งเป็นสิ่งเดียวที่ใช้ในโปรแกรมนี้เริ่มต้นที่ด้านบนซ้ายของซอร์สโค้ดหกเหลี่ยมและเริ่มเคลื่อนไปทางขวา เมื่อใดก็ตามที่ IP ออกจากขอบของรูปหกเหลี่ยมมันจะเคลื่อนที่side_length - 1แถวไปทางตรงกลางของรูปหกเหลี่ยม เนื่องจากโปรแกรมนี้ใช้ความยาวด้านหกเหลี่ยมหกเหลี่ยม IP จะเคลื่อนที่สองแถวเสมอเมื่อเกิดเหตุการณ์นี้ ข้อยกเว้นเพียงอย่างเดียวคือถ้ามันเคลื่อนออกจากแถวกลางซึ่งมีเงื่อนไขย้ายไปทางด้านบนหรือด้านล่างของรูปหกเหลี่ยมขึ้นอยู่กับค่าของขอบหน่วยความจำปัจจุบัน

ตอนนี้เป็นเรื่องเกี่ยวกับเงื่อนไข เงื่อนไขเฉพาะใน Hexagony สำหรับการควบคุมการไหลคือ> ,<และขอบกลางของรูปหกเหลี่ยม สิ่งเหล่านี้ล้วนเป็นไปตามกฎคงที่: หากค่าบนขอบหน่วยความจำปัจจุบันเป็นศูนย์หรือโฟลว์การควบคุมเชิงลบเลื่อนไปทางซ้ายและหากเป็นบวกการควบคุมการไหลจะถูกต้อง วงเล็บใหญ่กว่าและน้อยกว่าจะเปลี่ยนเส้นทาง IP ที่มุมหกสิบองศาในขณะที่ขอบของรูปหกเหลี่ยมจะควบคุมว่าแถวใดที่ IP กระโดดข้าม

Hexagony ยังมีโมเดลหน่วยความจำพิเศษซึ่งข้อมูลทั้งหมดจะถูกเก็บไว้ที่ขอบของกริดหกเหลี่ยมที่ไม่มีที่สิ้นสุด โปรแกรมนี้ใช้สามขอบเท่านั้น: หนึ่งเพื่อเก็บสองหนึ่งหนึ่งสำหรับหมายเลขที่อ่านในปัจจุบันและอีกหนึ่งสำหรับโมดูโลหมายเลขสอง ดูเหมือนว่า:

Mod  \ / Input
      |
      2

ฉันจะไม่อธิบายอย่างรอบคอบว่าเราอยู่ที่ไหนในความทรงจำในแต่ละจุดระหว่างการอธิบายของโปรแกรมดังนั้นกลับมาที่นี่หากคุณสับสนโดยที่เราอยู่ในความทรงจำ

ด้วยวิธีทั้งหมดนั้นคำอธิบายที่แท้จริงสามารถเริ่มต้นได้ อันดับแรกเราเติมขอบ "2" ในหน่วยความจำด้วย 2 จากนั้นเราเรียกใช้งาน no-op และย้ายตัวชี้หน่วยความจำไปทางขวา ( 2.})

ต่อไปเราจะเริ่มต้นลูปโปรแกรมหลัก เราอ่านหมายเลขแรกจาก STDIN จากนั้นเราก็กดเงื่อนไข ( ?<) หากไม่มีตัวเลขเหลืออยู่ใน STDIN จะเป็นการอ่านค่าศูนย์ในขอบหน่วยความจำปัจจุบันดังนั้นเราจะเลี้ยวซ้ายเข้าสู่โปรแกรม@ซึ่งจบโปรแกรม มิฉะนั้นเราจะกระเด้งออกจากกระจกเลื่อนตัวชี้หน่วยความจำไปทางซ้ายและไปทางซ้ายล้อมรอบหกเหลี่ยมเพื่อคำนวณส่วนที่เหลือของการหารอินพุทที่เหลือ 2 และจากนั้นกดเงื่อนไขอื่น ( /"%>)

หากส่วนที่เหลือเป็นหนึ่ง (เช่นจำนวนคี่) เราเลี้ยวขวาตามเส้นทางสีน้ำเงินด้านบนเริ่มต้นโดยดำเนินการ no-op อีกครั้งจากนั้นเราล้อมรอบไปที่ด้านล่างของรูปหกเหลี่ยมคูณขอบปัจจุบันด้วย 10 แล้วเพิ่ม แปดเด้งออกมาจากกระจกสองคู่ทำการคูณเดียวกันและเพิ่มอีกครั้งรับ 188 ที่ขอบปัจจุบันแล้วย้อนกลับไปที่ด้านบนของรูปหกเหลี่ยมดำเนินการแบบไม่มี op อีกครั้งและสิ้นสุดโปรแกรม ( .8/\8.@) ผลลัพธ์ที่ซับซ้อนนี้เป็นอุบัติเหตุที่มีความสุขในตอนแรกฉันเขียนตรรกะได้ง่ายขึ้น แต่สังเกตว่าฉันสามารถลบมันได้โดยไม่ต้องใช้ op-op ซึ่งฉันคิดว่าเป็นวิญญาณของ Hexagony มากกว่า

หากส่วนที่เหลือเป็นศูนย์เราแทนที่จะเลี้ยวซ้ายตามเส้นทางสีแดงด้านบน สิ่งนี้ทำให้เราย้ายตัวชี้หน่วยความจำไปทางซ้ายแล้วพิมพ์ค่าที่นั่น (ค่าอินพุต) เป็นตัวเลข กระจกที่เราพบทำหน้าที่เหมือนไม่มีการหมุนเนื่องจากทิศทางที่เรากำลังเคลื่อนที่ ( ) เนื่องจาก 77 เป็นบวกเราจึงเลื่อนไปทางด้านล่างของรูปหกเหลี่ยมและเนื่องจากแทรมโพลีนกระโดดข้ามคำสั่งแรก ( ) จากนั้นเราคูณจำนวนหน่วยความจำปัจจุบันทีละ 10 และเพิ่ม 8 เพิ่มเป็น 778 จากนั้นเราจะส่งออกค่า mod 256 (10) เป็นอักขระ ASCII ซึ่งเกิดขึ้นเป็นบรรทัดใหม่ ในที่สุดเราก็ออกจากรูปหกเหลี่ยมและห่อกลับไปที่ตำแหน่งแรกซึ่งแทนที่ 778 ด้วยค่าอินพุตถัดไป{/! ) จากนั้นเราก็ไปที่ขอบของรูปหกเหลี่ยมซึ่งทำหน้าที่มีเงื่อนไขกับผลลัพธ์เดียวเท่านั้นเนื่องจากค่าอินพุตจากก่อนหน้านี้ถูกทดสอบแล้วว่าเป็นค่าบวกดังนั้นเราจึงเลื่อนไปทางขวาเสมอ . จากนั้นเราป้อนข้อมูลหลายรายการด้วย 10 และเพิ่มสองเพียงเพื่อเปลี่ยนทิศทางห่อรอบ ๆ และเขียนทับค่าใหม่ด้วยค่า ascii ของตัวอักษรตัวใหญ่ M, 77 จากนั้นเราไปที่กระจกเงาและออกจากขอบตรงกลางของ หกเหลี่ยมด้วยแทรมโพลีน (2<M\>$!?

Pyth, 13 9 7 ไบต์

uPWs%R2

ให้เครดิตกับ @FryAmTheEggman เป็นเวลา 2 ไบต์ (ค่อนข้างยุ่งยาก)!

คำอธิบาย:

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

ทดสอบได้ที่นี่

เยลลี่ 5 ไบต์

Ḃœp⁸Ḣ

ลองออนไลน์!หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

Ḃœ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 ไบต์

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

ฟังก์ชั่นปรับเปลี่ยนโต้แย้งในสถานที่

ขอบคุณ @xnor สำหรับการตีกอล์ฟด้วยวิธีที่ชาญฉลาดจริงๆ!

ทดสอบบนIdeone

ed, 13

/[13579]$/,$d

เพราะ จริงโปรแกรมเมอร์ใช้โปรแกรมแก้ไขข้อความมาตรฐาน

รับอินพุตเป็นจำนวนเต็มหนึ่งตัวในแต่ละบรรทัด เอาต์พุตในรูปแบบเดียวกัน

นี่จะค้นหาตัวเลขคี่แรก (หมายเลขที่ลงท้ายด้วยเลขคี่) และลบออกจากบรรทัดนั้นจนกระทั่งถึงจุดสิ้นสุดของไฟล์

Clojure 21 ไบต์

#(take-while even? %)

Clojure เกือบจะแข่งขันกันในที่สุด! (ต้องขอบคุณงานที่มีอยู่ในตัว) ดูแบบออนไลน์ได้ที่https://ideone.com/BEKmez

Python ขนาด45 44 ไบต์

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

ทดสอบบนIdeone

R, 25 ไบต์

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

หรือเทียบเท่า

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

05AB1E, 8 7 ไบต์

[DÉO_#¨

คำอธิบาย

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

ลองออนไลน์

โซลูชัน 8 ไบต์ก่อนหน้า

vyÈiyˆëq

คำอธิบาย

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

ลองออนไลน์

Brainf ***, 263 ไบต์

ฉันเอาตัวอย่างเล็กน้อยจากที่นี่

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

ฉันจะให้คำอธิบาย แต่ฉันก็ไม่รู้ว่ามันใช้งานได้อย่างไร

ต้องการอินพุตเป็นตัวเลขคั่นด้วยช่องว่าง (เช่น2 432 1)

Pyth, 7 ไบต์

<x%R2Q1

ลองที่นี่!

สิ่งที่ฉันพยายามทำใน Pyke แต่ดัชนีหักพังใน ATM นั้น

แร็กเก็ต, 22 ไบต์

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

λตัวอักษรนับเป็น 2 ไบต์

ฉันไม่เคยเห็นแร็กเก็ตมาก่อนในคำตอบของการเล่นกอล์ฟที่ฉันเคยเห็นดังนั้นฉันต้องทำอย่างน้อยหนึ่งครั้ง!

เขาวงกตขนาด 14 ไบต์

?:
"`#
"@%
\!;

อินพุตและเอาต์พุตเป็นรายการที่คั่นด้วยตัวป้อนบรรทัด (แม้ว่าโดยหลักการแล้วอินพุตสามารถใช้ตัวคั่นที่ไม่ใช่ตัวเลขใด ๆ )

ลองออนไลน์!

นี่อาจเป็นโปรแกรมเขาวงกตขนาดกะทัดรัดที่สุดที่ฉันเคยเขียน

ที่น่าสนใจtakewhile(odd)คือเรียบง่ายมาก:

?:#
" %
\!/

คำอธิบาย

ไพรเมอร์เขาวงกตปกติ:

• โมเดลหน่วยความจำคือสแต็ก (มีสองจริง แต่เราจะต้องการเพียงหนึ่งสำหรับโปรแกรมนี้) ซึ่งมีจำนวนเต็มความแม่นยำโดยพลการและในตอนแรกถือจำนวนศูนย์ (โดยปริยาย) จำนวนอนันต์
• ไม่มีคำสั่งโฟลว์ควบคุม แต่ความเคลื่อนไหวของตัวชี้คำสั่ง (IP) จะถูกกำหนดโดยรูปแบบของรหัส (ช่องว่างจะถูกพิจารณาว่าเป็น "กำแพง" และไม่สามารถเคลื่อนที่ผ่าน IP) โดยปกติรหัสควรมีลักษณะคล้ายกับเขาวงกตที่ IP ตามทางเดินตรงและโค้ง แต่เมื่อใดก็ตามที่มันถึงทางแยกนี้จะทำหน้าที่เป็นเงื่อนไขที่ทิศทางใหม่ของ IP จะถูกกำหนดขึ้นอยู่กับสถานะปัจจุบัน กฎสำหรับการเลือกทิศทางที่ต้มลงมาถึงสิ่งนี้: หากส่วนบนสุดของสแต็กเป็นศูนย์ IP จะยังคงเดินหน้าต่อไป ถ้าด้านบนเป็นค่าบวก IP จะเลี้ยวขวา ถ้าด้านบนเป็นลบ IP จะเลี้ยวซ้าย หากหนึ่งในทิศทางเหล่านี้ถูกบล็อกโดยกำแพง IP จะใช้ทิศทางตรงกันข้ามแทน ซึ่งหมายความว่าโปรแกรมโดยไม่ต้องทางเดินที่ชัดเจนมักจะยากที่จะทำงานอย่างไม่น่าเชื่อเพราะทุกคำสั่งเดียวจะทำหน้าที่เป็นชุมทาง ความจริงที่ว่าสิ่งนี้ได้ผลในกรณีนี้เป็นเรื่องมหัศจรรย์
• IP เริ่มต้นที่อักขระที่ไม่ใช่ช่องว่างแรกในลำดับการอ่าน ( ?ในกรณีนี้) เคลื่อนไปทางทิศตะวันออก

กระแสหลักผ่านโปรแกรมเป็นวงเดียวรอบปริมณฑล:

>v
^>v
^@v
^<<

เมื่อมันเกิดขึ้นเรารู้ว่าด้านบนของสแต็คเป็นศูนย์หลัง!และ"เพื่อให้ IP จะรับประกันไม่หันไปทางศูนย์ `และ%ในทางกลับกันจะถูกใช้เป็นเงื่อนไขซึ่ง IP อาจเคลื่อนที่ไปสู่ศูนย์กลางดังกล่าว@จะยุติโปรแกรมหรืออาจเคลื่อนที่ไปรอบ ๆ ปริมณฑล

ลองดูรหัสในลูป:

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

จากนั้นลูปเริ่มใหม่

นั่นทำให้เกิดคำถามว่าทำไมtakewhile(odd)จึงง่ายกว่ามาก มีสองเหตุผล:

• เนื่องจาก EOF ถูกส่งคืนเป็น0(ซึ่งเท่ากัน) เราไม่จำเป็นต้องมีการตรวจสอบ EOF แยกต่างหาก รายการจะถูกตัดออกที่จุดนั้นต่อไป
• ตอนนี้เราต้องการที่จะยุติเมื่อN % 2เป็น0(เมื่อเทียบกับ1) ซึ่งหมายความว่าแทนการควบคุมเงื่อนไขไหลเราก็สามารถแบ่งสำเนาอื่น ๆNโดยN % 2: ถ้าใส่เป็นเลขคี่ที่ใบเพียงNและเรายังมีการกำจัดของN % 2(เพื่อให้เราสวม' ไม่จำเป็น;) แต่ถ้าอินพุทเป็นเลขคู่นั่นก็เป็นการยกเลิกโปรแกรมด้วยข้อผิดพลาดการหาร (เงียบ) โดยศูนย์

ดังนั้นรหัสอื่นคือการวนรอบแบบง่าย ๆ ที่ไม่อนุญาตให้มีการแตกแขนงใด ๆ เลย

Brachylog , 19 16 ไบต์

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

s.:Mc?,.:{:2%0}a

คำอธิบาย

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

วันนี้ฉันได้เรียนรู้เคล็ดลับเรียบร้อย (ซึ่งใช้ในการตอบ 19 ไบต์): ~b.hHสั้นกว่า :[H]rc.การผนวกองค์ประกอบที่จุดเริ่มต้นของรายการ อันแรกหมายถึง"เอาท์พุทเป็นผลลัพธ์ที่มีรายการเพิ่มเติมที่จุดเริ่มต้นและรายการแรกของเอาท์พุทคือH"ในขณะที่อีกคนหนึ่งตรงไปตรงมา"เอาท์พุทคือการต่อกัน[[H], Result]"

J, 10 ไบต์

{.~2&|i.1:

คำอธิบาย

{.~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 ไบต์

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

ตัดทอนlจนถึงดัชนีการเกิดขึ้นครั้งแรกของจำนวนคี่ ดัชนีจะพบได้โดยการมองหาในค่าโมดูโล1 2เพื่อป้องกันการไม่พบจำนวนคี่ a 1ถูกวางในท้ายที่สุด

C#, 50 bytes

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

CJam, 11 bytes

Thanks to @Dennis for two corrections and one byte off!

{1+_2f%1#<}

This is a code block (equivalent to a function; allowed by default) that expects the input array on the stack, and leaves the output array on the stack.

Try it online!

Explanation

{         }    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

Retina, 17 bytes

 ?\d*[13579]\b.*

The trailing linefeed is significant. Input and output are space-separated lists.

Try it online!

This is a simple regex substitution, it matches the first odd number (i.e. a number ending in an odd digit), and if possible the space preceding it as well as everything after it and replaces it with an empty string, i.e. all elements from there onward are removed from the input.

As Leaky Nun points out, taking the list in binary, we can save 6 bytes, but it seems a bit cheaty, so I'll probably continue counting the decimal version:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 bytes

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

V, 13 bytes

íä*[13579]¾.*

Try it online!

Explanation:

í              "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.

Conveniently, the same code works to verify all test-cases simultaneously.

Dyalog APL, 11 bytes

{⍵/⍨∧\~2|⍵}

2| division remainder from dividing with 2

~ negate

∧\ AND-scan (turns off from first 0)

/⍨ select where

Ruby, 25 bytes

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

I think I lose...

Pyke, 8 bytes

0+2L%fhO

Interpreter fixed, use other links

Uses Dennis' method except my split_at function includes the change - probably a bug

Or with bugfix, 7 bytes

2L%1R@<

Try it here!

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

Or after 2nd bugfix, 6 bytes

2L%fhO

Try it here!

Explanation:

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

GolfScript, 11 bytes

This is a full GolfScript program that reads a stringified GolfScript array literal (e.g. [28 14 7 0]) and prints out the same array with the first odd element and everything after it removed:

~1\{~&.},p;

Try it online. (Also: Extended version with test harness.)

De-golfed version with comments:

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

This solution is based on the GolfScript { }, filter operator, which runs the contents of the code block on each element of an array, and selects the elements of the array for which the code in the block returns a true (i.e. non-zero) value on top of the stack.

Thus, for example, {1&}, would select all odd numbers in an array, and {~1&}, would select all even numbers. The challenge, then, is to make a filter that selects even numbers until it finds the first odd one, and thereafter selects no numbers at all.

The solution I used is to replace the constant bit-mask 1 (used to extract the lowest bit of each input number) with a variable on the stack that stores the result (0 or 1) of the previous filter loop iteration (and is initialized to 1 before the loop). Thus, as soon as the filter returns 0 once, the bitmask also gets set to 0, preventing the filter from ever returning 1 again.

Forth, 114 bytes

Forth doesn't really have lists. The parameters must be pushed onto the stack in reverse order, as is typical in Forth. The result will be left on the stack in the same order. This doesn't work on Ideone for some reason, but it works on repl. The new line is required to remove ambiguity of some sort?

: 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 ;

Try it online

Ungolfed, with comments:

: 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
;

This program (my previous attempt) prints the results until it hits an odd number. Everything remaining (not taken) will be left on the stack.

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

Fails if only even integers

Befunge, 35 Bytes

This code handles numbers between 0 and 65535

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

Input format :

number_of_values    values(separated by a space)

Here is a version that displays the values at the end of the process :

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

You may test the code here, but you will have to add a trailing line with trailing spaces, as this interpret specifies :

« The code torus is only as large as the initial program. Insert more lines or trailing space if data will be put beyond the end of code.»

I don't know if this is acceptable, as I didn't count this trailing in the byte count
nb: it seems that because I'm storing number in the code, the interpreter won't let this program run twice in the correct way. You'll have to reload it.

How does this work: The interpreter follows the arrows and skip an instruction when crossing '#'

Grey dots are test, and the red line removes unneeded variables from the stack

Using the here in the above interpreter, the saved values are displayed in the code using their representations (I don't know the format). Yes, Befunge is a quite reflective language