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

คุณสามารถเลือกเพิ่มบรรทัดใหม่ต่อท้ายไปยังเอาต์พุต

นี่คือ code-golf คำตอบที่สั้นที่สุดเป็นไบต์ (คี่) ชนะ

ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม นอกจากนี้คุณไม่สามารถใช้เวอร์ชันภาษาซึ่งใหม่กว่าการโพสต์ความท้าทายนี้

ตัวอย่างอินพุต> เอาต์พุต:

13 > 13

42 >

Japt -f 1 ไบต์

u

uมีค่ารหัสตัวอักษร117เป็น

ลองมัน

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069758100171520285996319 ไบต์

มันมีค่าประมาณ 2 duodecillion bytes

ไฟล์แปลเป็นโปรแกรม brainfuck ต่อไปนี้:

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

รับอินพุตเป็นรหัส ASCII ที่มีค่าสูงสุด 256 ใช้การตัดคำ

x86-64 รหัสเครื่อง, 8 ไบต์

แรงบันดาลใจจากคำตอบของBruce Forteแต่อยู่ภายใต้การเล็กน้อย :-)

8D 07          lea      eax, [rdi]    ; put copy of input parameter in EAX
D1 EF          shr      edi, 1        ; shift LSB into CF
             InfiniteLoop:
F3 73 FD       rep jnc  InfiniteLoop  ; test CF; infinite loop back here if input was even
C3             ret                    ; return with original input in EAX if it was odd

พารามิเตอร์เลขจำนวนเต็มเดี่ยวถูกนำมาใช้ในการEDIลงทะเบียนตามการเรียก System V AMD64

สำเนาของค่านี้จะทำในขั้นต้นและใส่ลงในEAXเพื่อที่จะสามารถกลับมาตามความเหมาะสม ( LEAใช้แทนปกติMOVเพราะเราต้องการคำสั่งที่มีไบต์คี่)

จากนั้นค่าในEDIจะถูกเลื่อนไปทางขวา 1 ซึ่งวางบิต shifted-off ลงใน carry flag (CF) บิตนี้จะเป็น 0 ถ้าตัวเลขเป็นเลขคู่หรือ 1 ถ้าเป็นเลขคี่

จากนั้นเราจะทดสอบ CF โดยใช้JNCคำสั่งซึ่งจะแตกสาขาเฉพาะถ้า CF เป็น 0 (เช่นจำนวนนั้นเท่ากัน) นี่หมายความว่าเราจะเข้าสู่วงวนไม่สิ้นสุดสำหรับค่าที่เท่ากัน สำหรับค่าคี่เราจะผ่านและส่งคืนค่าดั้งเดิม ( EAXเป็น)

มีเคล็ดลับเล็กน้อยในการJNCเรียนการสอน - มีREPคำนำหน้า! โดยปกติแล้วREPคำนำหน้าจะใช้กับคำสั่งแบบสตริงเท่านั้น แต่เนื่องจากคู่มือ Intel และ AMD ทั้งคู่ยอมรับว่าREPคำนำหน้าไม่เกี่ยวข้อง / ฟุ่มเฟือย / ซ้ำซ้อนจะถูกละเว้นเราจึงให้คำแนะนำสาขาที่นี่เพื่อทำให้มีความยาว 3 ไบต์ ด้วยวิธีนี้การชดเชยแบบสัมพัทธ์ที่ได้รับการเข้ารหัสในคำสั่งการกระโดดนั้นก็แปลก (และแน่นอนว่าREPตัวเองเป็นคำนำหน้าคี่ไบต์)

ขอบคุณพระเจ้าที่RETถูกเข้ารหัสโดยใช้ไบต์คี่!

ลองออนไลน์!

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

x86-64 รหัสเครื่อง (เอาต์พุตไปยังพอร์ตอนุกรม), 17 ไบต์

8D 07         lea   eax, [rdi]   ; put copy of input parameter (EDI) in EAX

B1 F7         mov   cl, 0xf7     ; put 0xF7 into low-order bits of CX
B5 03         mov   ch, 0x03     ; put 0x03 into high-order bits of CX
FE C1         inc   cl           ; increment low-order bits of CX to 0xF8 (so all together it's now 0x3F8)
0F B7 D1      movzx edx, cx      ; move CX to DX ("MOV DX, CX" would have a 16-bit prefix of 0x66)

D1 EF         shr   edi, 1       ; shift LSB of input parameter into CF
73 01         jnc   IsEven       ; test CF: branch if 0 (even), fall through if 1 (odd)
EF            out   dx, eax      ; output EAX (original input) to I/O port 0x3F8 (in DX)
            IsEven:
C3            ret                ; return

สิ่งที่ทำให้สิ่งนี้น่าสนใจยิ่งขึ้นคือโค้ดทำงานได้มากกว่าซึ่งหมายความว่าเป็นการยากที่จะทำทุกอย่างโดยใช้คำสั่งที่เข้ารหัสโดยใช้ไบต์คี่เท่านั้น แน่นอนนี่ก็หมายความว่ามันล้มเหลวที่ code golf ดังนั้นมันเป็นการแลกเปลี่ยนที่น่าสนใจ - คุณต้องการที่น่าสนใจและท้าทายหรือคุณต้องการสั้นไหม?

อย่างไรก็ตามสิ่งนี้ใช้OUTคำสั่ง x86 เพื่อเขียนไปยังพอร์ต I / O 0x3F8 ซึ่งเป็นพอร์ตอนุกรม COM1 มาตรฐานบนพีซี แน่นอนว่าส่วนที่สนุกสนานคือพอร์ต I / O มาตรฐานทั้งหมด (อนุกรมและขนาน) มีที่อยู่คู่ดังนั้นพวกเขาจึงไม่สามารถเข้ารหัสเป็นOUTคำสั่งได้ทันทีหรือย้ายไปลงทะเบียนโดยตรง คุณต้องเริ่มต้นด้วยค่าที่น้อยกว่าค่าจริงจากนั้นเพิ่มค่าในการลงทะเบียน นอกจากนี้คุณยัง จำกัด การใช้การลงทะเบียนบางอย่างสำหรับการจัดการเนื่องจากคุณต้องลงทะเบียนที่เข้ารหัสโดยใช้ไบต์คี่ในการเรียนการสอนเมื่อใช้เป็นตัวถูกดำเนินการ

นอกจากนี้ฉันต้องเริ่มต้นการDXลงทะเบียน (ผ่านการCXลงทะเบียน) ที่ด้านบนของลูปแม้ว่าจะต้องใช้เฉพาะในกรณีที่ค่าเป็นเลขคี่เพื่อให้แน่ใจว่าJNCคำสั่งนั้นจะมีออฟเซ็ตคี่ อย่างไรก็ตามเนื่องจากสิ่งที่เรากำลังข้ามไปคือOUTคำแนะนำรหัสทั้งหมดนี้คือวงจรการเสียและการลงทะเบียนขูดขีด มันไม่ได้ส่งออกอะไรเลยดังนั้นจึงไม่ผิดกฎ

สุดท้ายฟังก์ชันนี้จะกลับมา (หลังจากที่มีการทำหรือไม่ได้ทำส่งออกไปยังพอร์ตอนุกรม) EAXมีมูลค่าการป้อนข้อมูลที่เหลืออยู่ใน แต่นั่นไม่ได้ผิดกฎจริงๆ ฟังก์ชั่นทั้งหมดในภาษาแอสเซมบลีจะกลับมาพร้อมกับค่าในEAX- คำถามก็คือมันเป็นค่าที่สำคัญหรือค่าขยะ ที่กำหนดโดยเอกสารของฟังก์ชั่น (โดยหลักแล้วมันจะคืนค่าหรือส่งคืนvoid) และในกรณีนี้ฉันกำลังจัดทำเอกสารว่าไม่ได้คืนค่า :-)

ไม่มีลิงก์ TIO สำหรับลิงค์นี้เนื่องจากไม่ได้ใช้เอาต์พุตไปยังพอร์ตอนุกรม คุณจะต้องใช้เหล็กจริงหรือจินตนาการ

เยลลี่ 2 ไบต์

ẋḂ

ตัวละครเหล่านี้สอดคล้องกับไบต์0xF7และ0xBFในหน้ารหัสของวุ้น

ลองออนไลน์!

05AB1E , 3 ไบต์

Éi=

รหัสสอดคล้องกับค่าไบต์C9,69,3Dหรือ201,105,61เป็นเลขคี่ทั้งหมด

ลองออนไลน์!

คำอธิบาย

É     # input % 2 == 1
 i    # if true
  =   # print without popping

MATL , 3 ไบต์

o?G

MATL ใช้อักขระ ASCII เพื่อให้o?Gสอดคล้องกับการไบต์ (ในทศนิยม) 111, ,6371

ลองออนไลน์!

คำอธิบาย

o     % Push (implicit) input modulo 2
?     % If nonzero
  G   %   Push input
      % End (implicit)
      % Display stack contents (implicit)

Haskell , 36 33 ไบต์

c[1]=1;c[m]=1+1+c[m-1-1];o	m=c[m]

ลองออนไลน์!

การใช้งาน: o 7yiedls 7, o 8เข้าสู่วง จำกัด

อัลกอริทึมที่แท้จริงคือ

o 1 = 1
o m = 2 + o(m-2)

ปัญหาแรกที่ผมต้องเผชิญคือการขาดพื้นที่และ(เพราะฟังก์ชั่นoซึ่งจะมีการโต้แย้งmมักจะถูกกำหนดให้เป็นหรือo m=... o(m)=...อย่างไรก็ตามฉันพบว่าความคิดเห็นแบบอินไลน์{- some comment -}ทำงานเป็นตัวคั่นโทเค็นด้วยดังนั้นการนิยามo{--}m=...จึงเป็นไปได้ภายใต้กฎที่กำหนด แก้ไข: Ørjan Johansen ชี้ให้เห็นว่าสามารถใช้อักขระแท็บแทนการเว้นวรรคโดยประหยัดสามไบต์: o m=...

o(m-2)ปัญหาที่สองคือการโทร recursive -2เป็นเพียง-1-1แต่ที่นี่เคล็ดลับความคิดเห็นไม่ทำงานเพราะจำเป็นต้องใส่วงเล็บ ฉันคงนี้โดยการให้การทำงานของฟังก์ชั่นในรายการเดี่ยวที่มีจำนวน: o[m-2]อย่างไรก็ตามขณะนี้ไม่ได้เป็นวิธีมาตรฐานในการให้การป้อนข้อมูลผม outsourced คำนวณเพื่อฟังก์ชั่นผู้ช่วยcที่ทำงานในรายการและโทรcจากoที่มีรูปแบบที่ถูกต้อง .

Python REPL ขนาด 38 ไบต์

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

'%s'%[['']+[_]][-1][[_%[1+1][-1]][-1]]

ลองออนไลน์

การทำงานในเปลือกจริงคุณสามารถลองที่นี่ พิมพ์อินพุตกด Enter วางรหัสแล้วกด Enter

คำอธิบาย:

การดำเนินการนี้ใช้เวลาสักครู่ ไม่มีการทวีคูณไม่มีการแตกกิ่งไม่มีการแบ่งเครื่องหมายจุลภาคไม่มีจุดไม่มีการนำเข้าไม่มีวงเล็บไม่มีexecไม่evalไม่printและไม่มีฟังก์ชัน ฉันได้วิธีหนึ่งที่ใช้เอาต์พุตนั้นโดยใช้ stderr แต่แล้วฉันก็รู้ว่าเราต้องเอาท์พุทจำนวนเต็มจริงไม่ใช่แค่ค่าจริง / เท็จ

[expression][-1]ผมใช้วงเล็บในสถานที่ของวงเล็บด้วย '%s'%(['']+[_])[_%(1+1)]ง่ายที่จะเปลี่ยนรหัสดังกล่าวลง

['',_]เนื่องจากจะต้องไม่มีเครื่องหมายจุลภาคผมใช้นอกเหนือจากรายการที่จะสร้าง การใช้การจัดรูปแบบสตริงจะได้ผลลัพธ์ที่ต้องการ

CJam, 6 ไบต์

q_iY%%

113 95 105 89 37 37

โปรแกรมนี้ใช้ mod 2 ของอินพุต (เรียกว่าr ) และพิมพ์อักขระทุกตัวที่rในสตริงอินพุต หากหมายเลขอินพุตเป็นเลขคี่มันจะพิมพ์สตริงทั้งหมด แต่หากถูกขอให้พิมพ์อักขระทุก ๆ 0 ตัวโปรแกรมจะเกิดข้อผิดพลาด

ลองที่นี่

Cubix , 23 19 17 ไบต์

;;u!I1)%/;O=!;;/;

ลองมัน!

@ซึ่งยุติโปรแกรม Cubix คือ ascii 64 แต่น่าเสียดายที่นี่เพิ่งเข้าสู่วงวนไม่สิ้นสุดหลังจากทดสอบความแปลก ไม่มีลิงก์ TIO เนื่องจากจะหมดเวลา

= (ascii 61) เป็น no-op ใน Cubix

นี่เป็นการปรับเปลี่ยนเล็กน้อยของอัลกอริทึมก่อนหน้า (# ไบต์เดียวกัน) ที่ใช้งานได้จริงสำหรับจำนวนเต็มลบ

รุ่น Cube:

    ; ;
    u !
I 1 ) % / ; O =
! ; ; / ; . . .
    . .
    . .

ขั้นตอนวิธีการ:

• I (73) : อ่านในการป้อนข้อมูลเป็นจำนวน
• 1 (49) : กด 1
• ) (41) : เพิ่มขึ้น
• % (37) : ใช้ mod
• / (47) : เลี้ยวซ้าย
• ! (33) : ข้ามคำแนะนำถัดไปถ้าแปลก
  • 1;;/; ;is (59): เตรียมสแต็กสำหรับเอาต์พุต
  • O (79) : เอาท์พุทเป็นตัวเลข
  • จากนั้นมันจะเข้าสู่อัลกอริธึม แต่Iอ่าน a 0สำหรับส่วนท้ายของอินพุตดังนั้นเราจึงรับประกันว่าจะเข้าสู่สาขาคู่
• u (117) : ทางขวามือกลับรถ
• ;;;!I : วนซ้ำไม่ทำอะไรเลย

ถ่าน 9 ไบต์

¿﹪Ｉθ÷χ⁵→θ

ลองออนไลน์!

โดยทั่วไปมันพิมพ์ไปทางขวาถ้ามันไม่ได้เป็นหลาย 10/5 ( ²ถ่านแม้ในหน้ารหัสถ่าน ) ตัวละครที่ใช้คือ:

• ¿: BFรหัส
• ﹪: A5รหัส
• Ｉ: C9รหัส
• θ: F1รหัส
• ÷: AFรหัส
• χ: E3รหัส
• ⁵: B5รหัส
• →: 13รหัส

อันที่จริง→ใกล้ถึงจุดสิ้นสุดซ้ำซ้อน แต่แล้วฉันเห็นว่าคำตอบต้องมีความยาวคี่ ...

คำอธิบาย:

¿      if (
 ﹪      Modulo (
  Ｉθ      the input as number,
  ÷χ⁵      χ (predefined value: 10) divided by 5 = 2 ) [is 1])
 →θ      then print rightwards the input as string

รหัสเครื่อง x86_64 (Linux), 12 11 ไบต์

น่าเสียดายที่0x80เป็นไปได้ แต่มันก็ยังทำงานได้ (สมมติว่า "ไม่ทำอะไรเลย" หมายความว่าจะไม่กลับมา):

0000000000000000 <odd>:
   0:   8d 07                   lea  (%rdi), %eax
   2:   83 e7 01                and    $0x1, %edi
   5:   83 ff 01                cmp    $0x1, %edi
   8:   75 fb                   jne       5  <odd+0x5>
   a:   c3                      retq

-1 ไบต์ขอบคุณ @CodyGray!

ลองออนไลน์!

Mathematica ขนาด 20 ไบต์

ดูเหมือนจะเป็นทางออกแรกในภาษาที่ไม่ใช่กอล์ฟ

a=1+1;g[i_/;!a\[Divides]i]=i

ในการMacintoshChineseTraditionalเข้ารหัสตัวอักษร \[Divides]คือ{161, 253}(2 ไบต์)

รุ่นทางเลือก (23 ไบต์)

\[CapitalAlpha]=1+1;\[CapitalGamma][\[CapitalChi]_/;\[CapitalAlpha]\[LeftFloor]\[CapitalChi]/\[CapitalAlpha]\[RightFloor]\[NotEqual]\[CapitalChi]]=\[CapitalChi]

หรือ (แสดงเป็น Unicode)

Α=1+1;Γ[Χ_/;Α⌊Χ/Α⌋≠Χ]=Χ

ในการSymbolเข้ารหัสตัวอักษร (ใช้อักขระ 1 ไบต์เท่านั้น)

วิธีการแก้ปัญหากำหนดฟังก์ชั่นg(หรือΓ) ที่ประเมินเป็นอินพุตเมื่ออินพุตเป็นคี่และแท้จริง "ไม่ทำอะไรเลย" (ไม่ได้ประเมิน) เมื่ออินพุตเป็นแม้กระทั่ง

Perl, 54 ไบต์

-Eต้องใช้

ฉันสนุกกับการท้าทายนี้จริง ๆ ฉันคิดว่าฉันต้องการลองและปรับปรุงคำตอบนี้ แต่ฉันคิดว่านั่นอาจเป็นช่วงเวลาที่สั้นที่สุดที่ฉันสามารถทำได้ ฉันเล่นกับคำตอบเหล่านี้เป็นเวลาสองสามวันแล้ว แต่รู้สึกว่าฉันมีความสุขกับโซลูชั่น 54 ไบต์!

s//A_=Y[;A_=A_%O?A_W''/;y/#A-_/#-A/;s/[#-}]+/uc/ee;say

ลองออนไลน์!

คำอธิบาย

โดยค่าเริ่มต้นฟังก์ชันสตริงของ Perl ส่วนใหญ่จะทำงาน$_ซึ่งว่างเปล่าเพื่อเริ่ม

ขั้นแรกให้s//A_=Y[;A_=A_%O?A_W''/แทนที่สตริงว่าง$_ด้วยด้วยA_=Y[;A_=A_%O?A_W''แล้วy/#A-_/#-A/แทนที่อักขระตามรายการต่อไปนี้ (อักขระด้านบนกลายเป็นอักขระด้านล่าง):

#ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
#$%&'()*+,-./0123456789:;<=>?@A

ซึ่งการปรับปรุงเพื่อให้มี$_ $_=<>;$_=$_%2?$_:''ถัดไปs/[#-}]+/uc/eeแทนที่ตัวอักษรทั้งหมดที่มี[#-}]+ ucหากไม่มีสิ่ง/eeนี้จะเป็นเพียงสตริงucแต่/eeประเมินเนื้อหาของสตริงสองครั้ง การประเมินผลครั้งแรกส่งกลับผลลัพธ์ของucซึ่งเป็นรุ่นตัวพิมพ์ใหญ่ของ$_แต่เนื่องจาก$_ไม่มีอักขระที่เป็นตัวอักษรนี่เพิ่งส่งคืนสตริงทั้งหมดจากนั้นสตริงที่สองจะ/eประเมินค่าสตริงอีกครั้งซึ่งตั้งค่า$_เป็น$_(หมายเลขอินพุต) หรือ''ขึ้นอยู่กับว่าหรือ ไม่ใช่จำนวนคี่หรือคู่

ในที่สุดเนื่องจาก$_ตอนนี้มีสิ่งที่เราต้องการเราเรียกsay(ซึ่งเป็นสิ่งที่ต้องการ-Eแทน-e) ซึ่งพิมพ์$_ตามด้วยการขึ้นบรรทัดใหม่

ทางเลือก Perl, 93 ไบต์

รหัส 92 ไบต์ + 1 สำหรับ-pซึ่งฉันรู้สึกว่ามันจะไม่ใช่การแข่งขัน

s//_/g;s//uc/e;y/\x09-\x0b/_/;s/____/}[/;s/___/%C]/;s/_/{''H/;y/'{}1CDGH/'-)1-3+--/;s/[#-}]+/uc/ee

มีแท็บแท็บแนวตั้งในy///ที่ระบุเป็นและ\x09\x0b

ลองออนไลน์!

โลโก้ , 390 46 52 50 ไบต์

[ask    1   se[make]iseq    1-3 cos ?/ask   1[1/sum 1   179]?]

นั่นคือรายการเทมเพลตที่ส่งคืนอินพุตหากอินพุตเป็นเลขคี่และทำให้เกิดข้อผิดพลาดหากอินพุตเป็นเลขคู่

การใช้งาน:

show invoke [ask ... (paste code here) ... ] 5

เอาท์พุต

5

เนื่องจาก 5 เป็นเลขคี่และ

invoke [ask ... (paste code here) ... ] 6

จะทำให้เกิดข้อผิดพลาดเพราะ 6 เป็นเลขคู่

TI-BASIC ขนาด 14 ไบต์

Input Q
sinֿ¹(gcd(Q²,int(e
Q

สิ่งนี้จะโยนข้อผิดพลาดโดเมน (ไม่มีการพิมพ์อะไรไปยังหน้าจอหลัก) บนจำนวนคู่

Input Q             Q is a variable with an odd code. We cannot use "Ans" as it's even.

            int(e   floor(e) = 2; "2" is even.
         Q²         Q may be negative, so we square it which preserves parity.
     gcd(Q²,int(e   1 if Q is odd; 2 if Q is even.
sinֿ¹(gcd(Q²,int(e   Error iff Q is even.

Q                   If there was no error, print Q.

Pyth , 14 11 10 9 ไบต์

ฉัน + Q_ + K / Q + 3_1KQ 
I! sIcQ + 3_1Q 
I! u + 1_GQ1Q
? U + 1_GQ1k

ชุดทดสอบ

Japt , 4 ไบต์

u)çU

Japt ใช้มาตรฐาน ISO / IEC 8859-1เพื่อให้สอดคล้องนี้ 117 41 231 85(ในทศนิยม)

ทดสอบออนไลน์!

คำอธิบาย

Uu)çU   Implicit: U = input integer
Uu)     Return Python-style U % (missing argument = 2). This gives 1 if U is odd, 0 if even.
   çU   Implicitly convert U to a string and repeat it that many times.
        Implicit: output result of last expression

ฉันลองใช้วิธีแก้ปัญหาpก่อนซึ่งโดยทั่วไปแล้วçมีข้อโต้แย้งที่กลับรายการ อย่างไรก็ตามpดำเนินการยกกำลังถ้าอาร์กิวเมนต์ด้านซ้ายของมันคือตัวเลขดังนั้นเราจะต้องแปลงเป็นสตริงอย่างชัดเจน การแก้ปัญหานี้กลายเป็นไบต์ที่สั้นกว่าจริง ๆ และไม่มีไบต์แปลก ๆ

dc , 21 ไบต์

[c]sa?kKKCI-1;1k%1!=a

ทศนิยม: 91 99 93 115 97 63 107 75 75 67 73 45 49 59 49 107 37 49 33 61 97

ตามนี้เริ่มต้น IO โปรแกรมใบนี้ข้อมูลเกี่ยวกับกองหลักถ้ามันเป็นสิ่งที่แปลกและรถเปล่าสแต็คเป็นอย่างอื่น สิ่งนี้สามารถยืนยันได้โดยการเพิ่มfคำสั่ง debug ที่ส่วนท้ายของโปรแกรมเช่นเดียวกับกรณีในหน้า TIO

ลองออนไลน์!

คำอธิบาย

[    # Begin macro definition.
 c   # Clear the main stack.
]sa  # End macro definition and push the macro into register "a".
?k   # Prompt for input and store it into precision parameter "k".
KK   # Push two copies of the input to the main stack.
CI-  # Push C-I = 12-10 = 2 to the main stack  
1;1  # Push the value stored in the first index of array "1" (0 by default) 
     # to the main stack. 
k    # Push 0 into parameter "k" to reset the precision (otherwise the modulus 
     # function will not work correctly).
%    # Push the input (mod 2) to the main stack.
1!=a # If the input (mod 2) does not equal 1, execute the macro in register "a".
f    # OPTIONAL: Output the contents of the main stack.

TI-Basic, 18 ไบต์

บันทึก 2 ไบต์ขอบคุณ lirtosiast

:Prompt Q
:While 5Q/ᴇ1-int(5Q/ᴇ1
:Q

เป็นไบต์ (+2 newlines = 3F)

:Prompt Q
 DD     51
:While 5Q/ᴇ1-int(5Q/ᴇ1
 D1    35 3B B1  35 3B  
        51 31     51 31
         83 71     83
:Q
 51

ดูhttp://tibasicdev.wikidot.com/one-byte-tokens

MathGolf 3 ไบต์

¥{k

ลองออนไลน์!

157, 123, 107ไบต์ที่ใช้กันอยู่

คำอธิบาย

¥     Input modulo 2
 {    Loop that many times
  k   Push input

Bash , 31 ไบต์

read a
[ $[a%2] = 0 ] ||echo $a

ลองออนไลน์!

คำอธิบาย:

read a                   reading the input and define it on the variable a
[ $[a%2] = 0 ]      outputs exit status 0 when a/2 is 0 and exit status 1 if not.
||                           evaluates only when the exit status left of it is 1
echo $a                displays the variable a