Tugas

Diberikan bilangan bulat positif n, keluaran n+1jika nganjil, dan keluaran n-1jika ngenap.

Memasukkan

Bilangan bulat positif. Anda dapat berasumsi bahwa integer berada dalam kemampuan penanganan bahasa.

Keluaran

Bilangan bulat positif, ditentukan di atas.

Testcases

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

Mencetak gol

Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.

Celah standar berlaku.

Referensi

• OEIS A103889

C, 20 byte

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

Cobalah online .

Stack Cats , 3 + 3 ( -n) = 6 byte

-*-

Cobalah online!

Membutuhkan -nflag untuk bekerja dengan input dan output numerik.

Penjelasan

Stack Cats biasanya jauh dari kompetitif, karena serangkaian perintah yang terbatas (semuanya injeksi, dan sebagian besar adalah involusi) dan karena setiap program perlu memiliki simetri cermin. Namun, salah satu keterlibatan adalah untuk mengalihkan bit paling tidak signifikan dari angka, dan kita dapat mengimbangi nilainya dengan negasi unary yang juga ada. Untungnya, itu memberi kita program simetris, jadi kita tidak perlu khawatir tentang hal lain:

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

Input dan output implisit pada awal dan akhir program, karena mengambil input dan menghasilkan output bukanlah operasi yang dapat dibalik, sehingga mereka tidak bisa menjadi perintah.

x86 Assembly, 9 byte (untuk entri yang bersaing)

Setiap orang yang mencoba tantangan ini dalam bahasa tingkat tinggi kehilangan kesenangan nyata memanipulasi bit mentah. Ada begitu banyak variasi halus tentang cara melakukan ini, ini gila — dan banyak kesenangan untuk dipikirkan. Berikut adalah beberapa solusi yang saya rancang dalam bahasa assembly x86 32-bit.

Saya mohon maaf sebelumnya bahwa ini bukan jawaban khas kode-golf. Saya akan mengoceh banyak tentang proses pemikiran optimasi berulang (untuk ukuran). Semoga itu menarik dan mendidik untuk audiens yang lebih besar, tetapi jika Anda adalah tipe TL; DR, saya tidak akan tersinggung jika Anda melewatkannya sampai akhir.

Solusi yang jelas dan efisien adalah menguji apakah nilainya ganjil atau genap (yang dapat dilakukan secara efisien dengan melihat bit yang paling tidak signifikan), dan kemudian memilih antara n + 1 atau n − 1 yang sesuai. Dengan asumsi bahwa input dilewatkan sebagai parameter dalam ECXregister, dan hasilnya dikembalikan dalam EAXregister, kita mendapatkan fungsi berikut:

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 byte)}

Tetapi untuk tujuan kode-golf, LEAinstruksi itu tidak bagus, karena mereka membutuhkan 3 byte untuk dikodekan. DECRement sederhana ECXakan jauh lebih pendek (hanya satu byte), tetapi ini mempengaruhi flag, jadi kita harus sedikit pintar dalam bagaimana kita mengatur kode. Kita dapat melakukan pengurangan pertama , dan tes ganjil / genap kedua , tetapi kemudian kita harus membalikkan hasil tes ganjil / genap.

Juga, kita dapat mengubah instruksi pemindahan bersyarat ke cabang, yang dapat membuat kode berjalan lebih lambat (tergantung pada seberapa dapat diprediksi cabang itu - jika input bergantian secara tidak konsisten antara ganjil dan genap, cabang akan lebih lambat; jika ada pola, itu akan lebih cepat), yang akan menyelamatkan kita byte lain.

Bahkan, dengan revisi ini, seluruh operasi dapat dilakukan di tempat, hanya menggunakan satu register. Ini bagus jika Anda memasukkan kode ini di suatu tempat (dan kemungkinan besar, Anda pasti akan melakukannya, karena ini sangat singkat).

    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)

^{(sebaris: 7 byte; sebagai fungsi: 10 byte)}

Tetapi bagaimana jika Anda memang ingin membuatnya berfungsi? Tidak ada konvensi panggilan standar yang menggunakan register yang sama untuk melewatkan parameter seperti halnya untuk nilai pengembalian, jadi Anda perlu menambahkan MOVinstruksi register-register ke awal atau akhir fungsi. Ini hampir tidak ada biaya dalam kecepatan, tetapi menambah 2 byte. ( RETInstruksi ini juga menambahkan byte, dan ada beberapa overhead yang diperkenalkan oleh kebutuhan untuk membuat dan kembali dari panggilan fungsi, yang berarti ini adalah salah satu contoh di mana inlining menghasilkan kecepatan dan manfaat ukuran, daripada hanya menjadi kecepatan klasik -untuk pengorbanan ruang.) Secara keseluruhan, ditulis sebagai fungsi, kode ini membengkak hingga 10 byte.

Apa lagi yang bisa kita lakukan dalam 10 byte? Jika kita benar-benar peduli tentang kinerja (setidaknya, kinerja yang dapat diprediksi ), alangkah baiknya untuk menyingkirkan cabang itu. Berikut ini adalah solusi branchless, bit-twiddling yang ukurannya sama dengan byte. Premis dasarnya sederhana: kita menggunakan bitor XOR untuk membalik bit terakhir, mengubah nilai ganjil menjadi genap genap, dan sebaliknya. Tapi ada satu niggle — untuk input ganjil, yang memberi kita n-1 , sedangkan untuk input genap, ia memberi kita n +1 - persis berlawanan dengan yang kita inginkan. Jadi, untuk memperbaikinya, kami melakukan operasi pada nilai negatif, secara efektif membalik tanda.

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

^{(sebaris: 7 byte; sebagai fungsi: 10 byte)}

Cukup apik; sulit untuk melihat bagaimana hal itu dapat diperbaiki. Satu hal yang menarik perhatian saya: dua NEGinstruksi 2 byte itu . Terus terang, dua byte sepertinya satu byte terlalu banyak untuk menyandikan negasi sederhana, tapi itu adalah set instruksi yang harus kita kerjakan. Apakah ada solusi? Yakin! Jika XORdengan -2, kita dapat mengganti NEGasi kedua dengan INCrement:

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

^{(sebaris: 6 byte; sebagai fungsi: 9 byte)}

Satu lagi keanehan dari set instruksi x86 adalah instruksi multigunaLEA , yang dapat melakukan gerakan register-register, penambahan register-register, dikompensasi dengan konstanta, dan menskalakan semua dalam satu instruksi tunggal!

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 byte)}

The ANDinstruksi seperti TESTinstruksi kita gunakan sebelumnya, dalam bahwa baik melakukan bitwise-AND dan set bendera sesuai, tapi ANDbenar-benar memperbarui tujuan operan. The LEAinstruksi kemudian skala ini dengan 2, menambah nilai masukan asli, dan decrements oleh 1. Jika nilai masukan aneh, mengurangi ini 1 (2 × 0-1 = -1) dari itu; jika nilai inputnya genap, ini menambah 1 (2 × 1 - 1 = 1) padanya.

Ini adalah cara yang sangat cepat dan efisien untuk menulis kode, karena banyak dari eksekusi dapat dilakukan di front-end, tetapi itu tidak memberi kita banyak dalam hal byte, karena dibutuhkan begitu banyak untuk mengkodekan kompleks LEApetunjuk. Versi ini juga tidak berfungsi dengan baik untuk tujuan inlining, karena mengharuskan nilai input asli dipertahankan sebagai input dari LEAinstruksi. Jadi dengan upaya pengoptimalan terakhir ini, kami telah benar-benar mundur, menyarankan mungkin sudah waktunya untuk berhenti.

Jadi, untuk entri terakhir yang bersaing, kami memiliki fungsi 9-byte yang mengambil nilai input dalam ECXregister ( konvensi panggilan berbasis register semi-standar pada 32-bit x86), dan mengembalikan hasilnya dalam EAXregister (seperti halnya semua konvensi pemanggilan 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

Siap berkumpul dengan MASM; panggilan dari C sebagai:

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

Jelly , 3 byte

-*ạ

Cobalah online!

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

Python3, 20 18 byte

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

Cukup mudah. Pertama kita menghitung n-1 dan memutuskan apakah akan menambahkan 2 ke dalamnya, atau tidak.

Jika n genap -> n mod 2 akan menjadi 0, maka kita akan menambahkan 2 * 0 ke n-1 , menghasilkan n-1 .

Jika n ganjil -> n mod 2 akan menjadi 1, maka kami akan menambahkan 2 * 1 ke n-1 , menghasilkan n + 1 .

Saya lebih suka penjelasan yang saya buat dengan cat MS & touchpad laptop ...

Python, 16 byte

lambda x:-(-x^1)

Cobalah online!

MATL , 7 byte

Q:HePG)

Ini menghindari operasi aritmatika. Cobalah online!

Penjelasan

Pertimbangkan input 4sebagai contoh.

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

Braingolf v0.1 , 11 10 byte

.1>2,%?+:-

Cobalah online! (Argumen kedua adalah kode Braingolf, argumen ketiga adalah input)

Menyimpan satu byte berkat Neil

Jawaban braingolf yang pertama kali bersaing: D

Penjelasan:

.            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 byte [tidak bersaing]

.2%?1+:1-

Cobalah online! (Argumen kedua adalah kode Braingolf, argumen ketiga adalah input)

Lihat penjelasan di atas. Hanya perbedaannya dalam Braingolf v0.2, perilaku default operator diadik, dan fungsi ,pengubah, dibalik, artinya 2 koma dalam jawaban v0.1 tidak lagi diperlukan.

Namun v0.2 dirilis setelah tantangan, jadi yang ini tidak bersaing

Cubix , 10 9 byte

cO1)I(//@

Cobalah online

Penjelasan

Versi bersih

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

Karakter yang dieksekusi adalah

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

Python, 68 byte

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

Dalam semangat pendekatan yang unik. Grafik berikut menunjukkan fungsi (dengan titik-titik ungu mewakili 10 kasus pertama). Seharusnya secara teori dimungkinkan untuk membangun solusi untuk pertanyaan ini berdasarkan sebagian besar (semua?) Fungsi periodik (misalnya dosa, tan, detik). Bahkan, mengganti cos untuk sec dalam kode sebagaimana mestinya bekerja.

PHP, 15 byte

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

Javascript, 17 12 byte

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

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

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

Pendekatan lain, 10 byte _{dicuri dari jawaban C (sssshhh)}

x=>-(-x^1)

f=x=>-(-x^1)

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

JavaScript (ES6), 14 13 12 10 byte

n=>-(-n^1)

• 1 byte disimpan berkat Luke .
• 2 byte disimpan oleh porting solusi C feersum . (Jika itu disukai, tolong beri tahu saya dan saya akan kembali ke solusi saya sebelumnya di bawah)

Cobalah

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

<input id=i type=number><pre id=o>

Asli, 12 byte

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

Python, 20 byte

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

n%2or-1 akan mengembalikan 1 jika aneh, tetapi jika bahkan, n%2 adalah "false" (0), jadi ia mengembalikan -1. Kemudian kita cukup menambahkannya ke n.

Solusi sebelumnya, 23 byte

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

n%2menghitung sisa ketika ndibagi dengan 2. Jika itu genap, ini mengembalikan 0, dan elemen 0 dalam daftar ini adalah n-1. Jika aneh, ini mengembalikan 1, dan elemen 1 dalam daftar ini adalah n+1.

Retina , 21 byte

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

Cobalah online! Jawaban Retina pertama saya dengan dua baris baru! Penjelasan: Dua baris pertama dikonversi dari desimal ke unary. Baris ketiga dan keempat mengurangkan dua dari angka genap. Baris terakhir mengkonversi kembali ke desimal, tetapi menambahkannya juga.

05AB1E , 4 byte

(1^(

Cobalah online!

Cubix , 11 byte

u%2!I(/+@O<

Cobalah online!

Penjelasan

Versi bersih:

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

Karakter dieksekusi dalam urutan berikut:

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

Brain-Flak , 36 byte

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

Cobalah online!

Saya pribadi sangat senang dengan jawaban ini karena jauh lebih pendek daripada apa yang saya anggap metode tradisional untuk memecahkan masalah ini.

Penjelasan

Bit kode pertama

(({})(()))

mengubah tumpukan dari hanya nmenjadi

n + 1
  1
  n

Kemudian, sementara bagian atas tumpukan bukan nol, kami mengurangi dan membalik tanda nomor di bawahnya

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

Kami menghapus nol dan menambahkan dua angka yang tersisa

{}({}{})

Mathematica, 22 19 byte

Disimpan 3 byte berkat Greg Martin!

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

Jawaban sebelumnya, 22 byte

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

Penjelasan (untuk jawaban sebelumnya)

Mathematica memiliki fitur yang bagus sehingga operasi seperti aritmatika secara otomatis memasukkan daftar.

Dalam hal ini, kami mengambil Mod[#,2]yang akan mengembalikan 0 atau 1, tetapi kami perlu menambahkan 1 karena daftar Mathematica diindeks 1. Jika bahkan , ini keluar ke 1, jadi #-1dikembalikan. Jika aneh , ini keluar ke 2, jadi #+1dikembalikan.

Bijaksana , 8 byte

-::^~-^-

Cobalah online!

Penjelasan

Jika ini sebaliknya, (pengurangan jika aneh, kenaikan bahkan jika), akan sangat mudah untuk melakukan ini.

Kami hanya akan membalik bit terakhir.

::^~-^

Cara mengatasinya di sini adalah kita membalik bit terakhir sementara negatif. Angka negatif adalah 1 off dari negasi angka ~sehingga ini menciptakan offset yang menyelesaikan masalah.

Jadi kami hanya mengambil program dan membungkusnya -.

-::^~-^-

Java 8, 16 10 byte

n->-(-n^1)

Java 7, 34 28 byte

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

Membosankan port jawaban C menakjubkan @feersum .
Coba di sini.

Jawaban lama:

Java 8, 16 byte

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

Java 7, 34 byte

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

Penjelasan (dari jawaban Java 7 lama):

Coba di sini.

Jawaban di atas adalah varian yang lebih pendek int c(int n){return n%2<1?n-1:n+1;}dengan menyingkirkan ruang.

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

Japt , 6 byte

n ^1 n

Cobalah online!

Python, 20 byte

lambda n:n+(n&1)*2-1

Di luar 93 , 18 byte

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

Saya belum selesai bermain golf (saya harap).

Ruby, 12 byte

->n{-(-n^1)}

R, 17 byte

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

di mana n=scan()mengambil nilai digit.

Casio-Basic, 27 byte

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

26 byte untuk fungsi, +1 untuk dimasukkan ndalam kotak parameter.

C, 29 byte

a(int b){return b%2?b+1:b-1;}

Jelly , 4 byte

‘’Ḃ?

Cobalah online!

Batch, 20 byte

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

Algoritma @ feersum yang ditemukan kembali secara independen, jujur!