Este es un CMC (mini desafío de chat) que publiqué en nuestra sala de chat, The Ninteenth Byte , hace un poco.

El reto

Dado un entero positivo x, dependiendo de los últimos 2 bits de x, haga lo siguiente:

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

De entrada y salida

Single Integer -> Single Integer  

Se permite una nueva línea final en la salida. No se permite ningún otro espacio en blanco.

Casos de prueba

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

Este es un desafío de código de golf , por lo que gana el código más corto.

Jalea , 8 bytes

ị“+×*_”v

Pruébalo en línea!

Cómo funciona

En primer lugar, observe que x&3es equivalente a x%4, donde %es módulo. Entonces, dado que Jelly usa la indexación modular ( a[n] == a[n+len(a)]), entonces ni siquiera necesitamos ocuparnos de eso.

Luego:

• Si x%4==0, devuelve x_x(resta) (por consistencia);
• Si x%4==1, vuelve x+x;
• Si x%4==2, retorno x×x(multiplicación);
• Si x%4==3, retorno x*x(exponenciación)

Tenga en cuenta que Jelly utiliza la indexación 1, por lo que la resta "_"se mueve al final.

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

Pruébalo en línea!

CJam , 12 bytes

ri__"-+*#"=~

Pruébalo en línea!

Explicación

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.

Ejecuta una de las siguientes operaciones dependiendo del xvalor del mod 4 (mod 4 es equivalente a AND 3).

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

Mathematica 25 Bytes

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

Guardado 4 Bytes gracias a @MartinEnder

Pyth, 8 bytes

.v@"0y*^

Interprete

Rubí , 26 bytes

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

Pruébalo en línea!

PHP, 37 bytes

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

Versión en línea

PHP, 47 bytes

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

Versión en línea

Funciones de BC Math

Haskell, 28 27 bytes

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

Pruébalo en línea!

Editar: Gracias a @ Ørjan Johansen por 1 byte.

JavaScript, 24 bytes

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

Pruébalo en línea!

C, 63 o 62 bytes

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

-1 byte si se permiten macros, suponiendo xque no sea una expresión como 3+5(ya que eso estropearía la precedencia):

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

Aunque es válido según las reglas, longes de 64 bits, por lo que falla en los casos de prueba de exponenciación de 19^19y superiores. Para arreglar eso podemos usar un BigDecimalenfoque:

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

Explicación (del enfoque 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

Código de prueba:

Pruébalo aquí

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

Salida:

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; 

Ensamblador x86, sintaxis Intel, 192 bytes

.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

El ejemplo pretende la velocidad de trabajo más rápida. Is es un programa o parte del programa, que utiliza la convención de llamada rápida. Asume una variable de entrada xen el registro eaxy devuelve el resultado también en eax. La idea básica es mantenerse alejado del uso de saltos condicionales, como en algunos ejemplos aquí. Además, no es evaluar todo (como en el ejemplo de C con matrices) sino utilizar una matriz de punteros para functons y hacer saltos incondicionales más rápidos (jmp / call) como un análogo optimizado de "cambio de lenguaje C () - mayúsculas y minúsculas". Esta técnica también podría ser útil en tipos de autómatas finitos, como emuladores de procesadores, ejecutores, etc.

Upd: para x64 use "r" en los nombres de registro, en lugar de "e" (por ejemplo, en raxlugar de eax, en rcxlugar de ecx). El tamaño no se cambiará y utilizará palabras sin signo de 64 bits.

C #, 39 bytes

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

Explicación

Observa eso:

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

La solución crea una matriz, la indexa y luego multiplica el resultado por x:

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

Versiones alternativas:

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

(39B, toda la multiplicación realizada en la matriz, x%4reemplaza x&3)

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

(39B, igual que la respuesta de @ MetaColon pero x%2*2*xreemplazando x*x%4<1?0:2)

En realidad , 12 bytes

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

Pruébalo en línea!

Explicación:

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

Utiliza la codificación 05AB1E . Pruébalo en línea!

J , 14 bytes

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

Pruébalo en línea!

Oasis , 25 bytes

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

Pruébalo en línea!

Cómo funciona

Tenga en cuenta que x&3es equivalente a x%4, donde %es módulo.

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 es un lenguaje basado en la pila donde cada personaje es un comando.

Cubix , 29 bytes

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

Pruébalo en línea!

La explicación se agregará pronto ...

C #, 42 bytes

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

En realidad, es C # normal, pero como no puede ejecutarlo como un programa completo y tiene que escribirlo en el interactivo, creo que puede llamarlo C # interactivo .

Explicacion :

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)

No puedo decir si es la variante más corta, se agradece cualquier sugerencia.

PHP, 36 bytes

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

dc, 27

Nunca he tenido la oportunidad de usar matrices en cc antes:

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

Pruébalo en línea .

Groovy, 26 bytes

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

Pruébalo en línea!

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

El ejemplo es una función int f(int x)

Pretende una velocidad de trabajo más rápida, ya que evita que la CPU use saltos condicionales. Y esta es solo la forma correcta de optimización de velocidad para esta tarea. Además, intenta no evaluar todo, como en el ejemplo de la matriz C, return(int[]){0,x+x,x*x,pow(x,x)}[x%4];sino utilizar sabiamente una variedad de punteros a las funciones, para hacer saltos incondicionales mucho más rápidos (jmp / call) con una aritmética de direcciones mucho más rápida, como una versión optimizada de " switch () - case .. ". Esta técnica también podría ser útil en varios tipos de autómatas finitos, como emuladores de procesador, ejecutores, analizadores de flujo de comandos, etc., donde la velocidad es importante y el código switch(x%4) case(0):... case(1):... no es adecuado porque produce múltiples instrucciones cmp / jnz; y estas son operaciones costosas para la CPU

El programa de prueba más simple y corto (en condiciones predeterminadas) para el caso será el siguiente:

D(main,f(x))

Agregará solo 12 bytes de carga útil y totalizará nuestro tamaño a 127 bytes;

Pero es mejor que le digas al enlazador que use la ffunción como punto de entrada, en lugar de main. Esa es la forma, si nuestro objetivo es obtener el binario de trabajo más rápido posible para esta tarea desde el código más corto ;-) Esto sucede porque la biblioteca C agrega código de inicio / apagado adicional antes de llamar a su función main ().

El código se compila en MSVS Community 2015 sin ningún truco y problema y produce resultados correctos. No lo he probado con gcc, pero estoy seguro de que funcionará bien también.

R, 47 42 bytes

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

Aplica la función -, +, *, o ^basado en el módulo de xa xy x.

-es lo único (algo) inteligente, ya x-xque siempre es 0.

R, 33 bytes

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

El mismo método que usan otras personas. Aunque es más corto, no me gusta tanto.

Pyth , 12 bytes

.vjd,+@"-+*^

Pruébalo en línea!

Cómo funciona

En primer lugar, observe que x&3es equivalente a x%4, donde %es módulo. Entonces, dado que Pyth usa la indexación modular ( a[n] == a[n+len(a)]), entonces ni siquiera necesitamos ocuparnos de eso.

Luego:

• Si x%4==0, devuelve x-x(por consistencia);
• Si x%4==1, vuelve x+x;
• Si x%4==2, vuelve x*x;
• Si x%4==3, vuelve x^x.

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

Más información sobre la notación polaca: Wikipedia (lástima si estás en Turquía).

Japt , 13 bytes

Ov"^+*p"gU +U

Pruébalo en línea!

Esto usa el mismo método que las otras respuestas de evaluación, excepto que el programa -Usimplemente niega U, por lo que usamos ^(XOR bit a bit) en su lugar.

Vim, 50 bytes

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

Aquí, ^Vrepresenta a Ctrl+V, ^RrepresentaCtrl-R y ^[representa la escclave

Funciona construyendo primero la expresión y luego dejando bcevaluarla. Espera la entrada en la primera línea en un búfer vacío.

Explicación:

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^

Banco de pruebas

Aquí no pasa nada, solo calcule los cuatro valores y seleccione uno con indexación modular.

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

Lote, 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%

Esperaba crear la exponenciación construyendo y evaluando una cadena del formulario [0+...+0, 2+...+2, x+...+x, x*...*x]dependiendo de los dos últimos bits, xpero desafortunadamente el código para seleccionar la operación tardó demasiado en expresarse porque no podía usarlo *como forparámetro, pero estaba al menos capaz de usar algunos trucos de caída para eliminar algunos bytes.

Retina , 87 bytes

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

Pruébalo en línea! (El enlace incluye un conjunto de pruebas).

Explicación: Las dos primeras líneas convierten la entrada en unaria y la duplican (así que ahora la tenemos x;x). Las siguientes dos líneas buscan una x&3de o 0o 1y cambian x;xa x;0o x;2apropiadamente. Las siguientes dos líneas buscan x&3==3y cambian x;xa x;x;x;...;x;1;x( x xs). Esto significa que tenemos o bien x;0, x;2, x;x, o x;...;xy queda por todo lo que se multiplican juntos y volver a convertir decimal. (El código de multiplicación se basa en eso en la wiki de Retina, pero se modificó para manejar la multiplicación por cero).