이것은 제가 채팅방 인 The Ninteenth Byte에 게시 한 CMC (chat mini challenge)입니다 .

도전

x의 마지막 2 비트에 따라 양의 정수가 주어지면 x다음을 수행하십시오.

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

입출력

Single Integer -> Single Integer  

출력에서 후행 줄 바꿈이 허용됩니다. 다른 공백은 허용되지 않습니다.

테스트 케이스

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

이것은 코드 골프 도전이므로 가장 짧은 코드가 승리합니다!

젤리 , 8 바이트

ị“+×*_”v

온라인으로 사용해보십시오!

작동 원리

첫째, 통지 x&3에 해당 x%4여기서 %모듈입니다. 그런 다음 Jelly는 모듈 식 인덱싱 ( a[n] == a[n+len(a)])을 사용하므로이를 처리 할 필요조차 없습니다.

그때:

• 인 경우 일관성을 위해 (빼기)를 x%4==0반환합니다 x_x.
• 인 경우 x%4==1, x+x;
• 인 경우 x%4==2반환 x×x(곱하기);
• 인 경우 x%4==3반환 x*x(지수)

Jelly는 1- 인덱싱을 사용하므로 빼기 "_"가 끝으로 이동합니다.

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

파이썬 , 30 바이트

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

온라인으로 사용해보십시오!

CJam , 12 바이트

ri__"-+*#"=~

온라인으로 사용해보십시오!

설명

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.

x의 값 mod 4 에 따라 다음 작업 중 하나를 실행합니다 (mod 4는 AND 3과 같습니다).

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

매스 매 티카 25 바이트

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

@MartinEnder 덕분에 4 바이트 절약

Pyth, 8 바이트

.v@"0y*^

통역사

루비 , 26 바이트

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

온라인으로 사용해보십시오!

PHP, 37 바이트

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

온라인 버전

PHP, 47 바이트

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

온라인 버전

BC 수학 함수

하스켈, 28 27 바이트

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

온라인으로 사용해보십시오!

편집 : 1 바이트 동안 @ Ørjan Johansen에게 감사드립니다.

자바 스크립트, 24 바이트

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

온라인으로 사용해보십시오!

C, 63 또는 62 바이트

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

매크로가 허용되면 -1 바이트 x는 다음과 같은 표현식이 아니라고 가정 3+5합니다 (우선 순위를 엉망으로 만들기 때문에).

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

자바 7, 75 바이트

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

규칙에 따라 유효하더라도 long64 비트이므로 지수 테스트 사례 19^19이상 에서는 실패합니다 . 이를 해결하려면 BigDecimal접근 방식을 사용할 수 있습니다 .

148146 바이트

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

설명 (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

테스트 코드 :

여기에서 시도하십시오.

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

산출:

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 어셈블러, Intel 구문, 192 바이트

.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

예는 가장 빠른 작업 속도를 가장합니다. 빠른 호출 규칙을 사용하는 프로그램 또는 프로그램 부분입니다. x레지스터의 입력 변수 를 가정 eax하고 결과도로 반환합니다 eax. 기본 아이디어는 일부 예에서와 같이 조건부 점프를 사용하지 않는 것입니다. 또한 모든 것을 평가하는 것이 아니라 (배열을 가진 C 예제 에서처럼) functon에 대한 포인터 배열을 사용하고 최적화 된 "C language switch ()-case .."아날로그로 무조건 점프 (jmp / call)를 더 빠르게하는 것입니다. 이 기술은 프로세서 에뮬레이터, 실행기 등과 같은 일종의 finita automata에도 유용 할 수 있습니다.

UPD : 64 사용 (예를 들어, 대신에 "E"의 레지스터 이름에 "R"에 대한 rax대신 eax, rcx대신 ecx). 크기는 변경되지 않으며 부호없는 64 비트 단어를 사용합니다.

C #, 39 바이트

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

설명

다음을 확인하십시오.

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

솔루션은 배열을 생성하고 인덱스를 생성 한 다음 결과를 곱합니다 x.

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

대체 버전 :

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

(39B, 배열에서 수행 된 모든 곱셈이을 x%4대체 함 x&3)

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

(39B, @MetaColon의 답변과 동일하지만 x%2*2*x대체 x*x%4<1?0:2)

실제로 12 바이트

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

온라인으로 사용해보십시오!

설명:

;;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 바이트

Ð"-+*m"è.V

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

J , 14 바이트

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

온라인으로 사용해보십시오!

오아시스 , 25 바이트

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

온라인으로 사용해보십시오!

작동 원리

공지 사항 x&3에 해당합니다 x%4경우, %모듈입니다.

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

오아시스는 모든 문자가 명령 인 스택 기반 언어입니다.

Cubix , 29 바이트

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

온라인으로 사용해보십시오!

설명이 곧 추가 될 예정입니다 ...

C #, 42 바이트

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

실제로는 정상적인 C #이지만 전체 프로그램으로 실행할 수 없으므로 대화 형으로 입력해야하므로 전화 할 수 있습니다. C # interactive .

설명 :

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)

나는 그것이 가장 짧은 변형인지 말할 수 없으며, 어떤 제안이라도 높이 평가됩니다.

PHP, 36 바이트

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

dc, 27

전에는 dc에서 배열을 사용할 기회가 없었습니다.

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

온라인으로 사용해보십시오 .

그루비, 26 바이트

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

온라인으로 사용해보십시오!

C, 115 바이트

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

예는 함수입니다 int f(int x)

CPU가 조건부 점프를 사용하지 못하도록하여 가장 빠른 작업 속도를 가장합니다. 그리고 이것은이 작업에 대한 올바른 속도 최적화 방법입니다. 또한 배열 C 예제에서와 같이 모든 것을 평가하려고 시도하지 return(int[]){0,x+x,x*x,pow(x,x)}[x%4];않지만 훨씬 더 빠른 주소 산술을 사용하여 훨씬 더 빠른 무조건 점프 (jmp / call)를 수행하기 위해 함수의 포인터 배열을 " switch ()-case .. ". 이 기법은 프로세서 에뮬레이터, 실행기, 명령 스트림 파서 등과 같은 여러 종류의 피니 타 오토마타에도 유용 할 수 있습니다. 속도 문제와 코드 switch(x%4) case(0):... case(1):... 가 여러 cmp / jnz 명령어를 생성하기 때문에 적합하지 않은 경우; 그리고 이것은 CPU를위한 많은 비용 이 드는 작업입니다

경우에 대한 가장 짧고 가장 짧은 테스트 프로그램 (기본 조건)은 다음과 같습니다.

D(main,f(x))

페이로드는 12 바이트 만 추가하고 크기는 총 127 바이트입니다.

그러나 링커에게 f대신 함수를 시작점으로 사용하도록 지시해야합니다 main. 이것이 우리가 가장 짧은 코드 에서이 작업에 가장 빠른 작업 바이너리를 얻는 것을 목표로하는 방법입니다. ;-) 이것은 C 라이브러리가 main () 함수를 호출하기 전에 여분의 init / shutdown 코드를 추가하기 때문에 발생합니다.

코드는 트릭과 문제없이 MSVS Community 2015에서 컴파일되고 올바른 결과를 생성합니다. gcc로 테스트하지는 않았지만 제대로 작동 할 것이라고 확신합니다.

R, 47 42 바이트

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

기능을 적용합니다 -, +, *, 또는 ^의 계수를 기반 x으로 x하고 x.

-x-x항상 0 이기 때문에 유일하게 똑똑한 것 입니다.

R, 33 바이트

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

다른 사람들이 사용하는 것과 같은 방법입니다. 짧아도 거의 좋아하지 않습니다.

Pyth , 12 바이트

.vjd,+@"-+*^

온라인으로 사용해보십시오!

작동 원리

첫째, 통지 x&3에 해당 x%4여기서 %모듈입니다. Pyth는 모듈 식 인덱싱 ( a[n] == a[n+len(a)])을 사용하므로이를 처리 할 필요조차 없습니다.

그때:

• 인 경우 x%4==0, x-x일관성을 위해 리턴하십시오 .
• 인 경우 x%4==1, x+x;
• 인 경우 x%4==2, x*x;
• 만약 x%4==3반환 x^x.

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

폴란드어 표기법에 대한 추가 정보 : Wikipedia (터키에있는 경우 너무 나쁨).

Japt , 13 바이트

Ov"^+*p"gU +U

온라인으로 사용해보십시오!

이것은 프로그램 -U이 부정 하는 것을 제외하고 다른 평가 답변과 동일한 방법을 U사용하므로 ^대신 (비트 XOR)을 사용합니다.

Vim, 50 바이트

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

여기서, ^V대표 Ctrl+V, ^R대표 Ctrl-R및 ^[나타내는 esc키를

먼저 표현을 쌓아서 bc 평가 합니다. 비어있는 버퍼에서 첫 번째 라인의 입력을 예상합니다.

설명:

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 바이트

@[0yQ*QQ^

테스트 스위트

여기서는 아무 것도 멋진 일이 없습니다. 단지 4 개의 값을 계산하고 모듈 식 인덱싱으로 하나를 선택하십시오.

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

배치, 135 바이트

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

[0+...+0, 2+...+2, x+...+x, x*...*x]마지막 두 비트에 따라 형식의 문자열을 작성하고 평가하여 지수를 만들려고 x했지만 불행히도 작업을 선택하는 코드가 매개 변수 *로 사용할 수 없기 때문에 표현하는 데 너무 오래 걸렸습니다. for최소한 몇 바이트를 쓰러 뜨리기 위해 약간의 추락 속임수를 사용할 수 있습니다.

레티 나 , 87 바이트

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

온라인으로 사용해보십시오! (링크에는 테스트 스위트가 포함됩니다.)

설명 : 처음 두 줄은 입력을 단항으로 변환하고 복제합니다 (이제 x;x). 다음 두 줄 x&3은0 또는 1변경 x;x으로 x;0또는 x;2적절하게. 다음 두 줄을 찾아 x&3==3변화 x;x에 x;x;x;...;x;1;x( x x들). 이 방법은 우리가 가지고 중 x;0, x;2, x;x, 또는 x;...;x그것은 곱셈 모든 것을 함께하고 진수로 변환 뒷면에 남아있다. (곱셈 코드는 Retina 위키의 코드를 기반으로하지만 곱셈을 0으로 처리하도록 수정되었습니다.)