これは、少し前にチャットルームThe Ninteenth Byteに投稿したCMC（チャットミニチャレンジ）です。

チャレンジ

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等しいことに注意してください。次に、Jellyはモジュラーインデックス（）を使用するため、それに対処する必要さえありません。x%4%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.

Python、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

Mathematica 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 Math関数

Haskell、28 27バイト

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

オンラインでお試しください！

編集：1バイトの@ØrjanJohansenに感謝します。

JavaScript、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]

Java 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アプローチを使用できます。

148 146バイト

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

例では、最速の作業速度を装います。Isは、プログラムまたはプログラムパーツであり、fastcall規則を使用します。入力変数xをレジスタに想定しeax、結果もに返しますeax。基本的な考え方は、ここのいくつかの例のように、条件付きジャンプの使用から遠ざかることです。また、すべてを評価するのではなく（配列を使用するCの例のように）、関数へのポインターの配列を使用し、最適化された「C言語switch（）-case ..」アナログとして高速無条件ジャンプ（jmp / call）を作成します。この手法は、プロセッサエミュレータ、エグゼキュータなどのような種類のFinitaオートマトンでも有用です。

代わりに「E」ののx64用の「R」レジスタ名では、（例えば：UPD 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

Oasisは、すべての文字がコマンドであるスタックベースの言語です。

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

オンラインでお試しください。

Groovy、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];、最適化されたバージョンのアドレス演算を使用して、スイッチケース.."。この手法は、プロセッサエミュレーター、エグゼキューター、コマンドストリームパーサーなど、いくつかの種類のFinitaオートマトンでも役立ちswitch(x%4) case(0):... case(1):... ます。複数のcmp / jnz命令を生成するため、速度が重要でコードのようなものは不適切です。これらはCPUにとってコストのかかる操作です

ケースの単純で最短のテストプログラム（デフォルトの状態）は次のとおりです。

D(main,f(x))

ペイロードはわずか12バイト追加され、サイズは合計で127バイトになります。

ただし、リンカーfではなく、関数をエントリポイントとして使用するように指示する必要がありmainます。この方法で、最短のコードからこのタスクの可能な限り高速な作業バイナリを取得することを目指している場合;-)これは、Cライブラリがmain（）関数を呼び出す前に追加の初期化/シャットダウンコードを追加するために発生します。

コードは、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])

他の人が使用するのと同じ方法。短いですが、私はそれがあまり好きではありません。

パイス、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)

ポーランド表記の詳細：ウィキペディア（トルコにいる場合は残念）。

Japt、13バイト

Ov"^+*p"gU +U

オンラインでお試しください！

これは、他のeval回答と同じ方法を使用しますが、プログラムが-U単にnegatesする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つの値を計算し、モジュラーインデックスを使用して1つを選択します。

@[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]最後の2ビットに応じてフォームの文字列を構築して評価することでべき乗を作成したいと思っていましたxが、残念ながら、パラメータ*として使用できないため、操作を選択するコードを表現するには時間がかかりすぎましたforが、少なくともいくつかのフォールスルートリックを使用して、いくつかのバイトをゴルフで飛ばすことができる。

網膜、87バイト

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

オンラインでお試しください！（リンクにはテストスイートが含まれています。）

説明：最初の2行は入力を単項に変換し、それを複製します（したがって、今ではありますx;x）。次の2行は探しx&3いずれかの0か1と変更x;xにx;0またはx;2適切に。次の2行は、（s）を探してx&3==3変更x;xします。これは、、、、またはのいずれかがあり、すべてを一緒に乗算して10進数に戻すことを意味します。（乗算コードはRetina Wikiのコードに基づいていますが、ゼロによる乗算を処理するように修正されています。）x;x;x;...;x;1;xx xx;0x;2x;xx;...;x