Diseño de la función f (f (n)) == -n

Una pregunta que recibí en mi última entrevista:

Diseñe una función f, de modo que:

f(f(n)) == -n

Donde nes un entero con signo de 32 bits ; no puedes usar aritmética de números complejos.

Si no puede diseñar dicha función para todo el rango de números, diséñela para el rango más grande posible.

¿Algunas ideas?

Qué tal si:

f (n) = signo (n) - (-1) n * n

En Python:

def f(n): 
    if n == 0: return 0
    if n >= 0:
        if n % 2 == 1: 
            return n + 1
        else: 
            return -1 * (n - 1)
    else:
        if n % 2 == 1:
            return n - 1
        else:
            return -1 * (n + 1)

Python promueve automáticamente enteros a longitudes arbitrarias de longitud. En otros idiomas, el número entero positivo más grande se desbordará, por lo que funcionará para todos los números enteros excepto ese.

Para que funcione para números reales, debe reemplazar la n en (-1) ⁿ con { ceiling(n) if n>0; floor(n) if n<0 }.

En C # (funciona para cualquier doble, excepto en situaciones de desbordamiento):

static double F(double n)
{
    if (n == 0) return 0;

    if (n < 0)
        return ((long)Math.Ceiling(n) % 2 == 0) ? (n + 1) : (-1 * (n - 1));
    else
        return ((long)Math.Floor(n) % 2 == 0) ? (n - 1) : (-1 * (n + 1));
}

No dijiste qué tipo de lenguaje esperaban ... Aquí hay una solución estática (Haskell). Básicamente está jugando con los 2 bits más significativos:

f :: Int -> Int
f x | (testBit x 30 /= testBit x 31) = negate $ complementBit x 30
    | otherwise = complementBit x 30

Es mucho más fácil en un lenguaje dinámico (Python). Simplemente verifique si el argumento es un número X y devuelve una lambda que devuelve -X:

def f(x):
   if isinstance(x,int):
      return (lambda: -x)
   else:
      return x()

Aquí hay una prueba de por qué dicha función no puede existir, para todos los números, si no utiliza información adicional (excepto 32 bits de int):

Debemos tener f (0) = 0. (Prueba: supongamos que f (0) = x. Entonces f (x) = f (f (0)) = -0 = 0. Ahora, -x = f (f (x )) = f (0) = x, lo que significa que x = 0.)

Además, para cualquiera xy y, supongamos f(x) = y. Queremos f(y) = -xentonces. Y f(f(y)) = -y => f(-x) = -y. Para resumir: si f(x) = y, entonces f(-x) = -y, y f(y) = -x, y f(-y) = x.

Entonces, necesitamos dividir todos los enteros excepto 0 en conjuntos de 4, pero tenemos un número impar de tales enteros; no solo eso, si eliminamos el número entero que no tiene una contraparte positiva, todavía tenemos 2 números (mod4).

Si eliminamos los 2 números máximos restantes (por valor de abs), podemos obtener la función:

int sign(int n)
{
    if(n>0)
        return 1;
    else 
        return -1;
}

int f(int n)
{
    if(n==0) return 0;
    switch(abs(n)%2)
    {
        case 1:
             return sign(n)*(abs(n)+1);
        case 0:
             return -sign(n)*(abs(n)-1);
    }
}   

Por supuesto, otra opción es no cumplir con 0 y obtener los 2 números que eliminamos como bonificación. (Pero eso es una tontería si).

Gracias a la sobrecarga en C ++:

double f(int var)
{
 return double(var);
} 

int f(double var)
{
 return -int(var);
}

int main(){
int n(42);
std::cout<<f(f(n));
}

O puede abusar del preprocesador:

#define f(n) (f##n)
#define ff(n) -n

int main()
{
  int n = -42;
  cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
}

Esto es cierto para todos los números negativos.

    f (n) = abs (n)

Debido a que hay un número negativo más que números positivos para dos enteros complementarios, f(n) = abs(n)es válido para un caso más que una f(n) = n > 0 ? -n : nsolución que sea la misma que f(n) = -abs(n). Te tengo por uno ...: D

ACTUALIZAR

No, no es válido para un caso más, como acabo de reconocer por el comentario de litb ... abs(Int.Min)simplemente se desbordará ...

También pensé en usar la información de mod 2, pero concluí que no funciona ... demasiado pronto. Si se hace correctamente, funcionará para todos los números, excepto Int.Minporque se desbordará.

ACTUALIZAR

Jugué con él por un tiempo, buscando un buen truco de manipulación, pero no pude encontrar una buena línea, mientras que la solución mod 2 encaja en una.

    f (n) = 2n (abs (n)% 2) - n + sgn (n)

En C #, esto se convierte en lo siguiente:

public static Int32 f(Int32 n)
{
    return 2 * n * (Math.Abs(n) % 2) - n + Math.Sign(n);
}

Para conseguir que funcione para todos los valores, tiene que sustituir Math.Abs()con (n > 0) ? +n : -ne incluir el cálculo en un uncheckedbloque. Luego, incluso te Int.Minasignas a ti mismo como lo hace la negación sin control.

ACTUALIZAR

Inspirado por otra respuesta, voy a explicar cómo funciona la función y cómo construirla.

Comencemos desde el principio. La función fse aplica repetidamente a un valor dado que nproduce una secuencia de valores.

    n => f (n) => f (f (n)) => f (f (f (n))) => f (f (f (f (n))))) => ...

La pregunta exige f(f(n)) = -n, es decir, dos aplicaciones sucesivas de fnegar el argumento. Dos aplicaciones adicionales de f- cuatro en total - niegan el argumento nuevamente dando como resultado nnuevamente.

    n => f (n) => -n => f (f (f (n))) => n => f (n) => ...

Ahora hay un ciclo obvio de longitud cuatro. Sustituyendo x = f(n)y observando que la ecuación obtenida se f(f(f(n))) = f(f(x)) = -xcumple, se obtiene lo siguiente.

    n => x => -n => -x => n => ...

Entonces obtenemos un ciclo de longitud cuatro con dos números y los dos números negados. Si imagina el ciclo como un rectángulo, los valores negados se encuentran en las esquinas opuestas.

Una de las muchas soluciones para construir dicho ciclo es la siguiente a partir de n.

 n => negar y restar uno
-n - 1 = - (n + 1) => agregar uno
-n => negar y agregar uno
 n + 1 => restar uno
 norte

Un ejemplo concreto es de tal ciclo es +1 => -2 => -1 => +2 => +1. Casi terminamos. Al observar que el ciclo construido contiene un número positivo impar, su sucesor par, y ambos números se niegan, podemos dividir fácilmente los enteros en muchos de estos ciclos ( 2^32es un múltiplo de cuatro) y hemos encontrado una función que satisface las condiciones.

Pero tenemos un problema con cero. El ciclo debe contener 0 => x => 0porque el cero se niega a sí mismo. Y porque el ciclo ya dice 0 => xque sigue 0 => x => 0 => x. Este es solo un ciclo de longitud dos y xse convierte en sí mismo después de dos aplicaciones, no en -x. Afortunadamente, hay un caso que resuelve el problema. Si Xes igual a cero, obtenemos un ciclo de longitud uno que contiene solo cero y resolvemos ese problema concluyendo que cero es un punto fijo de f.

¿Hecho? Casi. Tenemos 2^32números, el cero es un punto fijo que deja 2^32 - 1números, y debemos dividir ese número en ciclos de cuatro números. Malo que 2^32 - 1no es un múltiplo de cuatro: quedarán tres números que no estarán en ningún ciclo de longitud cuatro.

Explicaré la parte restante de la solución usando el conjunto más pequeño de iteradores con signo de 3 bits que van desde -4hasta +3. Hemos terminado con cero. Tenemos un ciclo completo +1 => -2 => -1 => +2 => +1. Ahora construyamos el ciclo comenzando en +3.

    +3 => -4 => -3 => +4 => +3

El problema que surge es que +4no es representable como un entero de 3 bits. Obtendríamos +4negando -3a +3- lo que todavía es un número entero de 3 bits válido - pero luego sumando uno al +3(binario 011) los rendimientos 100binario. Se interpreta como un entero sin signo, +4pero tenemos que interpretarlo como un entero con signo -4. Entonces, en realidad, -4para este ejemplo o Int.MinValueen el caso general, hay un segundo punto fijo de negación aritmética de enteros, 0 y Int.MinValuese asignan a sí mismos. Entonces el ciclo es en realidad como sigue.

    +3 => -4 => -3 => -4 => -3

Es un ciclo de longitud dos y además +3ingresa al ciclo a través de -4. En consecuencia, -4se asigna correctamente a sí mismo después de dos aplicaciones de función, +3se asigna correctamente -3después de dos aplicaciones de función, pero -3se asigna erróneamente a sí mismo después de dos aplicaciones de función.

Así que construimos una función que funciona para todos los enteros menos uno. ¿Podemos hacerlo mejor? No podemos. ¿Por qué? Tenemos que construir ciclos de longitud cuatro y podemos cubrir todo el rango entero hasta cuatro valores. Los valores restantes son los dos puntos fijos 0y Int.MinValueque deben asignarse a sí mismos y a dos enteros arbitrarios xy -xdeben correlacionarse entre sí mediante dos aplicaciones de función.

Para asignar xa -xy viceversa deben formar un ciclo de cuatro y deben estar ubicados en las esquinas opuestas de ese ciclo. En consecuencia 0y Int.MinValuetiene que estar en las esquinas opuestas, también. Esto asignará correctamente xy cambiará -xlos dos puntos fijos 0y Int.MinValuedespués de dos aplicaciones de función y nos dejará con dos entradas fallidas. Por lo tanto, no es posible construir una función que funcione para todos los valores, pero tenemos una que funciona para todos los valores excepto uno y esto es lo mejor que podemos lograr.

Usando números complejos, puede dividir efectivamente la tarea de negar un número en dos pasos:

• multiplica n por i, y obtienes n * i, que n gira 90 ° en sentido antihorario
• multiplica de nuevo por i, y obtienes -n

Lo bueno es que no necesita ningún código de manejo especial. Simplemente multiplicando por i hace el trabajo.

Pero no puedes usar números complejos. Entonces, de alguna manera, debe crear su propio eje imaginario, utilizando parte de su rango de datos. Como necesita exactamente tantos valores imaginarios (intermedios) como valores iniciales, solo le queda la mitad del rango de datos.

Traté de visualizar esto en la siguiente figura, suponiendo datos firmados de 8 bits. Tendría que escalar esto para enteros de 32 bits. El rango permitido para n inicial es -64 a +63. Esto es lo que hace la función para n positivo:

• Si n está en 0..63 (rango inicial), la llamada a la función agrega 64, asignando n al rango 64..127 (rango intermedio)
• Si n está en 64..127 (rango intermedio), la función resta n de 64, asignando n al rango 0 ..- 63

Para n negativo, la función usa el rango intermedio -65 ..- 128.

Funciona excepto int.MaxValue y int.MinValue

    public static int f(int x)
    {

        if (x == 0) return 0;

        if ((x % 2) != 0)
            return x * -1 + (-1 *x) / (Math.Abs(x));
        else
            return x - x / (Math.Abs(x));
    }

La pregunta no dice nada acerca de lo que el tipo de entrada y el valor de retorno de la función ftienen que ser (al menos no de la manera que has presentado) ...

... solo que cuando n es un entero de 32 bits f(f(n)) = -n

Entonces, ¿qué tal algo como

Int64 f(Int64 n)
{
    return(n > Int32.MaxValue ? 
        -(n - 4L * Int32.MaxValue):
        n + 4L * Int32.MaxValue);
}

Si n es un entero de 32 bits, la declaración f(f(n)) == -nserá verdadera.

Obviamente, este enfoque podría extenderse para que funcione para un rango aún más amplio de números ...

para javascript (u otros lenguajes escritos dinámicamente) puede hacer que la función acepte un int o un objeto y devuelva el otro. es decir

function f(n) {
    if (n.passed) {
        return -n.val;
    } else {
        return {val:n, passed:1};
    }
}

dando

js> f(f(10))  
-10
js> f(f(-10))
10

alternativamente, podría usar la sobrecarga en un lenguaje fuertemente tipado, aunque eso puede romper las reglas

int f(long n) {
    return n;
}

long f(int n) {
    return -n;
}

Dependiendo de su plataforma, algunos idiomas le permiten mantener el estado en la función. VB.Net, por ejemplo:

Function f(ByVal n As Integer) As Integer
    Static flag As Integer = -1
    flag *= -1

    Return n * flag
End Function

IIRC, C ++ permitió esto también. Sin embargo, sospecho que están buscando una solución diferente.

Otra idea es que, dado que no definieron el resultado de la primera llamada a la función, podría usar impar / par para controlar si invertir el signo:

int f(int n)
{
   int sign = n>=0?1:-1;
   if (abs(n)%2 == 0)
      return ((abs(n)+1)*sign * -1;
   else
      return (abs(n)-1)*sign;
}

Suma uno a la magnitud de todos los números pares, resta uno de la magnitud de todos los números impares. El resultado de dos llamadas tiene la misma magnitud, pero en una llamada donde incluso cambiamos el signo. Hay algunos casos en los que esto no funcionará (-1, max o min int), pero funciona mucho mejor que cualquier otra cosa sugerida hasta ahora.

Explotación de excepciones de JavaScript.

function f(n) {
    try {
        return n();
    }
    catch(e) { 
        return function() { return -n; };
    }
}

f(f(0)) => 0

f(f(1)) => -1

Para todos los valores de 32 bits (con la advertencia de que -0 es -2147483648)

int rotate(int x)
{
    static const int split = INT_MAX / 2 + 1;
    static const int negativeSplit = INT_MIN / 2 + 1;

    if (x == INT_MAX)
        return INT_MIN;
    if (x == INT_MIN)
        return x + 1;

    if (x >= split)
        return x + 1 - INT_MIN;
    if (x >= 0)
        return INT_MAX - x;
    if (x >= negativeSplit)
        return INT_MIN - x + 1;
    return split -(negativeSplit - x);
}

Básicamente, necesita emparejar cada bucle -x => x => -x con ay => -y => bucle y. Así que emparejé lados opuestos de la split.

Por ejemplo, para enteros de 4 bits:

0 => 7 => -8 => -7 => 0
1 => 6 => -1 => -6 => 1
2 => 5 => -2 => -5 => 2
3 => 4 => -3 => -4 => 3

Una versión de C ++, probablemente doblando las reglas, pero funciona para todos los tipos numéricos (flotantes, ints, dobles) e incluso tipos de clase que sobrecargan el menos unario:

template <class T>
struct f_result
{
  T value;
};

template <class T>
f_result <T> f (T n)
{
  f_result <T> result = {n};
  return result;
}

template <class T>
T f (f_result <T> n)
{
  return -n.value;
}

void main (void)
{
  int n = 45;
  cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
  float p = 3.14f;
  cout << "f(f(" << p << ")) = " << f(f(p)) << endl;
}

x86 asm (estilo AT&T):

; input %edi
; output %eax
; clobbered regs: %ecx, %edx
f:
    testl   %edi, %edi
    je  .zero

    movl    %edi, %eax
    movl    $1, %ecx
    movl    %edi, %edx
    andl    $1, %eax
    addl    %eax, %eax
    subl    %eax, %ecx
    xorl    %eax, %eax
    testl   %edi, %edi
    setg    %al
    shrl    $31, %edx
    subl    %edx, %eax
    imull   %ecx, %eax
    subl    %eax, %edi
    movl    %edi, %eax
    imull   %ecx, %eax
.zero:
    xorl    %eax, %eax
    ret

Código verificado, todos los enteros posibles de 32 bits pasados, error con -2147483647 (flujo inferior).

Usa globals ... pero ¿y eso?

bool done = false
f(int n)
{
  int out = n;
  if(!done)
  {  
      out = n * -1;
      done = true;
   }
   return out;
}

Esta solución de Perl funciona para enteros, flotantes y cadenas .

sub f {
    my $n = shift;
    return ref($n) ? -$$n : \$n;
}

Prueba algunos datos de prueba.

print $_, ' ', f(f($_)), "\n" for -2, 0, 1, 1.1, -3.3, 'foo' '-bar';

Salida:

-2 2
0 0
1 -1
1.1 -1.1
-3.3 3.3
foo -foo
-bar +bar

Nadie dijo que f (x) tenía que ser del mismo tipo.

def f(x):
    if type(x) == list:
        return -x[0]
    return [x]


f(2) => [2]
f(f(2)) => -2

Realmente no estoy tratando de dar una solución al problema en sí, pero tengo un par de comentarios, ya que la pregunta dice que este problema fue parte de una entrevista (de trabajo):

• Primero preguntaría "¿Por qué se necesitaría tal función? ¿Cuál es el mayor problema del que forma parte?" en lugar de tratar de resolver el problema real planteado en el acto. Esto muestra cómo pienso y cómo abordo problemas como este. ¿Quien sabe? Esa podría incluso ser la razón real por la que se hace la pregunta en una entrevista en primer lugar. Si la respuesta es "No te preocupes, asume que es necesario y muéstrame cómo diseñarías esta función". Entonces continuaría haciéndolo.
• Luego, escribiría el código de caso de prueba de C # que usaría (lo obvio: bucle de int.MinValue a int.MaxValue, y para cada nllamada dentro de ese rango f(f(n))y verificar el resultado es -n), diciéndole que luego usaría Test Driven Development para llegar a tal función.
• Solo si el entrevistador continúa pidiéndome que resuelva el problema planteado, comenzaría a tratar de garabatear pseudocódigo durante la entrevista para intentar obtener algún tipo de respuesta. Sin embargo, realmente no creo que estaría saltando para tomar el trabajo si el entrevistador fuera una indicación de cómo es la compañía ...

Oh, esta respuesta asume que la entrevista fue para un puesto relacionado con la programación de C #. Por supuesto, sería una respuesta tonta si la entrevista fuera para un puesto relacionado con las matemáticas. ;-)

Me gustaría cambiar los 2 bits más significativos.

00.... => 01.... => 10.....

01.... => 10.... => 11.....

10.... => 11.... => 00.....

11.... => 00.... => 01.....

Como puede ver, es solo una adición, dejando fuera el bit llevado.

¿Cómo llegué a la respuesta? Mi primer pensamiento fue solo una necesidad de simetría. 4 vueltas para volver a donde empecé. Al principio pensé, ese es el código Gray de 2 bits. Entonces pensé que en realidad el binario estándar es suficiente.

Aquí hay una solución inspirada en el requisito o la afirmación de que los números complejos no se pueden usar para resolver este problema.

Multiplicar por la raíz cuadrada de -1 es una idea, que solo parece fallar porque -1 no tiene una raíz cuadrada sobre los enteros. Pero jugar con un programa como Mathica da, por ejemplo, la ecuación

(1849436465 ² 1) mod (2 ³² -3) = 0.

y esto es casi tan bueno como tener una raíz cuadrada de -1. El resultado de la función debe ser un entero con signo. Por lo tanto, voy a usar un modulo modificado mods de operación (x, n) que devuelve el entero y congruente a x módulo n que está más cerca de 0. Solo muy pocos lenguajes de programación tienen una operación de módulo similar, pero se puede definir fácilmente . Por ejemplo, en python es:

def mods(x, n):
    y = x % n
    if y > n/2: y-= n
    return y

Usando la ecuación anterior, el problema ahora se puede resolver como

def f(x):
    return mods(x*1849436465, 2**32-3)

Esto satisface f(f(x)) = -xa todos los enteros en el rango . Los resultados de también están en este rango, pero por supuesto el cálculo necesitaría enteros de 64 bits.[-231-2, 231-2]f(x)

C # para un rango de 2 ^ 32 - 1 números, todos los números int32 excepto (Int32.MinValue)

    Func<int, int> f = n =>
        n < 0
           ? (n & (1 << 30)) == (1 << 30) ? (n ^ (1 << 30)) : - (n | (1 << 30))
           : (n & (1 << 30)) == (1 << 30) ? -(n ^ (1 << 30)) : (n | (1 << 30));

    Console.WriteLine(f(f(Int32.MinValue + 1))); // -2147483648 + 1
    for (int i = -3; i <= 3  ; i++)
        Console.WriteLine(f(f(i)));
    Console.WriteLine(f(f(Int32.MaxValue))); // 2147483647

huellas dactilares:

2147483647
3
2
1
0
-1
-2
-3
-2147483647

Esencialmente, la función tiene que dividir el rango disponible en ciclos de tamaño 4, con -n en el extremo opuesto del ciclo de n. Sin embargo, 0 debe ser parte de un ciclo de tamaño 1, porque de lo contrario0->x->0->x != -x . Debido a que 0 está solo, debe haber otros 3 valores en nuestro rango (cuyo tamaño es un múltiplo de 4) que no están en un ciclo adecuado con 4 elementos.

Elegí estos valores extraños adicionales a ser MIN_INT, MAX_INTy MIN_INT+1. Además, se MIN_INT+1asignará MAX_INTcorrectamente, pero se quedará atascado allí y no se asignará de nuevo. Creo que este es el mejor compromiso, porque tiene la buena propiedad de que solo los valores extremos no funcionan correctamente. Además, significa que funcionaría para todos los BigInts.

int f(int n):
    if n == 0 or n == MIN_INT or n == MAX_INT: return n
    return ((Math.abs(n) mod 2) * 2 - 1) * n + Math.sign(n)

Nadie dijo que tenía que ser apátrida.

int32 f(int32 x) {
    static bool idempotent = false;
    if (!idempotent) {
        idempotent = true;
        return -x;
    } else {
        return x;
    }
}

Hacer trampa, pero no tanto como muchos de los ejemplos. Aún más mal sería mirar la pila para ver si la dirección de la persona que llama es & f, pero esto será más portátil (aunque no seguro para subprocesos ... la versión segura para subprocesos usaría TLS). Aún más malvado:

int32 f (int32 x) {
    static int32 answer = -x;
    return answer;
}

Por supuesto, ninguno de estos funciona demasiado bien para el caso de MIN_INT32, pero hay poco que pueda hacer al respecto a menos que se le permita devolver un tipo más amplio.

Me imagino que usar el bit 31 como bit imaginario ( i ) sería un enfoque que admitiría la mitad del rango total.

funciona para n = [0 .. 2 ^ 31-1]

int f(int n) {
  if (n & (1 << 31)) // highest bit set?
    return -(n & ~(1 << 31)); // return negative of original n
  else
    return n | (1 << 31); // return n with highest bit set
}

El problema establece "enteros con signo de 32 bits", pero no especifica si son dos-complemento o unos-complemento .

Si usa complementos de uno, entonces todos los valores de 2 ^ 32 ocurren en ciclos de longitud cuatro: no necesita un caso especial para cero, y tampoco necesita condicionales.

C ª:

int32_t f(int32_t x)
{
  return (((x & 0xFFFFU) << 16) | ((x & 0xFFFF0000U) >> 16)) ^ 0xFFFFU;
}

Esto funciona por

1. Intercambiando los bloques altos y bajos de 16 bits
2. Invertir uno de los bloques

Después de dos pasadas, tenemos el inverso en bits del valor original. Que en la representación del complemento uno es equivalente a la negación.

Ejemplos:

Pass |        x
-----+-------------------
   0 | 00000001      (+1)
   1 | 0001FFFF (+131071)
   2 | FFFFFFFE      (-1)
   3 | FFFE0000 (-131071)
   4 | 00000001      (+1)

Pass |        x
-----+-------------------
   0 | 00000000      (+0)
   1 | 0000FFFF  (+65535)
   2 | FFFFFFFF      (-0)
   3 | FFFF0000  (-65535)
   4 | 00000000      (+0)

:RE

boolean inner = true;

int f(int input) {
   if(inner) {
      inner = false;
      return input;
   } else {
      inner = true;
      return -input;
   }
}

return x ^ ((x%2) ? 1 : -INT_MAX);

Me gustaría compartir mi punto de vista sobre este interesante problema como matemático. Creo que tengo la solución más eficiente.

Si no recuerdo mal, niegas un entero de 32 bits con signo simplemente volteando el primer bit. Por ejemplo, si n = 1001 1101 1110 1011 1110 0000 1110 1010, entonces -n = 0001 1101 1110 1011 1110 0000 1110 1010.

Entonces, ¿cómo definimos una función f que toma un entero de 32 bits con signo y devuelve otro entero de 32 bits con la propiedad de que tomar f dos veces es lo mismo que voltear el primer bit?

Permítanme reformular la pregunta sin mencionar conceptos aritméticos como enteros.

¿Cómo definimos una función f que toma una secuencia de ceros y unos de longitud 32 y devuelve una secuencia de ceros y unos de la misma longitud, con la propiedad de que tomar f dos veces es lo mismo que voltear el primer bit?

Observación: Si puede responder la pregunta anterior para el caso de 32 bits, también puede responder para el caso de 64 bits, el caso de 100 bits, etc. Simplemente aplique f al primer bit de 32 bits.

Ahora si puedes responder la pregunta para el caso de 2 bits, ¡Voila!

Y sí, resulta que cambiar los primeros 2 bits es suficiente.

Aquí está el pseudocódigo

1. take n, which is a signed 32-bit integer.
2. swap the first bit and the second bit.
3. flip the first bit.
4. return the result.

Observación: El paso 2 y el paso 3 juntos se pueden resumir como (a, b) -> (-b, a). ¿Luce familiar? Eso debería recordarle la rotación de 90 grados del plano y la multiplicación por la raíz cuadrada de -1.

Si solo presentara el pseudocódigo solo sin el largo preludio, parecería un conejo fuera del sombrero, quisiera explicar cómo obtuve la solución.