Bu bizim sohbet odamız olan The Ninteenth Byte'da biraz önce yayınladığım bir CMC (chat mini mücadelesi) .

Meydan okuma

Pozitif bir tamsayı verildiğinde x, son 2 bit'ine bağlı olarak x, aşağıdakileri yapın:

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

Giriş çıkış

Single Integer -> Single Integer  

Çıkışta izleyen bir yeni satıra izin verilir. Başka boşluk yok.

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

Bu bir kod golf mücadelesidir, bu yüzden en kısa kod kazanır!

Jöle , 8 bayt

ị“+×*_”v

Çevrimiçi deneyin!

Nasıl çalışır

Birincisi, duyuru x&3eşdeğerdir x%4, nerede %modülo olduğunu. Sonra Jelly, modüler indeksleme ( a[n] == a[n+len(a)]) kullandığından , bununla uğraşmamıza bile gerek kalmaz.

Sonra:

• Varsa x%4==0, geri dönüş x_x(çıkarma) (tutarlılık için);
• Eğer x%4==1döndüyse x+x;
• Eğer x%4==2, geri dönüş x×x(çarpma);
• Eğer öyleyse x%4==3, iade x*x(üs üs)

Jelly'in 1 indeksleme kullandığını, bu yüzden çıkarma "_"işleminin sonuna kadar taşındığını unutmayın.

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

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

Çevrimiçi deneyin!

CJam , 12 bayt

ri__"-+*#"=~

Çevrimiçi deneyin!

açıklama

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.

xMod 4 değerine bağlı olarak aşağıdaki işlemlerden birini gerçekleştirir (mod 4, AND 3'e eşittir).

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

Mathematica 25 Bayt

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

@MartinEnder sayesinde 4 bayt kaydedildi

Pyth, 8 bayt

.v@"0y*^

yorumlayıcı

Ruby , 26 bayt

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

Çevrimiçi deneyin!

PHP, 37 Bayt

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

Çevrimiçi sürüm

PHP, 47 Bayt

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

Çevrimiçi sürüm

BC Math işlevleri

Haskell, 28 27 bayt

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

Çevrimiçi deneyin!

Düzenleme: 1 byte için @ Ørjan Johansen sayesinde.

JavaScript, 24 bayt

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

Çevrimiçi deneyin!

C, 63 veya 62 bayt

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

Makrolara izin verilirse -1 bayt x, bunun gibi bir ifade olmadığını varsayar 3+5(önceliği bozar).

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

Java 7, 75 bayt

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

Kurallara göre geçerli olmasına rağmen long, 64-bit, bu nedenle 19^19yukarıdaki ve üzerindeki üst deneme test durumları için başarısız olur . Bunu düzeltmek için bir BigDecimalyaklaşım kullanabiliriz :

148 146 bayt

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

Açıklama (BigDecimal yaklaşımının):

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

Test kodu:

Burada dene.

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

Çıktı:

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, Intel sözdizimi, 192 bayt

.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

Örnek en hızlı çalışma hızı gibi görünüyor. Fastcall kongre kullanan bir program veya program parçasıdır. xKayıt değişkeninde giriş değişkenini varsayareax ve sonucu da döndürür eax. Temel fikir, burada bazı örneklerde olduğu gibi koşullu atlama kullanmaktan uzak durmaktır. Ayrıca, her şeyi değerlendirmek (dizilerdeki C örneğinde olduğu gibi) değil, functonlar için işaretçiler dizisini kullanmak ve en iyi duruma getirilmiş "C dil anahtarı () - durum .." analogu olarak koşulsuz atlamaları (jmp / call) daha hızlı yapmaktır. Bu teknik aynı zamanda finita otomata benzeri işlemci emülatörleri, uygulayıcılar vb.

Gnc: x64 kullanımı (ör yerine "e" nin kayıt adlarında "r", için raxyerine eax, rcxyerine ecx). Boyut değiştirilmeyecek ve 64-bit işaretsiz sözcükleri kullanacaktır.

C #, 39 bayt

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

açıklama

Bunu gözlemle:

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

Çözüm bir dizi oluşturur, dizine endeksler ve ardından sonucu çarparak x:

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

Alternatif versiyonlar:

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

(39B, dizide yapılan tüm çarpma x%4yerine geçer x&3)

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

(39B, @ MetaColon'un cevabı ile aynı, ancak x%2*2*xdeğiştirme x*x%4<1?0:2)

Aslında , 12 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Ð"-+*m"è.V

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

J , 14 bayt

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

Çevrimiçi deneyin!

Oasis , 25 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

x&3Eşdeğer olduğuna dikkat edin x%4, nerede %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, her karakterin komut olduğu yığın tabanlı bir dildir.

Cubix , 29 bayt

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

Çevrimiçi deneyin!

Açıklama yakında eklenecek ...

C #, 42 Bayt

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

Aslında bu normal bir C #, ama bütün bir program olarak çalıştıramayacağınız ve onu interaktif olarak yazmanız gerektiği için sanırım C # interaktif diyebilirsiniz .

Açıklama :

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)

Bunun en kısa değişken olup olmadığını söyleyemem, önerileriniz takdir edilir.

PHP, 36 bayt

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

dc, 27

Daha önce hiç dc dizilerini kullanma fırsatım olmadı:

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

Çevrimiçi deneyin .

Groovy, 26 bayt

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

Çevrimiçi deneyin!

C, 115 bayt

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

Örnek bir fonksiyondur int f(int x)

İşlemciyi koşullu sıçrama kullanmaktan uzak tuttuğu için en hızlı çalışma hızı gibi görünüyor. Ve bu, bu görev için yalnızca doğru hız optimizasyon yöntemidir. Ayrıca, dizi C örneğinde olduğu gibi her şeyi değerlendirmeye return(int[]){0,x+x,x*x,pow(x,x)}[x%4];çalışmaz, ancak çok daha hızlı adres aritmetiğine sahip daha hızlı koşulsuz atlamalar (jmp / call) yapmak için optimize edilmiş bir sürüm olarak koşulsuz atlamalar (jmp / call) yapmak için functons için işaretçi dizisini akıllıca kullanın. " yer değiştir..". Bu teknik aynı zamanda birkaç finita otomata gibi - işlemci emülatörleri, uygulayıcılar, komut akışı ayrıştırıcıları ve benzerlerinde - hızın önemli olduğu kod gibi yerlerde yararlı olabilir.switch(x%4) case(0):... case(1):... uygun olmadığı, çünkü çoklu cmp / jnz komutları; ve bunlar CPU için pahalı işlemlerdir

Durum için en basit ve en kısa test programı (varsayılan koşullarda) aşağıdaki gibi olacaktır:

D(main,f(x))

Sadece 12 baytlık bir veri yükü ekleyecek ve büyüklüğümüzü 127 bayta çıkaracak;

Ama linker'a kullanması gerektiğini söylemelisin. f yerine fonksiyonu giriş noktası olarak .main . Bu, bu görev için mümkün olan en hızlı şekilde çalışan ikili dosyayı en kısa koddan elde etmeyi amaçlıyorsak ;-) Bu, C kütüphanesinin main () işlevinizi çağırmadan önce fazladan giriş / kapatma kodu eklemesi nedeniyle oluşur.

Kod, hileler ve sorunlar olmadan MSVS Community 2015'te derlenir ve doğru sonuçlar elde edilir. Bunu gcc ile test etmedim, ancak bunun da iyi olacağından eminim.

R, 47 42 bayt

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

Fonksiyon uygular -, +, *, veya ^modülü dayalı xetmek xve x.

-tek (biraz) akıllı şey, çünkü x-xher zaman 0'dır.

R, 33 bayt

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

Diğer insanların kullandığı yöntem. Daha kısa olmasına rağmen, neredeyse kadar sevmiyorum.

Pyth , 12 bayt

.vjd,+@"-+*^

Çevrimiçi deneyin!

Nasıl çalışır

Birincisi, duyuru x&3eşdeğerdir x%4, nerede %modülo olduğunu. Öyleyse, Pyth modüler indeksleme ( a[n] == a[n+len(a)]) kullandığından , bununla uğraşmamız gerekmiyor.

Sonra:

• Eğer x%4==0dönerseniz x-x(tutarlılık için);
• Eğer x%4==1döndüyse x+x;
• Eğer x%4==2döndüyse x*x;
• Eğer x%4==3dönersen x^x.

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

Lehçe notasyonu hakkında daha fazlası: Vikipedi (eğer Türkiye'de iseniz çok kötü).

Japt , 13 bayt

Ov"^+*p"gU +U

Çevrimiçi deneyin!

Bu, diğer değerlendirme cevaplarıyla aynı yöntemi kullanır, program -Usadece olumsuzlar dışında U, bu yüzden biz ^(bitwise XOR) kullanırız.

Vim, 50 bayt

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

Burada, ^Vtemsil eder Ctrl+V, ^Rtemsil ederCtrl-R ve ^[temsil ederesc anahtarı

Önce ifadeyi oluşturarak ve sonra bırakarak çalışır bc değerlendirerek çalışarak çalışır. İlk satırdaki girişi aksi halde boş bir tamponda bekler.

Açıklama:

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 bayt

@[0yQ*QQ^

Test odası

Burada hiçbir şey olmaz, sadece dört değeri hesaplayın ve modüler indeksleme ile bir tane seçin.

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

Toplu, 135 bayt

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

Ben formun bir dize birikmesini ve değerlendirerek üs oluşturmak için umuyordum [0+...+0, 2+...+2, x+...+x, x*...*x]son iki bit bağlı xkullanamıyorum çünkü ifade etmek çok uzun sürdü işlemini seçmek için ama maalesef kod *bir şekilde forparametre, ama ben en azından bazı baytları uzaklaştırmak için düşünse aldatmaca kullanabileceksiniz.

Retina , 87 bayt

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

Çevrimiçi deneyin!(Bağlantı test takımı içerir.)

Açıklama: İlk iki satır girdiyi birliğe çevirir ve çoğaltır (yani şimdi elimizde x;x). Sonraki iki satır bir aramaya x&3ya 0ya da 1değişimin x;xiçine x;0ya da x;2uygun bir şekilde. Sonraki iki satır bakmak x&3==3ve değişim x;xiçine x;x;x;...;x;1;x( x xs). Bu araçlar sahip olduğumuz ya x;0, x;2, x;x, veya x;...;xve çarpın birlikte her şey ve ondalık dönüştürmek arkasına kalır. (Çarpma kodu, Retina wiki'ninkine dayanır, ancak çarpma işlemini sıfırla işlemek için değiştirilir.)