Ceci est un CMC (mini défi de chat) que j'ai publié dans notre salon de discussion, The Ninteenth Byte , il y a un peu.

Le défi

Étant donné un entier positif x, en fonction des 2 derniers bits de x, procédez comme suit:

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

Entrée sortie

Single Integer -> Single Integer  

Une nouvelle ligne de fin est autorisée dans la sortie. Aucun autre espace n'est autorisé.

Cas de test

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

C'est un défi de code-golf , donc le code le plus court gagne!

Gelée , 8 octets

ị“+×*_”v

Essayez-le en ligne!

Comment ça marche

Tout d'abord, notez que x&3c'est équivalent à x%4, où %est modulo. Ensuite, puisque Jelly utilise l'indexation modulaire (a[n] == a[n+len(a)] ), nous n'avons donc même pas besoin de gérer cela.

Ensuite:

• Si x%4==0, retourx_x (soustraction) (pour cohérence);
• Si x%4==1, retourx+x ;
• Si x%4==2, retourx×x (multiplication);
• Si x%4==3, retour x*x(exponentiation)

Notez que Jelly utilise l'indexation 1, donc la soustraction "_"est déplacée à la fin.

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

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

Essayez-le en ligne!

CJam , 12 octets

ri__"-+*#"=~

Essayez-le en ligne!

Explication

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.

Exécute l'une des opérations suivantes en fonction de xla valeur de mod 4 (le mod 4 est équivalent à AND 3).

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

Mathematica 25 octets

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

4 octets enregistrés grâce à @MartinEnder

Pyth, 8 octets

.v@"0y*^

Interprète

Rubis , 26 octets

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

Essayez-le en ligne!

PHP, 37 octets

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

Version en ligne

PHP, 47 octets

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

Version en ligne

Fonctions BC Math

Haskell, 28 27 octets

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

Essayez-le en ligne!

Edit: Merci à @ Ørjan Johansen pour 1 octet.

JavaScript, 24 octets

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

Essayez-le en ligne!

C, 63 ou 62 octets

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

-1 octet si les macros sont autorisées, en supposant que ce xn'est pas une expression comme 3+5(car cela gâcherait la priorité):

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

Java 7, 75 octets

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

Même s'il est valide selon les règles, il longest de 64 bits, il échoue donc pour les cas de test d'exponentiation de 19^19et au-dessus. Pour résoudre ce problème, nous pouvons utiliser une BigDecimalapproche:

148 146 octets

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

Explication (de l'approche 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

Code de test:

Essayez-le ici.

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

Sortie:

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; 

Assembleur x86, syntaxe Intel, 192 octets

.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

L'exemple prétend la vitesse de travail la plus rapide. Is est un programme ou une partie de programme qui utilise la convention fastcall. Il suppose une variable d'entréex dans le registreeax et renvoie le résultat également danseax . L'idée de base est d'éviter d'utiliser des sauts conditionnels, comme dans certains exemples ici. En outre, il ne s'agit pas de tout évaluer (comme dans l'exemple C avec des tableaux), mais d'utiliser un tableau de pointeurs vers des fonctons et de faire des sauts inconditionnels plus rapides (jmp / call) comme un analogique "C language switch () - case .." optimisé. Cette technique pourrait également être utile dans des types d'automates finis, comme les émulateurs de processeurs, les exécuteurs, etc.

Mise à jour: pour x64, utilisez "r" dans les noms de registres, au lieu de "e" (par exemple raxau lieu de eax, rcxau lieu de ecx). La taille ne sera pas modifiée et elle utilisera des mots non signés 64 bits.

C #, 39 octets

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

Explication

Observe ceci:

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

La solution crée un tableau, y indexe puis multiplie le résultat par x:

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

Versions alternatives:

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

(39B, toute multiplication effectuée dans le tableau, x%4remplace x&3)

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

(39B, identique à la réponse de @ MetaColon mais x%2*2*xremplaçant x*x%4<1?0:2)

En fait , 12 octets

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

Essayez-le en ligne!

Explication:

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

Ð"-+*m"è.V

Utilise l' encodage 05AB1E . Essayez-le en ligne!

J , 14 octets

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

Essayez-le en ligne!

Oasis , 25 octets

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

Essayez-le en ligne!

Comment ça marche

Notez que cela x&3équivaut à x%4, où %est 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 est un langage basé sur la pile où chaque personnage est une commande.

Cubix , 29 octets

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

Essayez-le en ligne!

Une explication sera bientôt ajoutée ...

C #, 42 octets

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

En fait, c'est C # normal, mais comme vous ne pouvez pas l'exécuter comme un programme entier et que vous devez le taper dans l'interactif, je suppose que vous pouvez l'appeler C # interactif .

Explication :

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)

Je ne peux pas dire si c'est la variante la plus courte, toutes les suggestions sont appréciées.

PHP, 36 octets

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

dc, 27

Je n'ai jamais eu l'occasion d'utiliser des tableaux en DC auparavant:

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

Essayez-le en ligne .

Groovy, 26 octets

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

Essayez-le en ligne!

C, 115 octets

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

L'exemple est une fonction int f(int x)

Il prétend la vitesse de travail la plus rapide car il empêche le CPU d'utiliser des sauts conditionnels. Et ce n'est que la manière correcte d'optimiser la vitesse pour cette tâche. En outre, il essaie de ne pas tout évaluer, comme dans l'exemple du tableau C, return(int[]){0,x+x,x*x,pow(x,x)}[x%4];mais d'utiliser judicieusement le tableau de pointeurs vers les fonctons, afin de faire des sauts inconditionnels beaucoup plus rapides (jmp / call) avec une arithmétique d'adresse beaucoup plus rapide, comme une version optimisée de " switch () - case .. ". Cette technique pourrait également être utile dans plusieurs types d'automates finis - comme les émulateurs de processeur, les exécuteurs, les analyseurs de flux de commandes, etc. - où la vitesse est importante et le code comme switch(x%4) case(0):... case(1):... ne convient pas car elle produit plusieurs instructions cmp / jnz; et ce sont des opérations coûteuses pour le CPU

Le programme de test le plus simple et le plus court (dans les conditions par défaut) pour le cas sera le suivant:

D(main,f(x))

Il ajoutera seulement 12 octets de charge utile et totalisera notre taille à 127 octets;

Mais il vaut mieux dire à l'éditeur de liens d'utiliser la ffonction comme point d'entrée au lieu de main. C'est le moyen, si nous visons à obtenir le binaire de travail le plus rapide possible pour cette tâche à partir du code le plus court ;-) Cela se produit car la bibliothèque C ajoute du code init / shutdown supplémentaire avant d'appeler votre fonction main ().

Le code se compile sur MSVS Community 2015 sans trucs et problèmes et produit des résultats corrects. Je ne l'ai pas testé avec gcc, mais je suis sûr que cela fonctionnera aussi bien.

R, 47 42 octets

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

Applique la fonction -, +, *, ou ^sur la base du module xde xet x.

- est la seule chose (un peu) intelligente, car x-x est toujours 0.

R, 33 octets

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

Même méthode que les autres utilisent. Bien qu'il soit plus court, je ne l'aime pas autant.

Pyth , 12 octets

.vjd,+@"-+*^

Essayez-le en ligne!

Comment ça marche

Tout d'abord, notez que x&3c'est équivalent à x%4, où %est modulo. Ensuite, puisque Pyth utilise l'indexation modulaire ( a[n] == a[n+len(a)]), nous n'avons donc même pas besoin de gérer cela.

Ensuite:

• Si x%4==0, retournez x-x(pour cohérence);
• Si x%4==1, revenezx+x ;
• Si x%4==2, revenezx*x ;
• Si x%4==3, revenez x^x.

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

En savoir plus sur la notation polonaise: Wikipedia (tant pis si vous êtes en Turquie).

Japt, 13 bytes

Ov"^+*p"gU +U

Try it online!

This uses the same method as the other eval answers, except the program -U just negates U, so we use ^ (bitwise XOR) instead.

Vim, 50 bytes

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

Here, ^V represents a Ctrl+V, ^R represents Ctrl-R and ^[ represents the esc key

Works by first building up the expression and then letting bc evaluate it. Expects the input on the first line in an otherwise empty buffer.

Explanation:

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^

Test suite

Nothing fancy going on here, just calculate the four values, and select one with modular indexing.

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

I was hoping to create the exponentiation by building up and evaluating a string of the form [0+...+0, 2+...+2, x+...+x, x*...*x] depending on the last two bits of x but unfortunately the code to select the operation took too long to express because I couldn't use * as a for parameter, but I was at least able to use some fall-though trickery to golf away some bytes.

Retina, 87 bytes

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

Try it online! (Link includes test suite.)

Explanation: The first two lines convert the input into unary and duplicate it (so we now have x;x). The next two lines look for an x&3 of either 0 or 1 and change x;x into x;0 or x;2 appropriately. The next two lines look for x&3==3 and change x;x into x;x;x;...;x;1;x (x xs). This means that we have either x;0, x;2, x;x, or x;...;x and it remains to multiply everything together and convert back to decimal. (The multiplication code is based on that in the Retina wiki but amended to handle multiplication by zero.)