Progettazione della funzione f (f (n)) == -n

Una domanda che ho ricevuto durante la mia ultima intervista:

Progettare una funzione in modo ftale che:

f(f(n)) == -n

Dove nè un numero intero con segno a 32 bit ; non puoi usare l'aritmetica dei numeri complessi.

Se non è possibile progettare una tale funzione per l'intera gamma di numeri, progettarla per la gamma più ampia possibile.

Qualche idea?

Che ne dite di:

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

In 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 promuove automaticamente numeri interi in lunghezze arbitrarie. In altre lingue il numero intero positivo più grande traboccerà, quindi funzionerà per tutti i numeri interi tranne quello.

Per farlo funzionare con numeri reali è necessario sostituire n in (-1) ⁿ con { ceiling(n) if n>0; floor(n) if n<0 }.

In C # (funziona per qualsiasi doppio, tranne in situazioni di overflow):

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

Non hai detto che tipo di linguaggio si aspettavano ... Ecco una soluzione statica (Haskell). Fondamentalmente si scherza con i 2 bit più significativi:

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

È molto più semplice in un linguaggio dinamico (Python). Basta controllare se l'argomento è un numero X e restituire un lambda che restituisce -X:

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

Ecco una prova del perché una tale funzione non può esistere, per tutti i numeri, se non utilizza informazioni aggiuntive (tranne 32 bit di int):

Dobbiamo avere f (0) = 0. (Prova: supponiamo f (0) = x. Quindi f (x) = f (f (0)) = -0 = 0. Ora, -x = f (f (x )) = f (0) = x, il che significa che x = 0.)

Inoltre, per qualsiasi xe y, supponiamo f(x) = y. Vogliamo f(y) = -xallora. E f(f(y)) = -y => f(-x) = -y. Riassumendo: if f(x) = y, then f(-x) = -y, e f(y) = -x, and f(-y) = x.

Quindi, abbiamo bisogno di dividere tutti i numeri interi tranne 0 in set di 4, ma abbiamo un numero dispari di tali numeri interi; non solo, se rimuoviamo il numero intero che non ha una controparte positiva, abbiamo ancora 2 (mod4) numeri.

Se rimuoviamo i 2 numeri massimi rimasti (in base al valore abs), possiamo ottenere la funzione:

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

Naturalmente un'altra opzione, è di non rispettare 0, e ottenere i 2 numeri che abbiamo rimosso come bonus. (Ma è solo uno sciocco se.)

Grazie al sovraccarico in 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));
}

Oppure, potresti abusare del preprocessore:

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

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

Questo è vero per tutti i numeri negativi.

    f (n) = abs (n)

Poiché esiste un numero più negativo di quanti siano i numeri positivi per i numeri interi a due complementi, f(n) = abs(n)è valido per un caso in più rispetto alla f(n) = n > 0 ? -n : nsoluzione uguale a f(n) = -abs(n). Ti ho preso per uno ...: D

AGGIORNARE

No, non è valido per un altro caso in quanto ho appena riconosciuto dal commento di Litb ... traboccerà abs(Int.Min)...

Ho pensato di usare anche le informazioni sulla mod 2, ma ho concluso che non funziona ... troppo presto. Se fatto bene, funzionerà per tutti i numeri tranne Int.Minperché questo traboccerà.

AGGIORNARE

Ci ho giocato per un po ', cercando un bel trucco di manipolazione, ma non sono riuscito a trovare un buon one-liner, mentre la soluzione mod 2 si inserisce in uno.

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

In C #, questo diventa il seguente:

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

Per farlo funzionare per tutti i valori, è necessario sostituirlo Math.Abs()con (n > 0) ? +n : -ne includere il calcolo in un uncheckedblocco. Quindi vieni persino Int.Minmappato su se stesso come fa la negazione non selezionata.

AGGIORNARE

Ispirato da un'altra risposta, spiegherò come funziona la funzione e come costruirla.

Cominciamo dall'inizio. La funzione fviene ripetutamente applicata a un dato valore nproducendo una sequenza di valori.

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

La domanda richiede f(f(n)) = -n, cioè due successive applicazioni di fnegare l'argomento. Altre due applicazioni di f- quattro in totale - annullano nuovamente l'argomentazione n.

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

Ora c'è un ovvio ciclo di lunghezza quattro. Sostituendo x = f(n)e notando che l'equazione ottenuta f(f(f(n))) = f(f(x)) = -xvale, si ottiene quanto segue.

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

Quindi otteniamo un ciclo di lunghezza quattro con due numeri e i due numeri negati. Se immagini il ciclo come un rettangolo, i valori negati si trovano agli angoli opposti.

Una delle tante soluzioni per costruire un tale ciclo è la seguente a partire da n.

 n => annulla e sottrai uno
-n - 1 = - (n + 1) => aggiungi uno
-n => annulla e aggiungi uno
 n + 1 => sottrai uno
 n

Un esempio concreto è di tale ciclo +1 => -2 => -1 => +2 => +1. Abbiamo quasi finito. Notando che il ciclo costruito contiene un numero positivo dispari, il suo successore pari ed entrambi i numeri negano, possiamo facilmente suddividere gli interi in molti di questi cicli ( 2^32è un multiplo di quattro) e abbiamo trovato una funzione che soddisfa le condizioni.

Ma abbiamo un problema con zero. Il ciclo deve contenere 0 => x => 0perché zero è negato a se stesso. E poiché il ciclo afferma già 0 => xsegue 0 => x => 0 => x. Questo è solo un ciclo di lunghezza due e xsi trasforma in se stesso dopo due applicazioni, non in -x. Fortunatamente c'è un caso che risolve il problema. Se è Xuguale a zero otteniamo un ciclo di lunghezza uno contenente solo zero e abbiamo risolto il problema concludendo che zero è un punto fisso di f.

Fatto? Quasi. Abbiamo 2^32numeri, zero è un punto fisso che lascia 2^32 - 1numeri e dobbiamo suddividere quel numero in cicli di quattro numeri. Bad che 2^32 - 1non è un multiplo di quattro - rimarranno tre numeri non in nessun ciclo di lunghezza quattro.

Spiegherò la parte rimanente della soluzione usando l'insieme più piccolo di iteger con firma a 3 bit che vanno da -4a +3. Abbiamo finito con zero. Abbiamo un ciclo completo +1 => -2 => -1 => +2 => +1. Ora costruiamo il ciclo a partire da +3.

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

Il problema che si pone è che +4non è rappresentabile come numero intero a 3 bit. Otterremmo +4negando -3a +3- quello che è ancora un po '3 intero valido - ma poi l'aggiunta di uno a +3(binario 011) produce 100binario. Interpretato come intero senza segno, +4ma dobbiamo interpretarlo come intero con segno -4. Quindi in realtà -4per questo esempio o Int.MinValuenel caso generale è un secondo punto fisso di negazione aritmetica intera - 0 e Int.MinValuesono mappati su loro stessi. Quindi il ciclo è in realtà il seguente.

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

È un ciclo di lunghezza due ed +3entra inoltre nel ciclo tramite -4. Di conseguenza, -4viene correttamente mappato su se stesso dopo due applicazioni, +3viene correttamente mappato su -3due applicazioni, ma -3viene erroneamente mappato su se stesso dopo due applicazioni.

Quindi abbiamo costruito una funzione che funziona per tutti gli interi tranne uno. Possiamo fare di meglio? No, non possiamo. Perché? Dobbiamo costruire cicli di lunghezza quattro e siamo in grado di coprire l'intero intervallo intero fino a quattro valori. I valori rimanenti sono i due punti fissi 0e Int.MinValueche devono essere mappati su se stessi e due numeri interi arbitrari xe -xche devono essere mappati tra loro da due applicazioni di funzione.

Per mappare xa -xe viceversa devono formare un ciclo a quattro e devono essere posizionati in angoli opposti di tale ciclo. Di conseguenza 0e Int.MinValueanche agli angoli opposti. Ciò mappare correttamente xe -xma scambiare i due punti fissi 0e Int.MinValuedopo due applicazioni funzionali e lasciarli con due ingressi fallimento. Quindi non è possibile costruire una funzione che funzioni per tutti i valori, ma ne abbiamo una che funziona per tutti i valori tranne uno e questo è il meglio che possiamo ottenere.

Utilizzando numeri complessi, è possibile dividere in modo efficace l'attività di negare un numero in due passaggi:

• moltiplica n per i e otterrai n * i, che viene ruotato di 90 ° in senso antiorario
• moltiplicare di nuovo per i e si ottiene -n

Il bello è che non hai bisogno di alcun codice di gestione speciale. Basta moltiplicare per il lavoro.

Ma non ti è permesso usare numeri complessi. Quindi devi in ​​qualche modo creare il tuo asse immaginario, usando parte del tuo intervallo di dati. Dato che hai bisogno esattamente della stessa quantità di valori immaginari (intermedi) dei valori iniziali, ti rimane solo metà dell'intervallo di dati.

Ho provato a visualizzarlo nella figura seguente, assumendo dati con segno a 8 bit. Dovresti ridimensionarlo per numeri interi a 32 bit. L'intervallo consentito per l'iniziale n è compreso tra -64 e +63. Ecco cosa fa la funzione per n positivo:

• Se n è in 0..63 (intervallo iniziale), la chiamata di funzione aggiunge 64, mappando n nell'intervallo 64..127 (intervallo intermedio)
• Se n è in 64..127 (intervallo intermedio), la funzione sottrae n da 64, mappando n nell'intervallo 0 ..- 63

Per n negativo, la funzione utilizza l'intervallo intermedio -65 ..- 128.

Funziona ad eccezione di int.MaxValue e 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 domanda non dice nulla su ciò che fdevono essere il tipo di input e il valore restituito della funzione (almeno non nel modo in cui l'hai presentata) ...

... solo che quando n è un numero intero a 32 bit allora f(f(n)) = -n

Quindi, che ne dici di qualcosa del genere

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

Se n è un numero intero a 32 bit, l'istruzione f(f(n)) == -nsarà vera.

Ovviamente, questo approccio potrebbe essere esteso per funzionare per una gamma ancora più ampia di numeri ...

per javascript (o altre lingue tipizzate dinamicamente) puoi avere la funzione di accettare un int o un oggetto e restituire l'altro. vale a dire

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

in alternativa, è possibile utilizzare il sovraccarico in un linguaggio fortemente tipizzato, sebbene ciò possa infrangere le regole

int f(long n) {
    return n;
}

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

A seconda della piattaforma, alcune lingue consentono di mantenere lo stato nella funzione. VB.Net, ad esempio:

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

    Return n * flag
End Function

Anche IIRC, C ++ lo ha permesso. Sospetto però che stiano cercando una soluzione diversa.

Un'altra idea è che dal momento che non hanno definito il risultato della prima chiamata alla funzione, è possibile utilizzare dispari / uniformità per controllare se invertire il segno:

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

Aggiungine uno alla grandezza di tutti i numeri pari, sottrai uno dalla grandezza di tutti i numeri dispari. Il risultato di due chiamate ha la stessa grandezza, ma l'unica chiamata in cui è anche scambiamo il segno. Ci sono alcuni casi in cui questo non funziona (-1, max o min int), ma funziona molto meglio di qualsiasi altra cosa suggerita finora.

Sfruttare le eccezioni JavaScript.

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

f(f(0)) => 0

f(f(1)) => -1

Per tutti i valori a 32 bit (con l'avvertenza che -0 è -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);
}

Fondamentalmente è necessario accoppiare ogni ciclo -x => x => -x con il ciclo ay => -y => y. Quindi ho accoppiato i lati opposti di split.

ad es. per numeri interi a 4 bit:

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

Una versione C ++, che probabilmente piega leggermente le regole ma funziona per tutti i tipi numerici (float, ints, doppi) e persino per i tipi di classe che sovraccaricano il meno 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 (stile 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

Codice verificato, tutti i possibili numeri interi a 32 bit passati, errore con -2147483647 (underflow).

Usa i globi ... ma così?

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

Questa soluzione Perl funziona per numeri interi, float e stringhe .

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

Prova alcuni dati di prova.

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

Produzione:

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

Nessuno ha mai detto che f (x) doveva essere dello stesso tipo.

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


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

In realtà non sto cercando di dare una soluzione al problema stesso, ma ho un paio di commenti, poiché la domanda afferma che questo problema è stato posto faceva parte di un'intervista (di lavoro?):

• Vorrei prima chiedere "Perché dovrebbe essere necessaria una tale funzione? Qual è il problema più grande di cui fa parte?" invece di cercare di risolvere il problema reale posto sul posto. Questo mostra come penso e come affrontare problemi come questo. Chi lo sa? Questo potrebbe anche essere il vero motivo per cui la domanda viene posta in un'intervista in primo luogo. Se la risposta è "Non importa, supponi che sia necessario e mostrami come progetterai questa funzione." Vorrei quindi continuare a farlo.
• Quindi, scriverei il codice del test case C # che userei (l'ovvio: loop da int.MinValuea int.MaxValue, e per ciascuno nin quell'intervallo chiama f(f(n))e controlla che il risultato sia-n ), dicendo che avrei quindi usato Test Driven Development per arrivare a tale funzione.
• Solo se l'intervistatore continua a chiedermi di risolvere il problema posto, in realtà inizierei a cercare di scribacchiare lo pseudocodice durante l'intervista stessa per cercare di ottenere una sorta di risposta. Tuttavia, non penso davvero che salterei per accettare il lavoro se l'intervistatore fosse un indizio di come fosse la società ...

Oh, questa risposta presuppone che l'intervista fosse per una posizione relativa alla programmazione in C #. Naturalmente sarebbe una risposta sciocca se l'intervista riguardasse una posizione matematica. ;-)

Vorresti cambiare i 2 bit più significativi.

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

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

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

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

Come puoi vedere, è solo un'aggiunta, tralasciando il bit trasportato.

Come sono arrivato alla risposta? Il mio primo pensiero era solo un bisogno di simmetria. 4 giri per tornare da dove ho iniziato. All'inizio ho pensato, questo è il codice Gray a 2 bit. Poi ho pensato che in realtà il binario standard fosse abbastanza.

Ecco una soluzione che si ispira al requisito o afferma che non è possibile utilizzare numeri complessi per risolvere questo problema.

Moltiplicare per la radice quadrata di -1 è un'idea, che sembra fallire solo perché -1 non ha una radice quadrata sugli interi. Ma giocare con un programma come matematica dà ad esempio l'equazione

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

e questo è quasi buono come avere una radice quadrata di -1. Il risultato della funzione deve essere un numero intero con segno. Quindi userò una mod di operazione modulo modificata (x, n) che restituisce l'intero y congruente a x modulo n che è il più vicino a 0. Solo pochissimi linguaggi di programmazione hanno una operazione modulo, ma può essere facilmente definita . Ad esempio in Python è:

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

Utilizzando l'equazione sopra, il problema può ora essere risolto come

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

Questo soddisfa f(f(x)) = -xper tutti gli interi nell'intervallo . Anche i risultati di sono in questo intervallo, ma ovviamente il calcolo avrebbe bisogno di numeri interi a 64 bit.[-231-2, 231-2]f(x)

C # per un intervallo di 2 ^ 32 - 1 numeri, tutti i numeri int32 tranne (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

stampe:

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

Essenzialmente la funzione deve dividere l'intervallo disponibile in cicli di dimensione 4, con -n all'estremità opposta del ciclo di n. Tuttavia, 0 deve far parte di un ciclo di dimensione 1, perché altrimenti0->x->0->x != -x . Dato che 0 è solo, ci devono essere altri 3 valori nel nostro intervallo (la cui dimensione è un multiplo di 4) non in un ciclo corretto con 4 elementi.

Ho scelto questi valori in più strani di essere MIN_INT, MAX_INTe MIN_INT+1. Inoltre, MIN_INT+1mapperà MAX_INTcorrettamente, ma rimarrà bloccato lì e non mappare indietro. Penso che questo sia il miglior compromesso, perché ha la bella proprietà che solo i valori estremi non funzionano correttamente. Inoltre, significa che funzionerebbe per tutti i 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)

Nessuno ha detto che doveva essere apolide.

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

Barare, ma non tanto quanto molti esempi. Ancora più malvagio sarebbe sbirciare lo stack per vedere se l'indirizzo del chiamante è & f, ma questo sarà più portatile (anche se non thread-safe ... la versione thread-safe userebbe TLS). Ancora più cattivo:

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

Naturalmente, nessuno di questi funziona troppo bene nel caso di MIN_INT32, ma c'è poco prezioso che puoi fare a meno che non ti sia permesso di restituire un tipo più ampio.

Potrei immaginare di usare il 31 bit come bit immaginario ( i ) sarebbe un approccio che supporterebbe metà dell'intervallo totale.

funziona per 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
}

Il problema indica "numeri interi con segno a 32 bit" ma non specifica se sono complementi a due o a complementi .

Se si utilizza il complemento a uno, tutti i valori 2 ^ 32 si verificano in cicli di lunghezza quattro: non è necessario un caso speciale per zero e non sono necessari anche i condizionali.

In C:

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

Questo funziona da

1. Scambio di blocchi alti e bassi a 16 bit
2. Invertire uno dei blocchi

Dopo due passaggi abbiamo l'inverso bit a bit del valore originale. Che nella rappresentazione ad un complemento equivale alla negazione.

Esempi:

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)

: D

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

Vorrei condividere il mio punto di vista su questo interessante problema come matematico. Penso di avere la soluzione più efficiente.

Se ricordo bene, si annulla un numero intero a 32 bit con segno semplicemente lanciando il primo bit. Ad esempio, se n = 1001 1101 1110 1011 1110 0000 1110 1010, quindi -n = 0001 1101 1110 1011 1110 0000 1110 1010.

Quindi, come possiamo definire una funzione f che accetta un numero intero a 32 bit con segno e restituisce un altro numero intero a 32 bit con la proprietà che prendere f due volte è lo stesso che lanciare il primo bit?

Permettetemi di riformulare la domanda senza menzionare concetti aritmetici come numeri interi.

Come definiamo una funzione f che accetta una sequenza di zeri e quelli di lunghezza 32 e restituisce una sequenza di zeri e quelli della stessa lunghezza, con la proprietà che prendere f due volte equivale a lanciare il primo bit?

Osservazione: se è possibile rispondere alla domanda sopra per caso a 32 bit, allora si può anche rispondere per caso a 64 bit, caso a 100 bit, ecc. È sufficiente applicare f al primo 32 bit.

Ora, se puoi rispondere alla domanda per il caso a 2 bit, Voila!

E sì, risulta che cambiare i primi 2 bit è sufficiente.

Ecco lo pseudo-codice

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.

Nota: il passaggio 2 e il passaggio 3 insieme possono essere estesi come (a, b) -> (-b, a). Sembra familiare? Ciò dovrebbe ricordare la rotazione di 90 gradi del piano e la moltiplicazione per la radice quadrata di -1.

Se avessi appena presentato lo pseudo-codice da solo senza il lungo preludio, sembrerebbe un coniglio fuori dal cappello, vorrei spiegare come ho ottenuto la soluzione.