To jest CMC (mini-wyzwanie na czacie), które opublikowałem nieco wcześniej w naszym czacie, The Ninteenth Byte .

Wyzwanie

Biorąc pod uwagę dodatnią liczbę całkowitą x, w zależności od 2 ostatnich bitów x, wykonaj następujące czynności:

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

Wejście wyjście

Single Integer -> Single Integer  

Końcowy znak nowej linii jest dozwolony w danych wyjściowych. Żadne inne białe znaki nie są dozwolone.

Przypadki testowe

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

To wyzwanie dla golfa , więc wygrywa najkrótszy kod!

Galaretka , 8 bajtów

ị“+×*_”v

Wypróbuj online!

Jak to działa

Po pierwsze, zauważ, że x&3jest to równoważne z x%4, gdzie %jest modulo. Następnie, ponieważ Jelly używa modułowego indeksowania ( a[n] == a[n+len(a)]), więc nawet nie musimy sobie z tym poradzić.

Następnie:

• Jeśli x%4==0, zwróć x_x(odejmij) (dla spójności);
• Jeśli x%4==1wróć x+x;
• Jeśli x%4==2, zwróć x×x(mnożenie);
• Jeśli x%4==3, zwróć x*x(potęgowanie)

Zauważ, że Jelly używa indeksowania 1, więc odejmowanie "_"jest przenoszone na koniec.

ị“+×*_”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 bajtów

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

Wypróbuj online!

CJam , 12 bajtów

ri__"-+*#"=~

Wypróbuj online!

Wyjaśnienie

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.

Wykonuje jedną z następujących operacji w zależności od xwartości mod 4 (mod 4 jest równoważny AND 3).

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

Mathematica 25 bajtów

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

Zapisano 4 bajty dzięki @MartinEnder

Pyth, 8 bajtów

.v@"0y*^

Interpretator

Rubinowy , 26 bajtów

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

Wypróbuj online!

PHP, 37 bajtów

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

Wersja online

PHP, 47 bajtów

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

Wersja online

Funkcje BC Math

Haskell, 28 27 bajtów

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

Wypróbuj online!

Edycja: Dzięki @ Ørjan Johansen za 1 bajt.

JavaScript, 24 bajty

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

Wypróbuj online!

C, 63 lub 62 bajty

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

-1 bajt, jeśli makra są dozwolone, zakładając, że xnie jest wyrażeniem podobnym 3+5(ponieważ to zepsułoby pierwszeństwo):

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

Java 7, 75 bajtów

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

Mimo że jest prawidłowy zgodnie z regułami, longma 64 bity, więc nie powiedzie się w przypadku testów potęgowania 19^19wyższych i wyższych. Aby to naprawić, możemy zastosować BigDecimalpodejście:

148 146 bajtów

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

Objaśnienie (podejścia 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

Kod testowy:

Wypróbuj tutaj.

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

Wydajność:

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; 

Asembler x86, składnia Intel, 192 bajty

.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

Przykład udaje najszybszą prędkość roboczą. Jest to program lub część programu, która wykorzystuje konwencję szybkiego połączenia. Zakłada zmienną wejściową xw rejestrze eaxi zwraca wynik również w eax. Podstawową ideą jest unikanie skoku warunkowego, jak w niektórych przykładach tutaj. Nie chodzi również o ocenę wszystkiego (jak w przykładzie C z tablicami), ale o użycie tablicy wskaźników do funkcji i szybszych bezwarunkowych skoków (jmp / call) jako zoptymalizowany analog „C language switch () - case ..”). Ta technika może być również przydatna w rodzajach automatów finita - takich jak emulatory procesorów, executory i tak dalej.

Aktualizacja: dla x64 użyj „r” w nazwach rejestrów zamiast „e” (np. raxZamiast eax, rcxzamiast ecx). Rozmiar nie zostanie zmieniony i użyje 64-bitowych słów bez znaku.

C #, 39 bajtów

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

Wyjaśnienie

Obseruj to:

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

Rozwiązanie tworzy tablicę, indeksuje do niej, a następnie mnoży wynik przez x:

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

Alternatywne wersje:

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

(39B, wszystkie mnożenie wykonane w tablicy, x%4zastępuje x&3)

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

(39B, to samo co odpowiedź @ MetaColon, ale x%2*2*xzastępuje x*x%4<1?0:2)

Właściwie 12 bajtów

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

Wypróbuj online!

Wyjaśnienie:

;;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 bajtów

Ð"-+*m"è.V

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

J , 14 bajtów

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

Wypróbuj online!

Oaza , 25 bajtów

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

Wypróbuj online!

Jak to działa

Zauważ, że x&3jest to równoważne z x%4, gdzie %jest 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

Oaza to język oparty na stosie, w którym każda postać jest poleceniem.

Cubix , 29 bajtów

.;[email protected]:4%!^s;((?u.^P;<^*;

Wypróbuj online!

Wyjaśnienie zostanie dodane wkrótce ...

C #, 42 bajtów

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

W rzeczywistości jest to normalny C #, ale ponieważ nie możesz uruchomić go jako całego programu i musisz wpisać go w interaktywny, myślę, że możesz nazwać go C # interaktywnym .

Objaśnienie :

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)

Nie mogę powiedzieć, czy to najkrótszy wariant, wszelkie sugestie są mile widziane.

PHP, 36 bajtów

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

dc, 27

Nigdy wcześniej nie miałem okazji używać tablic w DC:

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

Wypróbuj online .

Groovy, 26 bajtów

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

Wypróbuj online!

C, 115 bajtów

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

Przykład jest funkcją int f(int x)

Udaje najszybszą prędkość roboczą, ponieważ powstrzymuje procesor przed używaniem skoków warunkowych. Jest to tylko poprawny sposób optymalizacji prędkości dla tego zadania. Ponadto stara się nie oceniać wszystkiego, jak w przykładzie z tablicy C, return(int[]){0,x+x,x*x,pow(x,x)}[x%4];ale mądrze wykorzystuje tablicę wskaźników do funkcji, aby wykonać znacznie szybsze bezwarunkowe skoki (jmp / call) z dużo szybszą arytmetyką adresu, jako zoptymalizowaną wersję „ Sprawa przełącznik..". Ta technika może być również przydatna w kilku rodzajach automatów finita - takich jak emulatory procesorów, moduły wykonawcze, parsery strumienia poleceń i tak dalej - w których prędkość ma znaczenie, a kod podobny switch(x%4) case(0):... case(1):... jest nieodpowiedni, ponieważ wytwarza wiele instrukcji cmp / jnz; i są to kosztowne operacje na procesorze

Najprostszym i najkrótszym programem testowym (w warunkach domyślnych) dla przypadku będzie:

D(main,f(x))

Doda to tylko 12 bajtów ładunku i sumuje nasz rozmiar do 127 bajtów;

Ale powinieneś lepiej powiedzieć linkerowi, aby fzamiast funkcji używał funkcji jako punktu wejścia main. W ten sposób staramy się uzyskać najszybszy możliwy działający plik binarny dla tego zadania z najkrótszego kodu ;-) Dzieje się tak, ponieważ biblioteka C dodaje dodatkowy kod inicjujący / zamykający przed wywołaniem funkcji main ().

Kod kompiluje się w MSVS Community 2015 bez żadnych sztuczek i problemów i daje prawidłowe wyniki. Nie testowałem tego z gcc, ale jestem pewien, że również będzie działał dobrze.

R, 47 42 bajtów

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

Stosuje funkcję -, +, *, lub ^w oparciu o moduł xdo xa x.

-jest jedyną (nieco) mądrą rzeczą, ponieważ x-xzawsze wynosi 0.

R, 33 bajty

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

Ta sama metoda, której używają inni ludzie. Chociaż jest krótszy, nie lubię go tak bardzo.

Pyth , 12 bajtów

.vjd,+@"-+*^

Wypróbuj online!

Jak to działa

Po pierwsze, zauważ, że x&3jest to równoważne z x%4, gdzie %jest modulo. Następnie, ponieważ Pyth używa modułowego indeksowania ( a[n] == a[n+len(a)]), więc nawet nie musimy sobie z tym poradzić.

Następnie:

• Jeśli x%4==0, zwróć x-x(w celu zachowania spójności);
• Jeśli x%4==1wróć x+x;
• Jeśli x%4==2wróć x*x;
• Jeśli x%4==3wrócisz x^x.

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

Więcej o polskiej notacji: Wikipedia (szkoda, jeśli jesteś w Turcji).

Japt , 13 bajtów

Ov"^+*p"gU +U

Wypróbuj online!

Używa tej samej metody, co inne odpowiedzi eval, z wyjątkiem tego, że program -Utylko neguje U, więc ^zamiast tego używamy (bitowego XOR).

Vim, 50 bajtów

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

Tutaj ^Vreprezentuje a Ctrl+V, ^Rreprezentuje Ctrl-Ri ^[reprezentuje escklucz

Działa, najpierw budując wyrażenie, a następnie pozwalając bcje ocenić. Oczekuje danych wejściowych w pierwszym wierszu w innym pustym buforze.

Wyjaśnienie:

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 bajtów

@[0yQ*QQ^

Zestaw testowy

Nie ma w tym nic dziwnego, wystarczy obliczyć cztery wartości i wybrać jedną z modułowym indeksowaniem.

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

Partia, 135 bajtów

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

Miałem nadzieję utworzyć potęgowanie, budując i oceniając ciąg formularza w [0+...+0, 2+...+2, x+...+x, x*...*x]zależności od dwóch ostatnich bitów, xale niestety kod do wybrania operacji zabrał zbyt dużo czasu na wyrażenie, ponieważ nie mogłem użyć *jako forparametru, ale byłem przynajmniej w stanie wykorzystać sztuczkę polegającą na upadku, aby odegrać trochę bajtów.

Siatkówka , 87 bajtów

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

Wypróbuj online! (Link zawiera pakiet testowy.)

Objaśnienie: Pierwsze dwa wiersze konwertują dane wejściowe na jednoargumentowe i powielają je (teraz mamy x;x). Następne dwie linie szukają x&3albo 0albo 1i zmieniają się x;xna x;0lub x;2odpowiednio. Następne dwie linie szukają x&3==3i zmieniają się x;xw x;x;x;...;x;1;x( x xs). Oznacza to, że musimy albo x;0, x;2, x;x, lub x;...;xi pozostaje pomnożyć wszystko razem i przeprowadzić z powrotem w systemie dziesiętnym. (Kod mnożenia jest oparty na kodzie na wiki Retina, ale został zmieniony tak, aby obsługiwał mnożenie przez zero).