Ini adalah CMC (tantangan mini obrolan) yang saya posting di chatroom kami, The Ninteenth Byte , beberapa waktu lalu.

Tantangan

Diberikan bilangan bulat positif x, tergantung pada 2 bit terakhir x, lakukan hal berikut:

x & 3 == 0: 0
x & 3 == 1: x + x
x & 3 == 2: x * x
x & 3 == 3: x ^ x (exponentiation)

Input output

Single Integer -> Single Integer  

Baris baru tambahan diizinkan dalam output. Tidak ada spasi putih lain yang diizinkan.

Testcases

input       output
    1            2
    2            4
    3           27
    4            0
    5           10
    6           36
    7       823543
    8            0
    9           18
   10          100
   11 285311670611
   12            0

Ini adalah tantangan kode-golf , jadi kode terpendek menang!

Jelly , 8 byte

ị“+×*_”v

Cobalah online!

Bagaimana itu bekerja

Pertama, pemberitahuan yang x&3setara dengan x%4, di mana %modulo. Lalu, karena Jelly menggunakan pengindeksan modular ( a[n] == a[n+len(a)]), jadi kita bahkan tidak perlu menghadapinya.

Kemudian:

• Jika x%4==0, kembali x_x(kurangi) (untuk konsistensi);
• Jika x%4==1, kembali x+x;
• Jika x%4==2, kembali x×x(multiplikasi);
• Jika x%4==3, kembali x*x(eksponensial)

Perhatikan bahwa Jelly menggunakan pengindeksan 1, sehingga pengurangannya "_"dipindahkan ke akhir.

ị“+×*_”v  example input: 10
ị“+×*_”   index 10 of the string “+×*_”, which gives "×"
       v  evaluate the above as a Jelly expression,
          with 10 as the argument, meaning "10×" is the
          expression evaluated. The dyad "×" takes the
          second argument from the only argument, effectively
          performing the function to itself.

Python , 30 byte

lambda x:[0,x+x,x*x,x**x][x%4]

Cobalah online!

CJam , 12 byte

ri__"-+*#"=~

Cobalah online!

Penjelasan

ri            e# Read an int from input (call it x).
  __          e# Duplicate x twice.
    "-+*#"    e# Push this string.
          =   e# Get the character from the string at index x (mod 4).
           ~  e# Eval that char, using the two copies of x from before.

Menjalankan salah satu dari operasi berikut tergantung pada xnilai mod 4 (mod 4 setara dengan DAN 3).

0:  -  Subtraction
1:  +  Addition
2:  *  Multiplication
3:  #  Exponentiation

Mathematica 25 Bytes

0[2#,#*#,#^#][[#~Mod~4]]&

Disimpan 4 Bytes berkat @MartinEnder

Pyth, 8 byte

.v@"0y*^

Penerjemah

Ruby , 26 byte

->x{x*[0,2,x,x**~-x][x%4]}

Cobalah online!

PHP, 37 Bytes

<?=[0,2*$x=$argn,$x*$x,$x**$x][$x&3];

Versi Online

PHP, 47 Bytes

<?=(bc.[sub,add,mul,pow][($x=$argn)&3])($x,$x);

Versi Online

Fungsi BC Matematika

Haskell, 28 27 byte

f x=cycle[0,x+x,x*x,x^x]!!x

Cobalah online!

Sunting: Terima kasih kepada @ Ørjan Johansen selama 1 byte.

JavaScript, 24 byte

a=>[0,a+a,a*a,a**a][a%4]

Cobalah online!

C, 63 atau 62 byte

#include<math.h>
f(x){return(int[]){0,x+x,x*x,pow(x,x)}[x&3];}

-1 byte jika makro dibolehkan, dengan asumsi xbukan ekspresi seperti 3+5(karena itu akan mengacaukan prioritas):

#include<math.h>
#define f(x)(int[]){0,x+x,x*x,pow(x,x)}[x&3]

Java 7, 75 byte

long c(int n){int x=n%4;return x<1?0:x<2?n+n:x<3?n*n:(long)Math.pow(n,n);}

Meskipun valid menurut aturan, longadalah 64-bit, sehingga gagal untuk kasus uji eksponensial ke 19^19atas. Untuk memperbaikinya kita dapat menggunakan BigDecimalpendekatan:

148 146 byte

import java.math.*;BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

Penjelasan (dari pendekatan BigDecimal):

import java.math.*;                // Import required for BigDecimal
BigDecimal c(int n){               // Method with integer parameter and BigDecimal return-type
  int x=n%4;                       //  Input modulo-4
  BigDecimal m=new BigDecimal(n);  //  Convert input integer to BigDecimal
  return x<1?                      //  If the input mod-4 is 0:
    m.subtract(m)                  //   Return input - input (shorter than BigDecimal.ZERO)
   :x<2?                           //  Else if the input mod-4 is 1:
    m.add(m)                       //   Return input + input
   :x<3?                           //  Else if the input mod-4 is 2:
    m.multiply(m)                  //   Return input * input
   :                               //  Else:
    m.pow(n);                      //   Return input ^ input
}                                  // End of method

Kode uji:

Coba di sini.

import java.math.*;
class M{
  static BigDecimal c(int n){int x=n%4;BigDecimal m=new BigDecimal(n);return x<1?m.subtract(m):x<2?m.add(m):x<3?m.multiply(m):m.pow(n);}

  public static void main(String[] a){
    for (int i = 1; i <= 25; i++) {
      System.out.print(c(i) + "; ");
    }
  }
}

Keluaran:

2; 4; 27; 0; 10; 36; 823543; 0; 18; 100; 285311670611; 0; 26; 196; 437893890380859375; 0; 34; 324; 1978419655660313589123979; 0; 42; 484; 20880467999847912034355032910567; 0; 50; 

x86 Assembler, Sintaks Intel, 192 byte

.data
f dw @q,@w,@e,@r
.code
mov ecx, eax
and ecx, 3
mov edx,dword ptr f[ecx*4]
call [edx]
ret
q:
xor eax,eax
ret
w:
add eax,eax
ret
e:
mul eax,eax
ret
r:
mov ecx,eax
t:
mul eax,eax
loop t
ret

Contoh berpura-pura untuk kecepatan kerja tercepat. Apakah adalah bagian program atau program, yang menggunakan konvensi panggilan cepat. Ini mengasumsikan variabel input xdalam register eax, dan mengembalikan hasil juga dalam eax. Ide dasarnya adalah menjauh dari menggunakan lompatan bersyarat, seperti dalam beberapa contoh di sini. Juga, ini bukan untuk mengevaluasi semuanya (seperti pada contoh C dengan array) tetapi untuk menggunakan array pointer ke functons dan membuat lompatan tanpa syarat lebih cepat (jmp / panggilan) sebagai analog "bahasa C switch () - case .." yang dioptimalkan. Teknik ini dapat juga berguna dalam jenis emulator finita automata - seperti prosesor, pelaksana dan sebagainya.

Pembaruan: untuk x64 gunakan "r" dalam nama register, bukan "e" (mis. raxBukannya eax, rcxbukan ecx). Ukuran tidak akan berubah, dan itu akan menggunakan kata-kata tak bertanda 64-bit.

C #, 39 byte

x=>new[]{0,2,x,Math.Pow(x,x-1)}[x&3]*x;

Penjelasan

Perhatikan bahwa:

(xx, x + x, x * x, x ^ x) == (0, 2, x, x ^ (x-1)) * x

Solusi ini menciptakan sebuah array, mengindeks ke dalamnya dan kemudian mengalikan hasilnya dengan x:

x => new[] { 0, 2, x, Math.Pow(x,x-1) }[x&3] * x;

Versi alternatif:

x=>new[]{0,x+x,x*x,Math.Pow(x,x)}[x%4];

(39B, semua perkalian yang dilakukan dalam array, x%4ganti x&3)

x=>x%4<2?x%2*2*x:Math.Pow(x,x%4<3?2:x);

(39B, sama dengan jawaban @ MetaColon tetapi x%2*2*xdiganti x*x%4<1?0:2)

Sebenarnya , 12 byte

;;3&"-+*ⁿ"Eƒ

Cobalah online!

Penjelasan:

;;3&"-+*ⁿ"Eƒ
;;            two copies of input (so 3 total)
  3&          bitwise AND with 3
    "-+*ⁿ"E   index into this string
           ƒ  call the respective function

05AB1E , 10 byte

Ð"-+*m"è.V

Menggunakan penyandian 05AB1E . Cobalah online!

J , 14 byte

4&|{0,+:,*:,^~

Cobalah online!

Oasis , 25 byte

mn4%3Q*nkn4%2Q*nxn4%1Q*++

Cobalah online!

Bagaimana itu bekerja

Perhatikan bahwa x&3itu setara dengan x%4, di mana %modulo.

mn4%3Q*nkn4%2Q*nxn4%1Q*++  input is n
mn4%3Q*                    (n**n)*((n%4)==3)
       nkn4%2Q*            (n**2)*((n%4)==2)
               nxn4%1Q*    (n*2)*((n%4)==1)
                       +   add the above two
                        +  add the above two

Oasis adalah bahasa berbasis tumpukan di mana setiap karakter adalah perintah.

Cubix , 29 byte

.;.O+@.UOI:4%!^s;((?u.^P;<^*;

Cobalah online!

Penjelasan akan ditambahkan segera ...

C #, 42 Bytes

x=>x%4<2?x*x%4<1?0:2:Math.Pow(x,x%4<3?2:x)

Sebenarnya itu adalah C # yang normal, tetapi karena Anda tidak dapat menjalankannya sebagai keseluruhan program dan Anda harus mengetiknya di interaktif, saya kira Anda dapat menyebutnya C # interaktif .

Penjelasan :

x => (x % 4) < 2     //If the bits are smaller than 2 (1 or 0)
? x *           //multiply x with
    (x % 4) < 1 //if the bits are 0
    ? 0         //0 (results in 0)
    : 2         //or else with 2 (results in 2*x or x+x)
: Math.Pow(x,   //otherwise power x by
    (x % 4) < 3 //if the bits are 2
    ? 2         //2 (results in x^2 or x*x)
    : x);       //or else x (results in x^x)

Saya tidak tahu apakah ini varian terpendek, ada saran yang dihargai.

PHP, 36 byte

<?=[0,2,$x=$argn,$x**~-$x][$x&3]*$x;

dc, 27

Saya tidak pernah memiliki kesempatan untuk menggunakan array di dc sebelumnya:

[+]1:r[*]2:r[^]3:r?dd4%;rxp

Cobalah online .

Groovy, 26 byte

{x->[0,x+x,x*x,x**x][x%4]}

Cobalah online!

C, 115 byte

#include<math.h>
#define D(K,L)K(x){return L;}
D(q,0)D(w,x+x)D(e,x*x)D(r,pow(x,x))(*g[])()={q,w,e,r};D(f,g[x%4](x))

Contoh adalah fungsi int f(int x)

Ini berpura-pura untuk kecepatan kerja tercepat karena menjauhkan CPU dari menggunakan lompatan bersyarat. Dan ini hanya cara optimalisasi kecepatan yang benar untuk tugas ini. Juga, ia mencoba untuk tidak mengevaluasi semuanya, seperti pada contoh array C return(int[]){0,x+x,x*x,pow(x,x)}[x%4];Tetapi tetapi dengan bijak menggunakan array pointer ke functons, untuk membuat lompatan tanpa syarat yang jauh lebih cepat (jmp / panggilan) dengan aritmatika alamat yang jauh lebih cepat, sebagai versi yang dioptimalkan dari " switch () - case .. ". Teknik ini bisa juga berguna dalam beberapa jenis finita automata - seperti emulator prosesor, pelaksana, pengurai aliran perintah, dan sebagainya - di mana masalah kecepatan dan kode suka switch(x%4) case(0):... case(1):... tidak cocok karena menghasilkan beberapa instruksi cmp / jnz; dan ini adalah operasi yang mahal untuk CPU

Program uji paling sederhana dan tersingkat (dalam kondisi default) untuk kasus ini adalah sebagai berikut:

D(main,f(x))

Ini akan menambah hanya 12 byte payload dan akan total ukuran kita menjadi 127 byte;

Tetapi Anda sebaiknya memberi tahu linker untuk menggunakan ffungsi sebagai titik masuk, alih-alih main. Itulah caranya, jika kami bertujuan untuk mendapatkan biner yang berfungsi paling cepat untuk tugas ini dari kode terpendek ;-) Ini terjadi karena pustaka C menambahkan kode init / shutdown tambahan sebelum memanggil fungsi utama () Anda.

Kode mengkompilasi pada Komunitas MSVS 2015 tanpa ada trik dan masalah dan menghasilkan hasil yang benar. Saya belum mengujinya dengan gcc, tapi saya yakin itu akan berfungsi dengan baik juga.

R, 47 42 byte

x=scan();c(`-`,`+`,`*`,`^`)[[x%%4+1]](x,x)

Berlaku fungsi -, +, *, atau ^berdasarkan modulus xuntuk xdan x.

-adalah satu-satunya (agak) hal yang cerdas, karena x-xselalu 0.

R, 33 byte

pryr::f(c(0,2*x,x^2,x^x)[x%%4+1])

Metode yang sama seperti yang digunakan orang lain. Meskipun lebih pendek, saya tidak terlalu menyukainya.

Pyth , 12 byte

.vjd,+@"-+*^

Cobalah online!

Bagaimana itu bekerja

Pertama, pemberitahuan yang x&3setara dengan x%4, di mana %modulo. Kemudian, karena Pyth menggunakan pengindeksan modular ( a[n] == a[n+len(a)]), jadi kita bahkan tidak perlu berurusan dengan itu.

Kemudian:

• Jika x%4==0, kembali x-x(untuk konsistensi);
• Jika x%4==1, kembali x+x;
• Jika x%4==2, kembali x*x;
• Jika x%4==3, kembali x^x.

.vjd,+@"-+*^  example input: 10
      @"-+*^  "-+*^"[10], which is "*"
     +        "*10"
    ,         ["*10","10"]
  jd          "*10 10"
.v            evaluate as Pyth expression
              (Pyth uses Polish notation)

Lebih lanjut tentang notasi Polandia: Wikipedia (terlalu buruk jika Anda berada di Turki).

Japt , 13 byte

Ov"^+*p"gU +U

Cobalah online!

Ini menggunakan metode yang sama dengan jawaban eval lainnya, kecuali program -Uhanya meniadakan U, jadi kami menggunakan ^(bitwise XOR) sebagai gantinya.

Vim, 50 byte

y$o^R"A-+*^^V^[0^R"lx0"_Dp^[0D@"kJ0"ad$:r!echo ^R"^R0|bc^<Enter>

Di sini, ^Vmewakili a Ctrl+V, ^Rmewakili Ctrl-Rdan ^[mewakili esckuncinya

Bekerja dengan terlebih dahulu membangun ekspresi dan kemudian membiarkan bcmengevaluasinya. Mengharapkan input pada baris pertama dalam buffer kosong.

Penjelasan:

y$o^R"                                                          Copies the input into register " and pastes it on the second line
      A-+*^^V^[0^R"lx0"_Dp                                      Enters that text after the input on the second line
                          ^[0D@"                                Executes the second line as a Vim command.
                                                                For example, if the input is 12, the second line would be 12A-+*^^[012lx0"_Dp, which means:
                                                                  12A-+*^^[           Insert the text -+*^ 12 times
                                                                           012lx0"_Dp Go 12 chars to the right and remove everything except for that.
                                                                If effect, this basically just selects the appropriate operation.
                                kJ0"ad$                         Put the operator after the number, cut it into register a
                                       :r!                      Execute the following shell command and put the result into the buffer:
                                          echo ^R"^R0|bc<Enter> The shell command "echo [contents of register a][contents of registers 0]|bc. As said above, register a contains the input and the operator, and register 0 contains the input. The <enter> then executes this command.

Pyth, 9 byte

@[0yQ*QQ^

Suite uji

Tidak ada yang terjadi di sini, hanya menghitung empat nilai, dan pilih satu dengan pengindeksan modular.

@[0yQ*QQ^
@[0yQ*QQ^QQ)Q    Implicit variable introduction
@           Q    Modularly index into the following list
 [0        )     0
   yQ            Q*2
     *QQ         Q*Q
        ^QQ      Q^Q

Batch, 135 byte

@set/an=%1*2^&6
@goto %n%
:6
@set n=1
@for /l %%i in (1,1,%1)do @set/an*=%1
@goto 0
:4
@set n=%1
:2
@set/an*=%1
:0
@echo %n%

Saya berharap untuk membuat eksponensial dengan membangun dan mengevaluasi string bentuk [0+...+0, 2+...+2, x+...+x, x*...*x]tergantung pada dua bit terakhir xtapi sayangnya kode untuk memilih operasi terlalu lama untuk diekspresikan karena saya tidak dapat menggunakan *sebagai forparameter, tapi saya setidaknya dapat menggunakan beberapa tipuan jatuh-jatuh untuk bermain golf beberapa byte.

Retina , 87 byte

.+
$*1;$&$*
;((1111)*)(1?)$
;$3$3
1(?=1.*;((1111)*111)$)
$1;
+`\G1(?=.*;(1*))|;1*$
$1
1

Cobalah online! (Tautan termasuk test suite.)

Penjelasan: Dua baris pertama mengubah input menjadi unary dan menduplikatnya (jadi sekarang kita miliki x;x). Dua baris berikutnya mencari x&3dari salah satu 0atau 1dan berubah x;xmenjadi x;0atau x;2tepat. Dua baris berikutnya mencari x&3==3dan perubahan x;xke x;x;x;...;x;1;x( x xs). Ini berarti bahwa kita harus baik x;0, x;2, x;x, atau x;...;xdan masih kalikan semuanya bersama-sama dan mengkonversi kembali ke desimal. (Kode multiplikasi didasarkan pada yang ada di Retina wiki tetapi diubah untuk menangani perkalian dengan nol.)