Đây là một CMC (thử thách trò chuyện nhỏ) mà tôi đã đăng trong phòng chat của chúng tôi, The Ninteenth Byte , một chút trước đây.

Các thách thức

Cho một số nguyên dương x, tùy thuộc vào 2 bit cuối cùng x, hãy làm như sau:

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

Đầu ra đầu vào

Single Integer -> Single Integer  

Một dòng mới được cho phép trong đầu ra. Không có khoảng trắng khác được cho phép.

Tủ thử

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

Đây là một thử thách chơi gôn , vì vậy mã ngắn nhất sẽ thắng!

Thạch , 8 byte

ị“+×*_”v

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Đầu tiên, lưu ý rằng x&3tương đương với x%4, %modulo ở đâu . Sau đó, vì Jelly sử dụng lập chỉ mục mô-đun ( a[n] == a[n+len(a)]), nên chúng tôi thậm chí không cần phải xử lý vấn đề đó.

Sau đó:

• Nếu x%4==0, trả về x_x(trừ) (cho thống nhất);
• Nếu x%4==1, trở về x+x;
• Nếu x%4==2, trả về x×x(nhân);
• Nếu x%4==3, trả lại x*x(lũy thừa)

Lưu ý rằng Jelly sử dụng lập chỉ mục 1, vì vậy phép trừ "_"được chuyển đến cuối.

ị“+×*_”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]

Hãy thử trực tuyến!

CJam , 12 byte

ri__"-+*#"=~

Hãy thử trực tuyến!

Giải trình

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.

Chạy một trong các hoạt động sau tùy thuộc vào xgiá trị của mod 4 (mod 4 tương đương với AND 3).

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

Toán học 25 byte

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

Đã lưu 4 byte nhờ @MartinEnder

Bình thường, 8 byte

.v@"0y*^

Thông dịch viên

Ruby , 26 byte

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

Hãy thử trực tuyến!

PHP, 37 byte

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

Phiên bản trực tuyến

PHP, 47 byte

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

Phiên bản trực tuyến

Hàm BC Toán

Haskell, 28 27 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: Cảm ơn @ rjan Johansen cho 1 byte.

JavaScript, 24 byte

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

Hãy thử trực tuyến!

C, 63 hoặc 62 byte

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

-1 byte nếu macro được cho phép, giả sử xkhông phải là một biểu thức như 3+5(vì điều đó sẽ làm xáo trộn quyền ưu tiên):

#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);}

Mặc dù nó hợp lệ theo các quy tắc, longlà 64 bit, do đó, nó không thành công cho các trường hợp kiểm tra lũy thừa của 19^19và trên. Để khắc phục rằng chúng ta có thể sử dụng một BigDecimalcách tiếp cận:

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

Giải thích (về cách tiếp cận 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

Mã kiểm tra:

Hãy thử nó ở đây.

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) + "; ");
    }
  }
}

Đầu ra:

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; 

Trình biên dịch x86, cú pháp 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

Ví dụ giả vờ cho tốc độ làm việc nhanh nhất. Là một chương trình hoặc một phần chương trình, trong đó sử dụng quy ước fastcall. Nó giả sử biến đầu vào xtrong thanh ghi eax, và trả về kết quả cũng trong eax. Ý tưởng cơ bản là tránh xa việc sử dụng các bước nhảy có điều kiện, như trong một số ví dụ ở đây. Ngoài ra, nó không phải là để đánh giá tất cả mọi thứ (như trong ví dụ C với mảng) mà là sử dụng mảng các con trỏ tới functon và thực hiện các bước nhảy vô điều kiện (jmp / cuộc gọi) nhanh hơn như một công cụ tương tự "chuyển đổi ngôn ngữ C () - trường hợp ..". Kỹ thuật này cũng có thể hữu ích trong các loại máy tự động finita - như trình giả lập bộ xử lý, người thực thi, v.v.

Trình cập nhật: cho x64 sử dụng "r" trong tên đăng ký, thay vì "e" (ví dụ raxthay vì eax, rcxthay vì ecx). Kích thước sẽ không được thay đổi và nó sẽ sử dụng các từ không dấu 64 bit.

C #, 39 byte

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

Giải trình

Quan sát rằng:

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

Giải pháp tạo ra một mảng, lập chỉ mục vào đó và sau đó nhân kết quả bằng cách x:

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

Phiên bản thay thế:

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

(39B, tất cả các phép nhân được thực hiện trong mảng, x%4thay thế x&3)

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

(39B, giống như câu trả lời của @ MetaColon nhưng x%2*2*xthay thế x*x%4<1?0:2)

Trên thực tế , 12 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

J , 14 byte

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

Hãy thử trực tuyến!

Ốc đảo , 25 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Lưu ý rằng x&3tương đương với x%4, %modulo ở đâu .

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 là một ngôn ngữ dựa trên ngăn xếp trong đó mỗi nhân vật là một lệnh.

Khối , 29 byte

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

Hãy thử trực tuyến!

Giải thích sẽ được bổ sung sớm ...

C #, 42 byte

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

Trên thực tế, đó là C # bình thường, nhưng vì bạn không thể chạy toàn bộ chương trình và bạn phải nhập nó vào tương tác, tôi đoán bạn có thể gọi nó là tương tác C # .

Giải thích :

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)

Tôi không thể nói rằng đó là biến thể ngắn nhất, mọi đề xuất đều được đánh giá cao.

PHP, 36 byte

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

đc, 27

Tôi chưa bao giờ có cơ hội sử dụng mảng trong dc trước đây:

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

Hãy thử trực tuyến .

Groovy, 26 byte

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

Hãy thử trực tuyến!

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

Ví dụ là một hàm int f(int x)

Nó giả vờ cho tốc độ làm việc nhanh nhất vì nó giữ CPU tránh sử dụng các bước nhảy có điều kiện. Và đây chỉ là cách tối ưu hóa tốc độ chính xác cho nhiệm vụ này. Ngoài ra, nó cố gắng không đánh giá tất cả mọi thứ, như trong ví dụ về mảng C return(int[]){0,x+x,x*x,pow(x,x)}[x%4];, nhưng sử dụng một cách khôn ngoan mảng con trỏ tới functon, để thực hiện các bước nhảy vô điều kiện (jmp / cuộc gọi) nhanh hơn với các phiên bản địa chỉ nhanh hơn nhiều, như là một phiên bản tối ưu hóa của " chuyển () - trường hợp .. ". Kỹ thuật này cũng có thể hữu ích trong một số loại finita automata - như trình giả lập bộ xử lý, bộ thực thi, trình phân tích cú pháp dòng lệnh, v.v. - trong đó vấn đề tốc độ và mã như switch(x%4) case(0):... case(1):... không phù hợp vì nó tạo ra nhiều lệnh cmp / jnz; và đây là những hoạt động tốn kém cho CPU

Chương trình thử nghiệm đơn giản nhất và ngắn nhất (trong điều kiện mặc định) cho trường hợp sẽ như sau:

D(main,f(x))

Nó sẽ chỉ thêm 12 byte tải trọng và sẽ tổng kích thước của chúng tôi lên 127 byte;

Nhưng tốt hơn bạn nên nói với trình liên kết sử dụng fchức năng như một điểm vào, thay vì main. Đó là cách, nếu chúng ta nhắm đến việc có được nhị phân hoạt động nhanh nhất có thể cho tác vụ này từ mã ngắn nhất ;-) Điều này xảy ra do thư viện C thêm mã init / shutdown trước khi gọi hàm main () của bạn.

Mã biên dịch trên MSVS Community 2015 mà không có bất kỳ thủ thuật và vấn đề nào và tạo ra kết quả chính xác. Tôi chưa thử nó với gcc, nhưng tôi chắc chắn nó cũng sẽ hoạt động tốt.

R, 47 42 byte

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

Áp dụng các chức năng -, +, *, hoặc ^dựa trên các mô đun của xđể xvà x.

-là điều thông minh duy nhất (phần nào), vì x-xluôn luôn là 0.

R, 33 byte

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

Phương pháp tương tự như những người khác sử dụng. Mặc dù nó ngắn hơn nhưng tôi không thích nó nhiều như vậy.

Bình thường , 12 byte

.vjd,+@"-+*^

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Đầu tiên, lưu ý rằng x&3tương đương với x%4, %modulo ở đâu . Sau đó, vì Pyth sử dụng lập chỉ mục mô-đun ( a[n] == a[n+len(a)]), nên chúng tôi thậm chí không cần phải xử lý vấn đề đó.

Sau đó:

• Nếu x%4==0, trả lại x-x(cho thống nhất);
• Nếu x%4==1, trở về x+x;
• Nếu x%4==2, trở về x*x;
• Nếu x%4==3, trở về x^x.

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

Thông tin thêm về ký hiệu Ba Lan: Wikipedia (quá tệ nếu bạn ở Thổ Nhĩ Kỳ).

Japt , 13 byte

Ov"^+*p"gU +U

Hãy thử trực tuyến!

Điều này sử dụng phương pháp tương tự như các câu trả lời eval khác, ngoại trừ chương trình -Uchỉ phủ định U, vì vậy chúng tôi sử dụng ^(bitwise XOR) thay thế.

Vim, 50 byte

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

Ở đây, ^Vđại diện cho a Ctrl+V, ^Rđại diện Ctrl-Rvà ^[đại diện cho escchìa khóa

Hoạt động bằng cách đầu tiên xây dựng biểu thức và sau đó cho phép bcđánh giá nó. Yêu cầu đầu vào trên dòng đầu tiên trong một bộ đệm trống.

Giải trình:

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.

Bình thường, 9 byte

@[0yQ*QQ^

Bộ kiểm tra

Không có gì lạ mắt xảy ra ở đây, chỉ cần tính toán bốn giá trị và chọn một giá trị với lập chỉ mục mô-đun.

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

Mẻ, 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%

Tôi đã hy vọng tạo ra lũy thừa bằng cách xây dựng và đánh giá một chuỗi biểu mẫu [0+...+0, 2+...+2, x+...+x, x*...*x]tùy thuộc vào hai bit cuối cùng xnhưng không may là mã để chọn thao tác mất quá nhiều thời gian để thể hiện vì tôi không thể sử dụng *làm fortham số, nhưng tôi đã ít nhất có thể sử dụng một số mánh khóe mặc dù để đánh bại một số byte.

Võng mạc , 87 byte

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

Hãy thử trực tuyến!(Liên kết bao gồm bộ kiểm tra.)

Giải thích: Hai dòng đầu tiên chuyển đổi đầu vào thành unary và sao chép nó (vì vậy bây giờ chúng ta có x;x). Hai dòng tiếp theo tìm kiếm một x&3trong hai 0hoặc 1và thay đổi x;xthành x;0hoặc x;2thích hợp. Hai dòng tiếp theo tìm kiếm x&3==3và thay đổi x;xthành x;x;x;...;x;1;x( x xs). Điều này có nghĩa rằng chúng ta có một trong hai x;0, x;2, x;x, hay x;...;xvà nó vẫn còn để mọi nhân với nhau và chuyển đổi trở lại thập phân. (Mã nhân được dựa trên mã trong Retina wiki nhưng được sửa đổi để xử lý phép nhân bằng không.)