Tarea

Dado un entero positivo n, la salida n+1si nes impar y la salida n-1si nes par.

Entrada

Un entero positivo. Puede suponer que el número entero está dentro de la capacidad de manejo del lenguaje.

Salida

Un entero positivo, especificado anteriormente.

Casos de prueba

input output
    1      2
    2      1
    3      4
    4      3
    5      6
    6      5
    7      8
    8      7
  313    314
  314    313

Tanteo

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Se aplican lagunas estándar .

Referencias

• OEIS A103889

C, 20 bytes

f(x){return-(-x^1);}

Pruébalo en línea .

Apilar gatos , 3 + 3 ( -n) = 6 bytes

-*-

Pruébalo en línea!

Necesita que la -nbandera funcione con entradas y salidas numéricas.

Explicación

Stack Cats generalmente está lejos de ser competitivo, debido a su conjunto limitado de comandos (todos los cuales son inyecciones, y la mayoría de ellos son involuciones) y porque cada programa necesita tener simetría espejo. Sin embargo, una de las involuciones es alternar el bit menos significativo de un número, y podemos compensar el valor con la negación unaria que también existe. Afortunadamente, eso nos da un programa simétrico, por lo que no debemos preocuparnos por nada más:

-   Multiply the input by -1.
*   Toggle the least significant bit of the value (i.e. take it XOR 1).
-   Multiply the result by -1.

La entrada y la salida están implícitas al principio y al final del programa, porque tomar entrada y producir salida no es una operación reversible, por lo que no pueden ser comandos.

Asamblea x86, 9 bytes (para entrada competitiva)

Todos los que intentan este desafío en lenguajes de alto nivel se están perdiendo la verdadera diversión de manipular bits sin procesar. Hay tantas variaciones sutiles en las formas de hacer esto, es una locura, y es muy divertido pensar en ello. Aquí hay algunas soluciones que ideé en lenguaje ensamblador x86 de 32 bits.

Me disculpo de antemano porque esta no es la típica respuesta de código de golf. Voy a divagar mucho sobre el proceso de pensamiento de la optimización iterativa (para el tamaño). Espero que sea interesante y educativo para un público más amplio, pero si eres del tipo TL; DR, no me ofenderé si saltas hasta el final.

La solución obvia y eficiente es probar si el valor es par o impar (lo que se puede hacer de manera eficiente mirando el bit menos significativo), y luego seleccionar entre n + 1 o n − 1 en consecuencia. Suponiendo que la entrada se pasa como un parámetro en el ECXregistro, y el resultado se devuelve en el EAXregistro, obtenemos la siguiente función:

F6 C1 01  |  test  cl, 1                      ; test last bit to see if odd or even
8D 41 01  |  lea   eax, DWORD PTR [ecx + 1]   ; set EAX to n+1 (without clobbering flags)
8D 49 FF  |  lea   ecx, DWORD PTR [ecx - 1]   ; set ECX to n-1 (without clobbering flags)
0F 44 C1  |  cmovz eax, ecx                   ; move in different result if input was even
C3        |  ret

^{(13 bytes)}

Pero para propósitos de código de golf, esas LEAinstrucciones no son excelentes, ya que toman 3 bytes para codificar. Un DECcomentario simple de ECXsería mucho más corto (solo un byte), pero esto afecta a las banderas, por lo que debemos ser un poco inteligentes en la forma en que organizamos el código. Podemos hacer el decremento primera , y la prueba de par / impar segundos , pero luego tenemos que invertir el resultado de la prueba de par / impar.

Además, podemos cambiar la instrucción de movimiento condicional a una bifurcación, lo que puede hacer que el código se ejecute más lentamente (dependiendo de cuán predecible sea la bifurcación; si la entrada alterna inconsistentemente entre pares e impares, una bifurcación será más lenta; si hay un patrón, será más rápido), lo que nos ahorrará otro byte.

De hecho, con esta revisión, toda la operación se puede realizar en el lugar, utilizando solo un único registro. Esto es genial si está incorporando este código en alguna parte (y es probable que lo sea, ya que es muy corto).

    48     |  dec  eax          ; decrement first
    A8 01  |  test al, 1        ; test last bit to see if odd or even
    75 02  |  jnz  InputWasEven ; (decrement means test result is inverted)
    40     |  inc  eax          ; undo the decrement...
    40     |  inc  eax          ; ...and add 1
  InputWasEven:                 ; (two 1-byte INCs are shorter than one 3-byte ADD with 2)

^{(en línea: 7 bytes; como una función: 10 bytes)}

Pero, ¿y si quisieras que fuera una función? Ninguna convención de llamada estándar utiliza el mismo registro para pasar parámetros que para el valor de retorno, por lo que deberá agregar una MOVinstrucción de registro-registro al principio o al final de la función. Esto prácticamente no tiene costo en velocidad, pero agrega 2 bytes. (La RETinstrucción también agrega un byte, y hay una sobrecarga introducida por la necesidad de realizar y regresar de una llamada de función, lo que significa que este es un ejemplo en el que la alineación produce un beneficio de velocidad y tamaño, en lugar de ser simplemente una velocidad clásica -por-espacio de compensación.) En total, escrito como una función, este código se hincha a 10 bytes.

¿Qué más podemos hacer en 10 bytes? Si nos preocupamos por el rendimiento (al menos, el rendimiento predecible ), sería bueno deshacerse de esa rama. Aquí hay una solución de ramificación de bits sin ramas que tiene el mismo tamaño en bytes. La premisa básica es simple: usamos un XOR bit a bit para voltear el último bit, convirtiendo un valor impar en uno par, y viceversa. Pero hay un inconveniente: para las entradas impares, que nos da n-1 , mientras que para las entradas pares, nos da n + 1 , exactamente opuesto a lo que queremos. Entonces, para arreglar eso, realizamos la operación en un valor negativo, volteando el signo de manera efectiva.

8B C1     |  mov eax, ecx   ; copy parameter (ECX) to return register (EAX)
          |
F7 D8     |  neg eax        ; two's-complement negation
83 F0 01  |  xor eax, 1     ; XOR last bit to invert odd/even
F7 D8     |  neg eax        ; two's-complement negation
          |
C3        |  ret            ; return from function

^{(en línea: 7 bytes; como una función: 10 bytes)}

Bastante hábil; Es difícil ver cómo se puede mejorar. Sin embargo, una cosa me llama la atención: esas dos NEGinstrucciones de 2 bytes . Francamente, dos bytes parecen un byte demasiado para codificar una simple negación, pero ese es el conjunto de instrucciones con el que tenemos que trabajar. ¿Hay alguna solución? ¡Seguro! Si tenemos XOR-2, podemos reemplazar la segunda NEGacción con un INCcomentario:

8B C1     |  mov eax, ecx
          |
F7 D8     |  neg eax
83 F0 FE  |  xor eax, -2
40        |  inc eax
          |
C3        |  ret

^{(en línea: 6 bytes; como función: 9 bytes)}

¡Otra de las rarezas del conjunto de instrucciones x86 es la LEAinstrucción multipropósito , que puede hacer un movimiento de registro-registro, una adición de registro-registro, compensación por una constante y escalar todo en una sola instrucción!

8B C1        |  mov eax, ecx
83 E0 01     |  and eax, 1        ; set EAX to 1 if even, or 0 if odd
8D 44 41 FF  |  lea eax, DWORD PTR [ecx + eax*2 - 1]
C3           |  ret

^{(10 bytes)}

La ANDinstrucción es como la TESTinstrucción que usamos anteriormente, ya que ambos hacen un AND a nivel de bit y establecen indicadores en consecuencia, pero en ANDrealidad actualizan el operando de destino. La LEAinstrucción luego escala esto en 2, agrega el valor de entrada original y disminuye en 1. Si el valor de entrada era impar, esto resta 1 (2 × 0 - 1 = −1) de él; si el valor de entrada fue par, esto le agrega 1 (2 × 1 - 1 = 1).

Esta es una forma muy rápida y eficiente de escribir el código, ya que gran parte de la ejecución se puede hacer en el front-end, pero no nos compra mucho en forma de bytes, ya que se necesitan muchos para codificar un complejo LEAinstrucción. Esta versión tampoco funciona tan bien para fines de alineación, ya que requiere que el valor de entrada original se conserve como entrada de la LEAinstrucción. Entonces, con este último intento de optimización, hemos retrocedido, sugiriendo que podría ser el momento de detenerse.

Por lo tanto, para la entrada competitiva final, tenemos una función de 9 bytes que toma el valor de entrada en el ECXregistro (una convención de llamada basada en un registro semi-estándar en x86 de 32 bits), y devuelve el resultado en el EAXregistro (como con todas las convenciones de llamadas x86):

           SwapParity PROC
8B C1         mov eax, ecx
F7 D8         neg eax
83 F0 FE      xor eax, -2
40            inc eax
C3            ret
           SwapParity ENDP

Listo para armar con MASM; llamar desde C como:

extern int __fastcall SwapParity(int value);                 // MSVC
extern int __attribute__((fastcall)) SwapParity(int value);  // GNU   

Jalea , 3 bytes

-*ạ

Pruébalo en línea!

Pseudocódigo: abs((-1)**n - n)

Python3, 20 18 bytes

lambda n:n-1+n%2*2

Bastante simple. Primero calculamos n-1 y decidimos si agregarle 2 o no.

Si n es par -> n mod 2 será 0, por lo tanto agregaremos 2 * 0 a n-1 , dando como resultado n-1 .

Si n es impar -> n mod 2 será 1, por lo tanto agregaremos 2 * 1 a n-1 , resultando en n + 1 .

Prefiero una explicación que hice con MS Paint y un touchpad portátil ...

Python, 16 bytes

lambda x:-(-x^1)

Pruébalo en línea!

MATL , 7 bytes

Q:HePG)

Esto evita cualquier operación aritmética. Pruébalo en línea!

Explicación

Considere la entrada 4como un ejemplo.

Q    % Implicit input. Add 1
     % STACK: 5
:    % Range
     % STACK: [1 2 3 4 5]
He   % Reshape with 2 rows in column-major order. Pads with a zero if needed
     % STACK: [1 3 5;
               2 4 0]
P    % Flip vertically
     % STACK: [2 4 0;
               1 3 5]
G    % Push input again
     % STACK: [2 4 0;
               1 3 5], 4
)    % Index, 1-based, in column major order. Implicitly display
     % STACK: 3

Braingolf v0.1 , 11 10 bytes

.1>2,%?+:-

Pruébalo en línea! (El segundo argumento es el código Braingolf, el tercer argumento es la entrada)

Salvó un byte gracias a Neil

Primera respuesta de Braingolf en competencia: D

Explicación:

.            Duplicate the top of the stack
 1>          Push 1 to the bottom of the stack
   2         Push 2 to stack
    ,%       Pop last 2 items, mod them and push result
      ?      If last item > 0
       +     Add the 1 to the input
        :    Else
         -   Subtract the 1 from the input

             No semicolon in code so print last item

Braingolf v0.2 , 9 bytes [no competidor]

.2%?1+:1-

Pruébalo en línea! (El segundo argumento es el código Braingolf, el tercer argumento es la entrada)

Ver arriba para explicación. La única diferencia está en Braingolf v0.2, el comportamiento predeterminado de los operadores diádicos y la función del ,modificador se invierten, lo que significa que las 2 comas en la respuesta v0.1 ya no son necesarias.

Sin embargo, v0.2 se lanzó después del desafío, por lo que este no compite

Cubix , 10 9 bytes

cO1)I(//@

Pruébalo en línea

Explicación

Versión neta

    c O
    1 )
I ( / / @ . . .
. . . . . . . .
    . .
    . .

Los caracteres ejecutados son

I(1c)O@
I          Input
 (         Decrement
  1c       XOR with 1
    )      Increment
     O@    Output and exit

Python, 68 bytes

lambda x:[m.floor(x-m.cos(m.pi*x)) for m in [__import__('math')]][0]

En el espíritu de un enfoque único. El siguiente gráfico muestra la función (con puntos morados que representan los primeros 10 casos). En teoría, debería ser posible construir una solución para esta pregunta basada en la mayoría de las funciones periódicas (¿todas?) (Por ejemplo, sin, tan, sec). De hecho, sustituir cos por sec en el código tal como debería funcionar.

PHP, 15 bytes

<?=-(-$argn^1);

Javascript, 17 12 bytes

x=>x-(-1)**x

f=x=>x-(-1)**x;

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

Otro enfoque, 10 bytes _{robados de la respuesta C (sssshhh)}

x=>-(-x^1)

f=x=>-(-x^1)

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

JavaScript (ES6), 14 13 12 10 bytes

n=>-(-n^1)

• 1 byte guardado gracias a Luke .
• 2 bytes guardados al portar la solución C de feersum . (Si eso está mal visto, hágamelo saber y volveré a mi solución anterior a continuación)

Intentalo

f=
n=>-(-n^1)
i.addEventListener("input",_=>o.innerText=f(+i.value))

<input id=i type=number><pre id=o>

Original, 12 bytes

n=>n-1+n%2*2

Python, 20 bytes

lambda n:n+(n%2or-1)

n%2or-1 devolverá 1 si es impar, pero si es par, n%2 es "falso" (0), por lo que devuelve -1. Luego simplemente agregamos eso a n.

Solución anterior, 23 bytes

lambda n:[n-1,n+1][n%2]

n%2calcula el resto cuando nse divide entre 2. Si es par, esto devuelve 0 y el elemento 0 en esta lista es n-1. Si es impar, esto devuelve 1, y el elemento 1 en esta lista es n+1.

Retina , 21 bytes

.+
$*
^11(?=(11)*$)

Pruébalo en línea! ¡Mi primera respuesta de Retina con dos líneas nuevas! Explicación: Las dos primeras líneas se convierten de decimal a unario. Las líneas tercera y cuarta restan dos de los números pares. La última línea se convierte de nuevo a decimal, pero también agrega uno.

05AB1E , 4 bytes

(1^(

Pruébalo en línea!

Cubix , 11 bytes

u%2!I(/+@O<

Pruébalo en línea!

Explicación

Versión neta:

    u %
    2 !
I ( / + @ O < .
. . . . . . . .
    . .
    . .

Los caracteres se ejecutan en el siguiente orden:

I(2%!+O@
I        # Take a number as input
 (       # Decrement it
  2%     # Take the parity of the decremented number
         # (0 if the input is odd, 1 if it's even)
    !    # If that number is zero:
     +   #   Add 2
      O  # Output the number
       @ # Terminate the program

Brain-Flak , 36 bytes

(({})(())){({}[()]<([{}])>)}{}({}{})

Pruébalo en línea!

Personalmente estoy muy contento con esta respuesta porque es mucho más corta de lo que consideraría un método tradicional para resolver este problema.

Explicación

El primer bit de código

(({})(()))

convierte la pila de solo na

n + 1
  1
  n

Luego, mientras la parte superior de la pila no es cero, la disminuimos y volteamos el signo del número debajo de ella

{({}[()]<([{}])>)}

Luego eliminamos el cero y sumamos los dos números restantes

{}({}{})

Mathematica, 22 19 bytes

¡Guardado 3 bytes gracias a Greg Martin!

#-1[-1][[#~Mod~2]]&

Respuesta anterior, 22 bytes

#+{-1,1}[[#~Mod~2+1]]&

Explicación (para la respuesta anterior)

Mathematica tiene la buena característica de que operaciones como la aritmética se enhebran automáticamente en las listas.

En este caso, tomamos Mod[#,2]cuál devolverá 0 o 1, pero necesitamos agregar 1 porque las listas de Mathematica están indexadas en 1. Si es par , esto sale a 1, por lo que #-1se devuelve. Si es extraño , sale 2, por lo que #+1se devuelve.

Sabio , 8 bytes

-::^~-^-

Pruébalo en línea!

Explicación

Si esto fuera al revés (disminuir si es impar, aumentar si es par), sería bastante fácil hacer esto.

Simplemente voltearíamos el último bit.

::^~-^

La solución aquí es que volteamos el último bit mientras somos negativos. Los números negativos son 1 fuera de la negación de los números, ~por lo que esto crea un desplazamiento para resolver el problema.

Así que solo sacamos el programa y lo envolvemos -.

-::^~-^-

Java 8, 16 10 bytes

n->-(-n^1)

Java 7, 34 28 bytes

int c(int n){return-(-n^1);}

Puertos aburridos de la sorprendente respuesta C de @feersum .
Pruébalo aquí.

Viejas respuestas:

Java 8, 16 bytes

n->n%2<1?n-1:n+1

Java 7, 34 bytes

int c(int n){return--n%2>0?n:n+2;}

Explicación (de la antigua respuesta de Java 7):

Pruébalo aquí

La respuesta anterior es una variante más corta de int c(int n){return n%2<1?n-1:n+1;}deshacerse del espacio.

int c(int n){     // Method with integer parameter and integer return-type
  return--n%2>0?  //  If n-1 mod-2 is 1:
    n             //   Return n-1
   :              //  Else:
    n+2;          //   Return n+1
}                 // End of method

Japt , 6 bytes

n ^1 n

Pruébalo en línea!

Python, 20 bytes

lambda n:n+(n&1)*2-1

Befunge 93 , 18 bytes

&:2%#v_1+.@
@.-1 <

Todavía no he terminado de jugar esto (espero).

Rubí, 12 bytes.

->n{-(-n^1)}

R, 17 bytes

(n=scan())-(-1)^n

donde n=scan()toma el valor del dígito.

Casio-Basic, 27 bytes

piecewise(mod(n,2),1,-1)+n

26 bytes para la función, +1 para ingresar nen el cuadro de parámetros.

C, 29 bytes

a(int b){return b%2?b+1:b-1;}

Jalea , 4 bytes

‘’Ḃ?

Pruébalo en línea!

Lote, 20 bytes

@cmd/cset/a"-(1^-%1)

Redescubierto independientemente el algoritmo de @ feersum, ¡honesto!