สลับพาริตี้


22

งาน

รับค่าเป็นจำนวนเต็มบวกnเอาต์พุตn+1ถ้าnเป็นเลขคี่และผลลัพธ์n-1ถ้าnเป็นเลขคู่

อินพุต

จำนวนเต็มบวก คุณอาจคิดว่าจำนวนเต็มอยู่ในความสามารถในการจัดการของภาษา

เอาท์พุต

จำนวนเต็มบวกที่ระบุข้างต้น

Testcases

input output
    1      2
    2      1
    3      4
    4      3
    5      6
    6      5
    7      8
    8      7
  313    314
  314    313

เกณฑ์การให้คะแนน

นี่คือดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ

ช่องโหว่มาตรฐานใช้

อ้างอิง


ขอให้เรารับข้อมูลด้วยความเป็นเอกภาพหรือไม่?
Kritixi Lithos

2
นี่จะน่าแปลกใจมากขึ้นถ้ามันเป็นวิธีอื่นในบางภาษา
MildlyMilquetoast

3
@MistahFiggins เป็นที่รู้จักกันดีพอที่ฉันค่อนข้างมั่นใจว่า OP ทำแบบนี้โดยมีจุดประสงค์
Ørjan Johansen

คำตอบ:


24

C, 20 ไบต์

f(x){return-(-x^1);}

ลองมันออนไลน์


7
@LeakyNun ฉันไม่ได้เขียนฟังก์ชันที่ไม่มีคำสั่ง return
feersum

18
@EriktheOutgolfer เลขที่ Nope Nuh-เอ่อ ไม่
feersum

10
@Sisyphus แต่นี่เป็นโค้ดกอล์ฟและทำงานบนลิงก์ TIO ของฉันดังนั้นจึงใช้ได้
Erik the Outgolfer

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

8
@EriktheOutgolfer หากคำตอบนั้นขึ้นอยู่กับพฤติกรรมการใช้งานที่เฉพาะเจาะจงก็ควรระบุการใช้งาน คำตอบนี้ไม่ได้ดังนั้นรหัสจะไม่ถูกต้อง
Sisyphus

17

Stack Cats , 3 + 3 ( -n) = 6 ไบต์

-*-

ลองออนไลน์!

ต้องการ-nแฟล็กเพื่อทำงานกับอินพุตและเอาต์พุตตัวเลข

คำอธิบาย

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

-   Multiply the input by -1.
*   Toggle the least significant bit of the value (i.e. take it XOR 1).
-   Multiply the result by -1.

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


1
มีการนับค่าสถานะด้วยพื้นที่เพิ่มเติมเสมอฉันไม่คิดว่าฉันเคยเห็นคำตอบอื่น ๆ โดยใช้ค่าสถานะ (เช่น Perl) ทำเช่นนั้นหรือไม่ แก้ไข: NVM ตกลงพบการโพสต์เมตาที่เกี่ยวข้อง " ฉันนับสิ่งเหล่านั้นเป็นความแตกต่างในตัวละครนับเป็นการอุทธรณ์ที่สั้นที่สุดโดยที่ไม่มีพวกเขา " ... " perl -nle 'stuff'คือมากกว่า 2 ตัวอักษรperl -e 'stuff'ดังนั้นจึงนับได้อีก 2 ตัวอักษร " ดังนั้น(space)-nคือ 3 ไบต์มากกว่าโดยไม่มีการตั้งค่าสถานะ
Kevin Cruijssen

@KevinCruijssen ขึ้นอยู่กับจำนวนไบต์ที่คุณต้องเพิ่มในการเรียกใช้ตามปกติ ใน Perl และหลายภาษาการผลิตอื่น ๆ ที่คุณสามารถเรียกใช้รหัสด้วย-e "code"แล้วใส่ธงเพิ่มเติมก่อนเช่นe -pe "code"จากนั้น-pแฟลกจะมีเพียงหนึ่งไบต์ อย่างไรก็ตาม Stack Cats ไม่มี-eอาร์กิวเมนต์ดังกล่าวดังนั้นคุณต้องเพิ่ม<sp>-nคำสั่งแบบเต็มเสมอและด้วยเหตุนี้จึงมีสามไบต์
Martin Ender

12

ชุดประกอบ x86, 9 ไบต์ (สำหรับการแข่งขัน)

ทุกคนที่พยายามใช้ความท้าทายนี้ในภาษาระดับสูงนั้นพลาดไม่ได้กับความสนุกที่แท้จริงของการจัดการบิตดิบ มีวิธีการทำสิ่งต่าง ๆ ที่หลากหลายมากมายมันบ้าและสนุกมากที่จะคิด ต่อไปนี้เป็นคำตอบบางส่วนที่ฉันคิดในภาษาแอสเซมบลี x86 แบบ 32 บิต

ฉันขอโทษล่วงหน้าว่านี่ไม่ใช่คำตอบของ code-golf ทั่วไป ฉันจะเดินเล่นมากเกี่ยวกับกระบวนการคิดของการเพิ่มประสิทธิภาพซ้ำ (สำหรับขนาด) หวังว่าจะน่าสนใจและให้ความรู้แก่ผู้ชมจำนวนมาก แต่ถ้าคุณเป็นประเภท TL; DR ฉันจะไม่โกรธถ้าคุณข้ามไปจนจบ

วิธีแก้ปัญหาที่ชัดเจนและมีประสิทธิภาพคือการทดสอบว่าค่าเป็นเลขคี่หรือคู่ (ซึ่งสามารถทำได้อย่างมีประสิทธิภาพโดยการดูบิตที่มีนัยสำคัญน้อยที่สุด) จากนั้นเลือกระหว่างn + 1หรือn. 1ตามลำดับ สมมติว่าอินพุตถูกส่งผ่านเป็นพารามิเตอร์ในECXรีจิสเตอร์และผลลัพธ์ถูกส่งคืนในEAXรีจิสเตอร์เราจะได้รับฟังก์ชั่นต่อไปนี้:

F6 C1 01  |  test  cl, 1                      ; test last bit to see if odd or even
8D 41 01  |  lea   eax, DWORD PTR [ecx + 1]   ; set EAX to n+1 (without clobbering flags)
8D 49 FF  |  lea   ecx, DWORD PTR [ecx - 1]   ; set ECX to n-1 (without clobbering flags)
0F 44 C1  |  cmovz eax, ecx                   ; move in different result if input was even
C3        |  ret

(13 ไบต์)

แต่สำหรับ code-golf LEAคำแนะนำเหล่านั้นไม่ดีนักเนื่องจากใช้เวลาในการเข้ารหัส 3 ไบต์ การเรียบง่ายแบบDECใหม่ECXจะสั้นกว่ามาก (เพียงหนึ่งไบต์) แต่สิ่งนี้มีผลต่อการตั้งค่าสถานะดังนั้นเราจึงต้องมีความชาญฉลาดเล็กน้อยในการจัดเรียงรหัส เราสามารถทำพร่องแรกและคู่ / คี่ทดสอบที่สองแต่แล้วเราจะต้องกลับผลของการทดสอบคี่ / แม้กระทั่ง

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

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

    48     |  dec  eax          ; decrement first
    A8 01  |  test al, 1        ; test last bit to see if odd or even
    75 02  |  jnz  InputWasEven ; (decrement means test result is inverted)
    40     |  inc  eax          ; undo the decrement...
    40     |  inc  eax          ; ...and add 1
  InputWasEven:                 ; (two 1-byte INCs are shorter than one 3-byte ADD with 2)

(inlined: 7 ไบต์; เป็นฟังก์ชัน: 10 ไบต์)

แต่ถ้าคุณต้องการให้มันเป็นฟังก์ชั่นล่ะ? ไม่มีการเรียกแบบแผนมาตรฐานที่ใช้การลงทะเบียนเดียวกันเพื่อส่งผ่านพารามิเตอร์เช่นเดียวกับค่าส่งคืนดังนั้นคุณจะต้องเพิ่มMOVคำสั่งการลงทะเบียนลงทะเบียนที่จุดเริ่มต้นหรือจุดสิ้นสุดของฟังก์ชัน นี่แทบไม่มีค่าใช้จ่ายในเรื่องความเร็ว แต่มันเพิ่ม 2 ไบต์ ( RETคำสั่งนี้ยังเพิ่มไบต์และมีค่าใช้จ่ายที่แนะนำโดยความต้องการที่จะทำและกลับมาจากการเรียกใช้ฟังก์ชั่นซึ่งหมายความว่านี่คือตัวอย่างหนึ่งที่อินไลน์ทำให้เกิดประโยชน์ทั้งความเร็วและขนาดแทนที่จะเป็นความเร็วแบบคลาสสิก การแลกเปลี่ยนพื้นที่สำหรับ.) ในทั้งหมดเขียนเป็นฟังก์ชั่นรหัสนี้ขยายตัวถึง 10 ไบต์

เราสามารถทำอะไรได้อีกใน 10 ไบต์? ถ้าเราใส่ใจเรื่องประสิทธิภาพ (อย่างน้อยก็คาดเดาได้ ) มันคงจะดีถ้าได้กำจัดสาขานั้น นี่เป็นวิธีการแก้ปัญหากิ่งก้านสาขาที่มีขนาดเท่าไบต์ หลักฐานขั้นพื้นฐานนั้นง่าย: เราใช้บิต XOR เพื่อพลิกบิตสุดท้ายแปลงค่าแปลก ๆ ให้เป็นเลขคู่และในทางกลับกัน แต่มี niggle หนึ่งอัน - สำหรับอินพุตแปลก ๆ , ที่ให้n-1แก่เรา, ในขณะที่สำหรับอินพุตแม้แต่, มันให้n + 1 เรา - ตรงข้ามกับสิ่งที่เราต้องการ ดังนั้นเพื่อแก้ไขปัญหานั้นเราดำเนินการกับค่าลบพลิกเครื่องหมายอย่างมีประสิทธิภาพ

8B C1     |  mov eax, ecx   ; copy parameter (ECX) to return register (EAX)
          |
F7 D8     |  neg eax        ; two's-complement negation
83 F0 01  |  xor eax, 1     ; XOR last bit to invert odd/even
F7 D8     |  neg eax        ; two's-complement negation
          |
C3        |  ret            ; return from function

(inlined: 7 ไบต์; เป็นฟังก์ชัน: 10 ไบต์)

เนียนสวย เป็นการยากที่จะทราบว่าสามารถปรับปรุงได้อย่างไร สิ่งหนึ่งดึงดูดสายตาของฉัน: NEGคำแนะนำ2 ไบต์ทั้งสองนี้ ตรงไปตรงมาสองไบต์ดูเหมือนว่าหนึ่งไบต์มากเกินไปที่จะเข้ารหัสการปฏิเสธอย่างง่าย ๆ แต่นั่นเป็นชุดคำสั่งที่เราต้องทำงานด้วย มีวิธีแก้ไขปัญหาหรือไม่? แน่นอน! ถ้าเราXORคูณ -2 เราสามารถแทนที่NEGation ตัวที่สองด้วยINCrement:

8B C1     |  mov eax, ecx
          |
F7 D8     |  neg eax
83 F0 FE  |  xor eax, -2
40        |  inc eax
          |
C3        |  ret

(inlined: 6 ไบต์; เป็นฟังก์ชัน: 9 ไบต์)

หนึ่งในความแปลกประหลาดของชุดคำสั่ง x86 ก็คือคำสั่งอเนกประสงค์LEAซึ่งสามารถทำการย้ายรีจิสเตอร์ลงทะเบียนการเพิ่มรีจิสเตอร์รีจิสเตอร์ชดเชยด้วยค่าคงที่และปรับขนาดทั้งหมดในคำสั่งเดียว!

8B C1        |  mov eax, ecx
83 E0 01     |  and eax, 1        ; set EAX to 1 if even, or 0 if odd
8D 44 41 FF  |  lea eax, DWORD PTR [ecx + eax*2 - 1]
C3           |  ret

(10 ไบต์)

ANDการเรียนการสอนเป็นเหมือนTESTการเรียนการสอนที่เราใช้ก่อนหน้านี้ในการที่ทั้งสองทำบิต-AND และชุดธงตาม แต่ANDจริง ๆ การปรับปรุงตัวถูกดำเนินปลายทาง LEAการเรียนการสอนแล้วตาชั่งนี้โดย 2 เพิ่มมูลค่าการป้อนข้อมูลเดิมและลดลงทีละ 1 โดยหากค่าการป้อนข้อมูลที่เป็นเลขคี่หัก 1 (2 × 0-1 = -1) จากมัน; ถ้าค่าอินพุตเป็นเลขคู่จะเพิ่ม 1 (2 × 1 - 1 = 1) ลงไป

นี่เป็นวิธีที่รวดเร็วและมีประสิทธิภาพในการเขียนโค้ดเนื่องจากการประมวลผลส่วนใหญ่สามารถทำได้ในส่วนหน้า แต่ก็ไม่ได้ซื้อเรามากนักในทางไบต์เนื่องจากใช้การเข้ารหัสซับซ้อนLEAคำแนะนำ. รุ่นนี้ยังใช้งานไม่ได้กับจุดประสงค์ในการอินไลน์เนื่องจากมันต้องการให้ค่าอินพุตดั้งเดิมถูกสงวนไว้เป็นอินพุตของLEAคำสั่ง ดังนั้นด้วยความพยายามในการเพิ่มประสิทธิภาพครั้งล่าสุดนี้เราจึงย้อนกลับไปตามความเป็นจริงโดยบอกว่าอาจถึงเวลาหยุด


ดังนั้นสำหรับการแข่งขันรายการสุดท้ายเรามีฟังก์ชั่น 9- ไบต์ที่รับค่าอินพุตในECXรีจิสเตอร์ (แบบแผนการเรียกใช้การลงทะเบียนแบบกึ่งมาตรฐานบน 32- บิต x86) และส่งกลับผลลัพธ์ในEAXรีจิสเตอร์ (เช่นเดียวกับ ประชุม x86 ทั้งหมด):

           SwapParity PROC
8B C1         mov eax, ecx
F7 D8         neg eax
83 F0 FE      xor eax, -2
40            inc eax
C3            ret
           SwapParity ENDP

พร้อมที่จะประกอบกับ MASM; โทรจาก C เป็น:

extern int __fastcall SwapParity(int value);                 // MSVC
extern int __attribute__((fastcall)) SwapParity(int value);  // GNU   

จะไม่dec eax; xor eax, 1; inc eaxทำงานและประหยัดอีกหนึ่งไบต์หรือไม่
Ilmari Karonen

11

เยลลี่ 3 ไบต์

-*ạ

ลองออนไลน์!

pseudocode: abs((-1)**n - n)


ฉันเป็นจริงวางแผนที่จะ -1(AB)
Erik the Outgolfer

ขอโทษสำหรับสิ่งนั้น.
Leun Nun

ไม่มีขออภัยทำดีมาก! ฉันไม่ได้คิดว่าจะทำมันเร็วพอ ...
Erik the Outgolfer

11

Python3, 20 18 ไบต์

lambda n:n-1+n%2*2

ค่อนข้างง่าย ก่อนอื่นเราคำนวณ n-1และตัดสินใจว่าจะบวก 2 ลงไปหรือไม่

ถ้า n เป็นเลขคู่ -> n mod 2จะเป็น 0 ดังนั้นเราจะเพิ่ม2 * 0ถึงn-1ทำให้ได้ผลลัพธ์ n-1

หาก n คือคี่ -> n mod 2จะเป็น 1 ดังนั้นเราจะเพิ่ม2 * 1ไป n-1ส่งผลให้ใน1 + n

ฉันชอบคำอธิบายที่ฉันใช้กับโปรแกรมระบายสี MS & ทัชแพดแล็ปท็อป ... คำอธิบายภาพ


10

Python ขนาด 16 ไบต์

lambda x:-(-x^1)

ลองออนไลน์!


3
เดรัจฉานบังคับไม่พบวิธีการแก้ปัญหาใด ๆ "x+-012~|&^()*/%"ที่สั้นลงโดยใช้ตัวละครใน
xnor

@ xnor สิ่งที่ดีฉันได้รับมันแล้ว!
sagiksp

1
และดูเหมือนว่าจะไม่มีการแก้ปัญหาเดียวกันที่มีความยาวอื่น ๆ -(1^-x)ยกเว้นการปรับปรุงใหม่เล็กน้อย
xnor

8

MATL , 7 ไบต์

Q:HePG)

สิ่งนี้จะหลีกเลี่ยงการดำเนินการทางคณิตศาสตร์ใด ๆ ลองออนไลน์!

คำอธิบาย

พิจารณาการป้อนข้อมูล4เป็นตัวอย่าง

Q    % Implicit input. Add 1
     % STACK: 5
:    % Range
     % STACK: [1 2 3 4 5]
He   % Reshape with 2 rows in column-major order. Pads with a zero if needed
     % STACK: [1 3 5;
               2 4 0]
P    % Flip vertically
     % STACK: [2 4 0;
               1 3 5]
G    % Push input again
     % STACK: [2 4 0;
               1 3 5], 4
)    % Index, 1-based, in column major order. Implicitly display
     % STACK: 3

1
ดี! ชอบมัน !
Stewie Griffin

6

Braingolf v0.1 , 11 10 ไบต์

.1>2,%?+:-

ลองออนไลน์! (อาร์กิวเมนต์ที่สองคือรหัส Braingolf อาร์กิวเมนต์ที่สามคืออินพุต)

บันทึกเป็นไบต์ขอบคุณ Neil

braingolf ที่แข่งขันกันเป็นครั้งแรกตอบ: D

คำอธิบาย:

.            Duplicate the top of the stack
 1>          Push 1 to the bottom of the stack
   2         Push 2 to stack
    ,%       Pop last 2 items, mod them and push result
      ?      If last item > 0
       +     Add the 1 to the input
        :    Else
         -   Subtract the 1 from the input

             No semicolon in code so print last item

Braingolf v0.2 , 9 ไบต์ [ไม่แข่งขัน]

.2%?1+:1-

ลองออนไลน์! (อาร์กิวเมนต์ที่สองคือรหัส Braingolf อาร์กิวเมนต์ที่สามคืออินพุต)

ดูคำอธิบายด้านบน ความแตกต่างเพียงอย่างเดียวคือ Braingolf v0.2, พฤติกรรมเริ่มต้นของผู้ปฏิบัติงาน diadic, และฟังก์ชั่นของ,ตัวดัดแปลง, จะถูกสลับกลับ, หมายถึงคอมม่า2 ตัวในคำตอบ v0.1 ไม่จำเป็นอีกต่อไป

อย่างไรก็ตาม v0.2 ได้รับการปล่อยตัวหลังจากการท้าทายดังนั้นจึงไม่ใช่การแข่งขัน


5
ขอแสดงความยินดีกับภาษาใหม่ของคุณ!
Leun Nun

ไม่.1<2,%?+:-ทำในสิ่งที่ผมคิดว่ามันไม่?
Neil

@Neil ไม่มากที่คุณจะต้องจุลภาคก่อนที่-จะให้มันดำเนินการวิธีที่ถูกต้องรอบในกรณีที่มันยังคงต้องการจะยาวเช่นเดียวกับคำตอบของฉัน
Skidsdev

@Mayube ฉันคาดว่า<จะหมุน1ด้านล่างอินพุตดังนั้นมันจะอยู่ในตำแหน่งที่ถูกต้องแล้ว
Neil

@ Neil หากอินพุตเป็นจำนวนคู่ตามเวลาที่มาถึง-สแต็กจะมีลักษณะเช่นนี้: [n,1]ตัวดำเนินการ braingolf กลับด้านดังนั้นมันจะทำงาน1 - nซึ่งจะส่งผลให้เกิดผลลัพธ์-(n-1)ที่ต้องการเพียงn-1
Skidsdev

5

Cubix , 10 9 ไบต์

cO1)I(//@

ลองออนไลน์

คำอธิบาย

รุ่นสุทธิ

    c O
    1 )
I ( / / @ . . .
. . . . . . . .
    . .
    . .

ตัวละครที่ดำเนินการคือ

I(1c)O@
I          Input
 (         Decrement
  1c       XOR with 1
    )      Increment
     O@    Output and exit

4

Python ขนาด 68 ไบต์

lambda x:[m.floor(x-m.cos(m.pi*x)) for m in [__import__('math')]][0]

ในจิตวิญญาณของแนวทางที่เป็นเอกลักษณ์ กราฟต่อไปนี้แสดงฟังก์ชั่น (ที่มีจุดสีม่วงแสดงถึง 10 กรณีแรก) ในทางทฤษฎีแล้วมันควรจะเป็นไปได้ที่จะสร้างคำตอบสำหรับคำถามนี้โดยยึดตามฟังก์ชันส่วนใหญ่ (ทั้งหมด?) (เช่น sin, tan, sec) ในความเป็นจริงการแทนที่ cos เป็นวินาทีในรหัสตามที่ควรจะเป็น

ฟังก์ชั่นการสาธิตกราฟ


3

PHP, 15 ไบต์

<?=-(-$argn^1);

2
ฉันจะเรียกใช้สิ่งนี้ได้อย่างไร ฉันพยายามที่จะทดสอบว่า;จำเป็นหรือไม่และได้ลองใช้.phpไฟล์และสะท้อนไปยัง php โดยตรง (php7 cli.) ทุกครั้งที่ฉันบอกว่านั่น$argnเป็นตัวแปรที่ไม่ได้กำหนด
Andrakis

2
@Andrakis ด้วยธงและท่อ:F echo 42 | php -F script.php
user63956

3

Javascript, 17 12 ไบต์

x=>x-(-1)**x

f=x=>x-(-1)**x;
<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

อีกวิธีหนึ่งคือ 10 ไบต์ถูกขโมยจากคำตอบ C (sssshhh)

x=>-(-x^1)

f=x=>-(-x^1)
<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>


1. คุณไม่จำเป็นต้องใส่เครื่องหมายอัฒภาค 2.x=>x-(-1)**x
Leun Nun

ทำไม|0? โซลูชันทั้งสองดูเหมือนว่าควรแปลงสตริงเป็นตัวเลขโดยอัตโนมัติ (สำหรับวิธีแก้ปัญหาแรกหากคุณต้องการหลีกเลี่ยงการใช้ทศนิยม<input type=number>)
Neil

@ Neil ขอบคุณที่แจ้งให้ฉันทราบ!
Matthew Roh

3

JavaScript (ES6), 14 13 12 10 ไบต์

n=>-(-n^1)
  • 1 ไบต์บันทึกขอบคุณที่ให้ลุค
  • 2 ไบต์บันทึกไว้โดย porting feersum โซลูชั่น (หากถูกขมวดคิ้วโปรดแจ้งให้เราทราบและฉันจะย้อนกลับไปยังโซลูชันก่อนหน้าของฉันด้านล่าง)

ลองมัน

f=
n=>-(-n^1)
i.addEventListener("input",_=>o.innerText=f(+i.value))
<input id=i type=number><pre id=o>


ดั้งเดิม 12 ไบต์

n=>n-1+n%2*2

2

Python 20 ไบต์

lambda n:n+(n%2or-1)

n%2or-1จะคืนค่า 1 หากมันเป็นเลขคี่ แต่ถ้าเป็นเลขคู่n%2จะเป็น "false" (0) ดังนั้นจะส่งกลับค่า -1 จากนั้นเราก็เพิ่มมันเข้าไปnจากนั้นเราก็เพิ่มที่

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

lambda n:[n-1,n+1][n%2]

n%2คำนวณเหลือเมื่อnถูกหารด้วย 2. ถ้ามันแม้ผลตอบแทนนี้ 0 และองค์ประกอบ 0 n-1ในรายการนี้คือ ถ้ามันแปลกนี้ส่งกลับที่ 1 และองค์ประกอบที่ 1 n+1ในรายการนี้คือ


1
ใช้แลมบ์ดาlambda n:[n-1,n+1][n%2]
แม่ชีที่รั่ว

ใช่แล้วดังนั้นมันจึงสั้นลงในกรณีนี้ เสร็จแล้วขอบคุณ!
numbermaniac

2

เรติน่า 21 ไบต์

.+
$*
^11(?=(11)*$)


ลองออนไลน์! จอประสาทตาตัวแรกของฉันตอบด้วยการขึ้นบรรทัดใหม่สองบรรทัด! คำอธิบาย: สองบรรทัดแรกแปลงจากทศนิยมเป็น unary บรรทัดที่สามและสี่จะลบสองเส้นออกจากตัวเลขคู่ บรรทัดสุดท้ายแปลงกลับเป็นทศนิยม แต่เพิ่มอีกหนึ่งบรรทัด



2

Cubix , 11 ไบต์

u%2!I(/+@O<

ลองออนไลน์!

คำอธิบาย

รุ่นสุทธิ:

    u %
    2 !
I ( / + @ O < .
. . . . . . . .
    . .
    . .

ตัวละครจะถูกดำเนินการในลำดับต่อไปนี้:

I(2%!+O@
I        # Take a number as input
 (       # Decrement it
  2%     # Take the parity of the decremented number
         # (0 if the input is odd, 1 if it's even)
    !    # If that number is zero:
     +   #   Add 2
      O  # Output the number
       @ # Terminate the program

2

Brain-Flakขนาด 36 ไบต์

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

ลองออนไลน์!

ฉันมีความสุขจริงๆกับคำตอบนี้เพราะสั้นกว่าสิ่งที่ฉันคิดว่าเป็นวิธีดั้งเดิมในการแก้ปัญหานี้

คำอธิบาย

รหัสบิตแรก

(({})(()))

แปลงสแต็กจากเพียงnเป็น

n + 1
  1
  n

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

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

เราจะลบศูนย์และเพิ่มจำนวนที่เหลืออีกสองตัว

{}({}{})

2

Mathematica, 22 19 ไบต์

บันทึก 3 ไบต์ด้วย Greg Martin!

#-1[-1][[#~Mod~2]]&

คำตอบก่อนหน้า 22 ไบต์

#+{-1,1}[[#~Mod~2+1]]&

คำอธิบาย (สำหรับคำตอบก่อนหน้า)

Mathematica มีคุณสมบัติที่ดีที่การดำเนินการเช่นเลขคณิตจะเธรดรายการโดยอัตโนมัติ

ในกรณีนี้เราจะใช้Mod[#,2]ซึ่งจะส่งกลับ 0 หรือ 1 แต่เราต้องเพิ่ม 1 เพราะรายการ Mathematica เป็นดัชนี 1 ถ้าเป็นเช่นนั้นสิ่งนี้จะออกมาเป็น 1 ดังนั้น#-1จะถูกส่งคืน ถ้ามันแปลกนี่จะออกมาเป็น 2 ดังนั้น#+1จะถูกส่งคืน


2
คุณสามารถบันทึกสามไบต์โดยเหยียดหยาม Mathematica ของความสามารถ:[[0]] #-1[-1][[#~Mod~2]]&
Greg Martin

นั่นเป็นบ้าไม่เคยคิดอย่างนั้น เสร็จแล้วขอบคุณ!
numbermaniac

2

ฉลาด 8 ไบต์

-::^~-^-

ลองออนไลน์!

คำอธิบาย

ถ้านี่เป็นวิธีอื่น ๆ (ลดลงถ้าแปลกเพิ่มขึ้นถ้าเท่ากัน) มันจะค่อนข้างง่ายที่จะทำ

เราจะพลิกบิตสุดท้าย

::^~-^

การแก้ไขที่นี่คือว่าเราพลิกบิตสุดท้ายในขณะที่ลบ จำนวนลบเป็น 1 จากการปฏิเสธของตัวเลข~ดังนั้นสิ่งนี้สร้างออฟเซ็ตการแก้ไขปัญหา

-ดังนั้นเราก็จะออกจากโปรแกรมและห่อไว้ใน

-::^~-^-

1

Java 8, 16 10 ไบต์

n->-(-n^1)

Java 7, 34 28 ไบต์

int c(int n){return-(-n^1);}

น่าเบื่อพอร์ตของ@feersum 'คำตอบ C ที่น่าตื่นตาตื่นใจ
ลองที่นี่


คำตอบเก่า:

Java 8, 16 ไบต์

n->n%2<1?n-1:n+1

Java 7, 34 ไบต์

int c(int n){return--n%2>0?n:n+2;}

คำอธิบาย (ของคำตอบ Java 7 เก่า):

ลองที่นี่

คำตอบข้างต้นเป็นตัวแปรที่สั้นกว่าint c(int n){return n%2<1?n-1:n+1;}โดยการกำจัดพื้นที่

int c(int n){     // Method with integer parameter and integer return-type
  return--n%2>0?  //  If n-1 mod-2 is 1:
    n             //   Return n-1
   :              //  Else:
    n+2;          //   Return n+1
}                 // End of method



1

Befunge 93 , 18 ไบต์

&:2%#v_1+.@
@.-1 <

ฉันยังเล่นกอล์ฟไม่เสร็จ (ฉันหวังว่า)


เคล็ดลับการเล่นกอล์ฟ: Befunge 98 มีความสามารถในการใช้งานkv(หรือjvถ้ามันเป็นอย่างเคร่งครัด 1 หรือ 0) #v_แทน นอกจากนี้ถ้าคุณใช้ลองออนไลน์ (และฉันแนะนำ) คุณสามารถจบโปรแกรมด้วยโปรแกรมอื่น&(แม้ว่าจะใช้เวลา 60 วินาที) ดังนั้นคุณสามารถกำจัด@บรรทัดแรกได้หากคุณใช้ นี่คือรายการคำสั่งเต็มรูปแบบสำหรับ Befunge-98ถึงแม้ว่าคำสั่งเหล่านั้นอาจไม่ได้นำไปใช้อย่างถูกต้องใน TIO เช่นการ&สิ้นสุดโปรแกรมแทนการย้อนกลับบน EOF
MildlyMilquetoast

นอกจากนี้ดูเหมือนว่าคุณกำลังใช้ befunge 93 แทน 98 ซึ่งมีคำสั่งน้อยลง คุณอาจต้องการแก้ไขชื่อลิงก์ของคุณหากเป็น 93 และไม่ใช่ 98
MildlyMilquetoast

@MistahFiggins อ่าใช่คุณถูกต้องฉันใช้ 93
Daniel


1

R, 17 ไบต์

(n=scan())-(-1)^n

ที่n=scan()นำค่าหลัก


ฉันคิดว่าคุณต้องการ-(-1)^nมากกว่าที่+(-1)^nเราต้องการคืนn-1หากnเป็นเช่นนั้น
Giuseppe

@Giuseppe โอ้ใช่แน่นอนผิดพลาดโง่
Nutle

1

Casio-Basic ขนาด 27 ไบต์

piecewise(mod(n,2),1,-1)+n

26 ไบต์สำหรับฟังก์ชัน +1 เพื่อป้อนnในกล่องพารามิเตอร์




0

แบตช์ 20 ไบต์

@cmd/cset/a"-(1^-%1)

ค้นพบอัลกอริทึมของ @ feersum ที่ค้นพบใหม่ได้อย่างอิสระซื่อสัตย์!

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.