Dies ist eine CMC (Chat Mini Challenge), die ich vor einiger Zeit in unserem Chatraum The Ninteenth Byte gepostet habe.

Die Herausforderung

Gehen Sie bei einer positiven Ganzzahl xin Abhängigkeit von den letzten 2 Bits von xwie folgt vor:

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

Input-Output

Single Integer -> Single Integer  

In der Ausgabe ist ein abschließender Zeilenumbruch zulässig. Kein anderes Leerzeichen ist zulässig.

Testfälle

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

Dies ist eine Code-Golf- Herausforderung, also gewinnt der kürzeste Code!

Gelee , 8 Bytes

ị“+×*_”v

Probieren Sie es online!

Wie es funktioniert

Beachten Sie zunächst, dass x&3entspricht x%4, wo %Modulo ist. Da Jelly dann modular indexing ( a[n] == a[n+len(a)]) verwendet, müssen wir uns damit nicht einmal befassen.

Dann:

• If x%4==0, return x_x(Subtraktion) (aus Konsistenzgründen);
• Wenn x%4==1, kehre zurück x+x;
• If x%4==2, return x×x(Multiplikation);
• If x%4==3, return x*x(Potenzierung)

Beachten Sie, dass Jelly die 1-Indexierung verwendet, sodass die Subtraktion "_"an das Ende verschoben wird.

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

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

Probieren Sie es online!

CJam , 12 Bytes

ri__"-+*#"=~

Probieren Sie es online!

Erläuterung

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.

Führt je nach xdem Wert von mod 4 eine der folgenden Operationen aus (mod 4 entspricht AND 3).

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

Mathematica 25 Bytes

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

4 Bytes gespart dank @MartinEnder

Pyth, 8 Bytes

.v@"0y*^

Dolmetscher

Ruby , 26 Bytes

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

Probieren Sie es online!

PHP, 37 Bytes

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

Online Version

PHP, 47 Bytes

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

Online Version

BC Math Funktionen

Haskell, 28 27 Bytes

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

Probieren Sie es online!

Edit: Danke an @ Ørjan Johansen für 1 Byte.

JavaScript, 24 Byte

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

Probieren Sie es online!

C, 63 oder 62 Bytes

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

-1 Byte, wenn Makros erlaubt sind, vorausgesetzt, es xhandelt sich nicht um einen Ausdruck wie 3+5(da dies den Vorrang verfälschen würde):

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

Java 7, 75 Bytes

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

Obwohl es nach den Regeln gültig longist, 64-Bit ist, schlägt es für die Exponentiationstestfälle von 19^19und darüber fehl . Um das zu beheben, können wir einen BigDecimalAnsatz verwenden:

148 146 Bytes

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

Erklärung (des BigDecimal-Ansatzes):

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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-Syntax, 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

Beispiel gibt vor, die schnellste Arbeitsgeschwindigkeit zu haben. Is ist ein Programm oder Programmteil, das die Fastcall-Konvention verwendet. Es nimmt die Eingangsvariable xin register eaxan und gibt das Ergebnis auch in zurückeax . Die Grundidee ist, keine bedingten Sprünge zu verwenden, wie in einigen Beispielen hier. Es ist auch nicht alles auszuwerten (wie in C-Beispiel mit Arrays), sondern ein Array von Zeigern zu Funktionen zu verwenden und schnellere bedingungslose Sprünge (jmp / call) als optimiertes "C language switch () - case .." - Analog. Diese Technik kann auch in Finita-Automaten wie Prozessoremulatoren, Executoren usw. nützlich sein.

Upd: Verwenden Sie für x64 "r" in Registernamen anstelle von "e" (z. B. raxanstelle von eax, rcxanstelle von ecx). Die Größe wird nicht geändert und es werden 64-Bit-Wörter ohne Vorzeichen verwendet.

C #, 39 Bytes

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

Erläuterung

Beachten Sie, dass:

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

Die Lösung erstellt ein Array, indiziert es und multipliziert das Ergebnis mit x:

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

Alternative Versionen:

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

(39B, alle im Array durchgeführten Multiplikationen x%4ersetzen x&3)

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

(39B, wie bei @ MetaColon, jedoch x%2*2*xersetzt x*x%4<1?0:2)

Eigentlich 12 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Ð"-+*m"è.V

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

J , 14 Bytes

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

Probieren Sie es online!

Oase , 25 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Beachten Sie, dass x&3entspricht x%4, wo %Modulo ist.

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 ist eine stapelbasierte Sprache, in der jedes Zeichen ein Befehl ist.

Cubix , 29 Bytes

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

Probieren Sie es online!

Erklärung wird in Kürze hinzugefügt ...

C #, 42 Bytes

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

Eigentlich ist es normales C #, aber da Sie es nicht als ganzes Programm ausführen können und es in das interaktive Programm eingeben müssen, können Sie es auch als interaktives C # bezeichnen .

Erklärung :

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)

Ich kann nicht sagen, ob es sich um die kürzeste Variante handelt. Vorschläge sind willkommen.

PHP, 36 Bytes

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

dc, 27

Ich hatte noch nie die Gelegenheit, Arrays in dc zu verwenden:

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

Probieren Sie es online aus .

Groovy, 26 Bytes

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

Probieren Sie es online!

C 115 Bytes

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

Beispiel ist eine Funktion int f(int x)

Es gibt vor, die schnellste Arbeitsgeschwindigkeit zu haben, da es die CPU davon abhält, bedingte Sprünge auszuführen. Und das ist nur der richtige Weg zur Geschwindigkeitsoptimierung für diese Aufgabe. Es wird auch versucht, nicht alles auszuwerten, wie im Beispiel von Array C, return(int[]){0,x+x,x*x,pow(x,x)}[x%4];sondern Array von Zeigern zu Funktonen sinnvoll zu verwenden, um mit viel schnellerer Adressarithmetik bedingungslose Sprünge (jmp / call) durchzuführen, als eine optimierte Version von " Schaltergehäuse..". Diese Technik kann auch in verschiedenen Arten von Finita-Automaten nützlich sein, z. B. in Prozessoremulatoren, Executoren, Befehlsstrom-Parsern usw., bei denen Geschwindigkeit und Code switch(x%4) case(0):... case(1):... ungeeignet sind, da sie mehrere cmp / jnz-Anweisungen erzeugen. und dies sind kostspielige Operationen für die CPU

Das einfachste und kürzeste Testprogramm (unter Standardbedingungen) für diesen Fall lautet wie folgt:

D(main,f(x))

Es werden nur 12 Bytes Nutzlast hinzugefügt, und unsere Gesamtgröße beträgt 127 Bytes.

Sie sollten den Linker jedoch anweisen, die fFunktion statt als Einstiegspunkt zu verwendenmain . Das ist die Art und Weise, wenn wir versuchen, aus dem kürzesten Code die schnellstmögliche Binärfunktion für diese Aufgabe zu erhalten ;-) Dies geschieht, weil die C-Bibliothek vor dem Aufrufen Ihrer main () -Funktion zusätzlichen Init / Shutdown-Code hinzufügt.

Code wird auf MSVS Community 2015 ohne Tricks und Probleme kompiliert und liefert korrekte Ergebnisse. Ich habe es nicht mit gcc getestet, aber ich bin sicher, es wird auch gut funktionieren.

R, 47 42 Bytes

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

Wendet die Funktion -, +,* , oder ^auf der Basis des E - Modul xauf xund x.

-ist die einzige (etwas) kluge Sache, da x-ximmer 0 ist.

R, 33 Bytes

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

Gleiche Methode wie andere Leute. Obwohl es kürzer ist, mag ich es bei weitem nicht so sehr.

Pyth , 12 Bytes

.vjd,+@"-+*^

Probieren Sie es online!

Wie es funktioniert

Beachten Sie zunächst, dass x&3entspricht x%4, wo %Modulo ist. Da Pyth dann modular indexing ( a[n] == a[n+len(a)]) verwendet, müssen wir uns damit nicht einmal befassen.

Dann:

• If x%4==0, return x-x(aus Konsistenzgründen);
• Wenn x%4==1, kehre zurück x+x;
• Wenn x%4==2, kehre zurück x*x;
• Wenn ja x%4==3, kehre zurück x^x.

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

Weitere Informationen zur polnischen Notation: Wikipedia (schade, wenn Sie in der Türkei sind).

Japt , 13 Bytes

Ov"^+*p"gU +U

Probieren Sie es online!

Dies verwendet die gleiche Methode wie die anderen Auswertungsantworten, außer dass das Programm -Unur negiert U, sodass wir ^stattdessen (bitweises XOR) verwenden.

Vim, 50 Bytes

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

Hier ^Vrepräsentiert a Ctrl+V, ^Rrepräsentiert Ctrl-Rund ^[repräsentiert dasesc Schlüssel

Arbeiten, indem Sie zuerst den Ausdruck aufbauen und dann lassen bc ihn auswerten. Erwartet die Eingabe in der ersten Zeile in einem ansonsten leeren Puffer.

Erläuterung:

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 Bytes

@[0yQ*QQ^

Testsuite

Hier ist nichts Besonderes los, berechnen Sie einfach die vier Werte und wählen Sie einen mit modularer Indizierung aus.

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

Batch, 135 Bytes

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

Ich hatte gehofft, die Potenzierung durch Aufbauen und Auswerten eines Strings der Form in [0+...+0, 2+...+2, x+...+x, x*...*x]Abhängigkeit von den letzten beiden Bits zu xerzeugen, aber leider dauerte es zu lange, den Code zum Auswählen der Operation auszudrücken, da ich ihn nicht *als forParameter verwenden konnte, was ich aber tat Zumindest in der Lage, einige Fall-obwohl-Tricks zu verwenden, um einige Bytes wegzuspielen.

Retina , 87 Bytes

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

Probieren Sie es online! (Link enthält Testsuite.)

Erläuterung: Die ersten beiden Zeilen konvertieren die Eingabe in eine unäre und duplizieren sie (so haben wir es jetzt x;x). Die nächsten beiden Zeilen suchen nach einemx&3 von entweder 0oder 1und ändern sich x;xin x;0oder x;2entsprechend. Die nächsten beiden Zeilen suchen x&3==3und ändern sich x;xin x;x;x;...;x;1;x( x xs). Dies bedeutet , dass wir entweder x;0, x;2, x;x, oder , x;...;xund es bleibt zu multiplizieren alles zusammen und konvertieren zurück in Dezimalzahlen. (Der Multiplikationscode basiert auf dem im Retina-Wiki, wurde jedoch geändert, um die Multiplikation mit Null zu behandeln.)