Fonction de conception f (f (n)) == -n

Une question que j'ai posée lors de ma dernière interview:

Concevez une fonction f, telle que:

f(f(n)) == -n

Où nest un entier signé 32 bits ; vous ne pouvez pas utiliser l'arithmétique des nombres complexes.

Si vous ne pouvez pas concevoir une telle fonction pour toute la gamme de nombres, concevez-la pour la plus large gamme possible.

Des idées?

Que diriez-vous:

f (n) = signe (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 promeut automatiquement les entiers en longueurs arbitraires. Dans d'autres langues, le plus grand entier positif débordera, donc cela fonctionnera pour tous les entiers sauf celui-ci.

Pour le faire fonctionner pour des nombres réels, vous devez remplacer le n dans (-1) ⁿ par { ceiling(n) if n>0; floor(n) if n<0 }.

En C # (fonctionne pour tout double, sauf en cas de débordement):

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

Vous n'avez pas dit à quel type de langage ils s'attendaient ... Voici une solution statique (Haskell). Il s'agit essentiellement de jouer avec les 2 bits les plus significatifs:

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

C'est beaucoup plus facile dans un langage dynamique (Python). Vérifiez simplement si l'argument est un nombre X et renvoyez un lambda qui renvoie -X:

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

Voici une preuve de la raison pour laquelle une telle fonction ne peut pas exister, pour tous les nombres, si elle n'utilise pas d'informations supplémentaires (sauf 32 bits d'int):

Nous devons avoir f (0) = 0. (Preuve: Supposons que f (0) = x. Alors f (x) = f (f (0)) = -0 = 0. Maintenant, -x = f (f (x )) = f (0) = x, ce qui signifie que x = 0.)

De plus, pour tout xet y, supposons f(x) = y. Nous voulons f(y) = -xalors. Et f(f(y)) = -y => f(-x) = -y. Pour résumer: si f(x) = y, alors f(-x) = -y, et f(y) = -x, et f(-y) = x.

Donc, nous devons diviser tous les entiers sauf 0 en ensembles de 4, mais nous avons un nombre impair de tels entiers; non seulement cela, si nous supprimons l'entier qui n'a pas de contrepartie positive, nous avons toujours 2 nombres (mod4).

Si nous supprimons les 2 nombres maximaux restants (par valeur abs), nous pouvons obtenir la fonction:

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

Bien sûr, une autre option consiste à ne pas se conformer à 0 et à obtenir les 2 numéros que nous avons supprimés en bonus. (Mais c'est juste un idiot si.)

Merci à la surcharge 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));
}

Ou, vous pourriez abuser du préprocesseur:

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

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

Cela est vrai pour tous les nombres négatifs.

    f (n) = abs (n)

Parce qu'il y a un nombre négatif de plus qu'il y a de nombres positifs pour deux entiers complémentaires, f(n) = abs(n)est valable pour un cas de plus que la f(n) = n > 0 ? -n : nsolution qui est la même que f(n) = -abs(n). Je vous ai par un ...: D

MISE À JOUR

Non, ce n'est pas valable pour un cas de plus comme je viens de le reconnaître par le commentaire de litb ... abs(Int.Min)va juste déborder ...

J'ai aussi pensé à utiliser les informations du mod 2, mais j'ai conclu que cela ne fonctionne pas ... trop tôt. Si cela est fait correctement, cela fonctionnera pour tous les numéros, sauf Int.Minparce que cela débordera.

MISE À JOUR

J'ai joué avec pendant un certain temps, à la recherche d'un bon truc de manipulation, mais je n'ai pas pu trouver un joli one-liner, tandis que la solution mod 2 tient dans un.

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

En C #, cela devient le suivant:

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

Pour le faire fonctionner pour toutes les valeurs, vous devez remplacer Math.Abs()par (n > 0) ? +n : -net inclure le calcul dans un uncheckedbloc. Ensuite, vous êtes même Int.Minmappé sur lui-même comme le fait la négation non contrôlée.

MISE À JOUR

Inspiré par une autre réponse, je vais expliquer comment fonctionne la fonction et comment construire une telle fonction.

Commençons au tout début. La fonction fest appliquée à plusieurs reprises à une valeur donnée, nce qui donne une séquence de valeurs.

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

La question demande f(f(n)) = -n, soit deux applications successives de fnier l'argument. Deux autres applications de f- quatre au total - annulent à nouveau l'argument n.

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

Maintenant, il y a un cycle évident de longueur quatre. En substituant x = f(n)et en notant que l'équation obtenue f(f(f(n))) = f(f(x)) = -xest vraie, on obtient ce qui suit.

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

Nous obtenons donc un cycle de longueur quatre avec deux nombres et les deux nombres niés. Si vous imaginez le cycle comme un rectangle, les valeurs négatives sont situées aux coins opposés.

Une des nombreuses solutions pour construire un tel cycle est la suivante à partir de n.

 n => nier et soustraire un
-n - 1 = - (n + 1) => ajouter un
-n => nier et ajouter un
 n + 1 => soustraire un
 n

Un exemple concret est d'un tel cycle est +1 => -2 => -1 => +2 => +1. On a presque fini. En notant que le cycle construit contient un nombre positif impair, son successeur pair et que les deux nombres sont négatifs, nous pouvons facilement partitionner les nombres entiers en plusieurs de ces cycles ( 2^32est un multiple de quatre) et avons trouvé une fonction qui satisfait les conditions.

Mais nous avons un problème avec zéro. Le cycle doit contenir 0 => x => 0parce que zéro est annulé à lui-même. Et parce que le cycle indique déjà 0 => xqu'il suit 0 => x => 0 => x. Ce n'est qu'un cycle de longueur deux et xest transformé en lui-même après deux applications, pas en -x. Heureusement, il y a un cas qui résout le problème. Si Xest égal à zéro, nous obtenons un cycle de longueur un contenant uniquement zéro et nous avons résolu ce problème en concluant que zéro est un point fixe de f.

Terminé? Presque. Nous avons des 2^32nombres, zéro est un point fixe laissant des 2^32 - 1nombres, et nous devons partitionner ce nombre en cycles de quatre nombres. Mauvais qui 2^32 - 1n'est pas un multiple de quatre - il restera trois nombres qui ne seront dans aucun cycle de longueur quatre.

Je vais expliquer la partie restante de la solution en utilisant le plus petit ensemble de itegers signés sur 3 bits allant de -4à +3. Nous en avons fini avec zéro. Nous avons un cycle complet +1 => -2 => -1 => +2 => +1. Construisons maintenant le cycle à partir de +3.

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

Le problème qui se pose est qu'il +4n'est pas représentable comme un entier de 3 bits. Nous obtiendrions +4en niant -3à +3- ce qui est toujours un entier valide de 3 bits - mais en ajoutant ensuite un à +3(binaire 011), on obtient 100binaire. Interprété comme un entier non signé, il l'est, +4mais nous devons l'interpréter comme un entier signé -4. Donc, en fait, -4pour cet exemple ou Int.MinValuedans le cas général, il y a un deuxième point fixe de négation arithmétique entière - 0 et Int.MinValuesont mappés à eux-mêmes. Le cycle est donc en fait le suivant.

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

C'est un cycle de longueur deux et +3entre en plus dans le cycle via -4. En conséquence -4est correctement mappé sur lui-même après deux applications de fonction, +3est correctement mappé sur -3après deux applications de fonction, mais -3est mappé par erreur sur lui-même après deux applications de fonction.

Nous avons donc construit une fonction qui fonctionne pour tous les entiers sauf un. Pouvons-nous faire mieux? Non, nous ne pouvons pas. Pourquoi? Nous devons construire des cycles de longueur quatre et pouvons couvrir toute la plage entière jusqu'à quatre valeurs. Les valeurs restantes sont les deux points fixes 0et Int.MinValuequi doivent être mappés sur eux-mêmes et deux entiers arbitraires xet -xqui doivent être mappés l'un sur l'autre par deux applications de fonction.

Pour correspondre xà -xet vice versa, ils doivent former un cycle à quatre et ils doivent être situés aux coins opposés de ce cycle. En conséquence 0et Int.MinValuedoivent également être dans des coins opposés. Cela va correctement mapper xet -xmais échanger les deux points fixes 0et Int.MinValueaprès deux applications de fonction et nous laisser avec deux entrées défaillantes. Il n'est donc pas possible de construire une fonction qui fonctionne pour toutes les valeurs, mais nous en avons une qui fonctionne pour toutes les valeurs sauf une et c'est le mieux que nous puissions obtenir.

À l'aide de nombres complexes, vous pouvez efficacement diviser la tâche de négation d'un nombre en deux étapes:

• multipliez n par i, et vous obtenez n * i, qui est n tourné de 90 ° dans le sens antihoraire
• multipliez à nouveau par i, et vous obtenez -n

La grande chose est que vous n'avez pas besoin de code de traitement spécial. La simple multiplication par i fait le travail.

Mais vous n'êtes pas autorisé à utiliser des nombres complexes. Vous devez donc en quelque sorte créer votre propre axe imaginaire, en utilisant une partie de votre plage de données. Étant donné que vous avez besoin d'autant de valeurs imaginaires (intermédiaires) que de valeurs initiales, il ne vous reste que la moitié de la plage de données.

J'ai essayé de visualiser cela sur la figure suivante, en supposant que les données signées 8 bits. Vous devez mettre cela à l'échelle pour les entiers 32 bits. La plage autorisée pour n initial est de -64 à +63. Voici ce que fait la fonction pour n positif:

• Si n est dans 0..63 (plage initiale), l'appel de fonction ajoute 64, mappant n à la plage 64..127 (plage intermédiaire)
• Si n est dans 64..127 (plage intermédiaire), la fonction soustrait n de 64, mappant n à la plage 0 ..- 63

Pour n négatif, la fonction utilise la plage intermédiaire -65 ..- 128.

Fonctionne sauf int.MaxValue et 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 question ne dit rien sur ce que le type d'entrée et de la valeur de retour de la fonction fdoivent être (au moins pas la façon dont vous l'avez présenté) ...

... juste que lorsque n est un entier 32 bits, f(f(n)) = -n

Alors, que diriez-vous de quelque chose comme

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

Si n est un entier 32 bits, alors l'instruction f(f(n)) == -nsera vraie.

De toute évidence, cette approche pourrait être étendue pour fonctionner avec une gamme de nombres encore plus large ...

pour le javascript (ou d'autres langages typés dynamiquement), vous pouvez demander à la fonction d'accepter un int ou un objet et de renvoyer l'autre. c'est à dire

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

donnant

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

vous pouvez également utiliser la surcharge dans un langage fortement typé bien que cela puisse enfreindre les règles, c.-à-d.

int f(long n) {
    return n;
}

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

Selon votre plateforme, certaines langues vous permettent de conserver l'état dans la fonction. VB.Net, par exemple:

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

    Return n * flag
End Function

L'IIRC, C ++ l'a également autorisé. Je soupçonne cependant qu'ils recherchent une solution différente.

Une autre idée est que, puisqu'ils n'ont pas défini le résultat du premier appel à la fonction, vous pouvez utiliser impair / égalité pour contrôler s'il faut inverser le signe:

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

Ajoutez un à la magnitude de tous les nombres pairs, soustrayez un de la magnitude de tous les nombres impairs. Le résultat de deux appels a la même ampleur, mais le seul appel où il est même nous échangeons le signe. Il y a des cas où cela ne fonctionnera pas (-1, max ou min int), mais cela fonctionne beaucoup mieux que tout ce qui a été suggéré jusqu'à présent.

Exploiter les exceptions JavaScript.

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

f(f(0)) => 0

f(f(1)) => -1

Pour toutes les valeurs 32 bits (avec la mise en garde de -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);
}

Vous devez essentiellement associer chaque boucle -x => x => -x à la boucle ay => -y => y. J'ai donc jumelé les côtés opposés du split.

par exemple pour les entiers 4 bits:

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

Une version C ++, probablement pliant quelque peu les règles mais fonctionne pour tous les types numériques (flottants, entiers, doubles) et même les types de classe qui surchargent le moins unaire:

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 (style 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

Code vérifié, tous les entiers 32 bits possibles passés, erreur avec -2147483647 (sous-dépassement).

Utilise les globaux ... mais alors?

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

Cette solution Perl fonctionne pour les entiers, les flottants et les chaînes .

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

Essayez quelques données de test.

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

Production:

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

Personne n'a jamais dit que f (x) devait être du même type.

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


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

Je n'essaie pas réellement de donner une solution au problème lui-même, mais j'ai quelques commentaires, car la question indique que ce problème a été posé faisait partie d'un entretien (d'emploi?):

• Je voudrais d'abord demander "Pourquoi une telle fonction serait-elle nécessaire? Quel est le plus gros problème dont cela fait partie?" au lieu d'essayer de résoudre le problème posé sur place. Cela montre comment je pense et comment je m'attaque à des problèmes comme celui-ci. Qui sait? C'est peut-être même la raison pour laquelle la question est posée en premier lieu lors d'un entretien. Si la réponse est "Ça ne vous dérange pas, supposez que c'est nécessaire et montrez-moi comment vous concevriez cette fonction." Je continuerais alors à le faire.
• Ensuite, j'écrirais le code de cas de test C # que j'utiliserais (l'évidence: boucle de int.MinValueà int.MaxValue, et pour chacun ndans cet appel de plage f(f(n))et vérifier le résultat est-n ), en disant que j'utiliserais ensuite Test Driven Development pour arriver à une telle fonction.
• Ce n'est que si l'intervieweur continue de me demander de résoudre le problème posé que je commencerai à essayer de griffonner le pseudocode pendant l'entretien lui-même pour essayer d'obtenir une sorte de réponse. Cependant, je ne pense pas vraiment que je serais en train de sauter pour prendre le poste si l'intervieweur pouvait être une indication de la société.

Oh, cette réponse suppose que l'entrevue était pour un poste lié à la programmation C #. Ce serait bien sûr une réponse idiote si l'entretien était pour un poste lié aux mathématiques. ;-)

Je voudrais que vous changiez les 2 bits les plus significatifs.

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

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

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

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

Comme vous pouvez le voir, ce n'est qu'un ajout, en laissant de côté le peu porté.

Comment ai-je obtenu la réponse? Ma première pensée était juste un besoin de symétrie. 4 tours pour revenir là où j'ai commencé. Au début, je pensais que c'était du code Gray à 2 bits. Ensuite, j'ai pensé que le binaire standard était suffisant.

Voici une solution qui s'inspire de l'exigence ou de la revendication selon laquelle les nombres complexes ne peuvent pas être utilisés pour résoudre ce problème.

La multiplication par la racine carrée de -1 est une idée qui semble échouer car -1 n'a pas de racine carrée sur les entiers. Mais jouer avec un programme comme mathématique donne par exemple l'équation

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

et c'est presque aussi bon que d'avoir une racine carrée de -1. Le résultat de la fonction doit être un entier signé. Je vais donc utiliser une opération modulo modifiée mods (x, n) qui retourne l'entier y congruent à x modulo n qui est le plus proche de 0. Seuls très peu de langages de programmation ont réussi une opération modulo, mais elle peut facilement être définie . Par exemple en python c'est:

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

En utilisant l'équation ci-dessus, le problème peut maintenant être résolu comme

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

Cela satisfait f(f(x)) = -xpour tous les entiers de la plage[-231-2, 231-2] . Les résultats de f(x)sont également dans cette plage, mais bien sûr, le calcul aurait besoin d'entiers 64 bits.

C # pour une plage de 2 ^ 32 - 1 nombres, tous les nombres int32 sauf (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

impressions:

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

La fonction doit essentiellement diviser la plage disponible en cycles de taille 4, avec -n à l'extrémité opposée du cycle de n. Cependant, 0 doit faire partie d'un cycle de taille 1, car sinon0->x->0->x != -x . Parce que 0 est seul, il doit y avoir 3 autres valeurs dans notre plage (dont la taille est un multiple de 4) pas dans un cycle correct avec 4 éléments.

J'ai choisi ces valeurs étranges supplémentaires pour être MIN_INT, MAX_INTet MIN_INT+1. En outre, MIN_INT+1sera mappé MAX_INTcorrectement, mais restez bloqué et ne mappez pas en arrière. Je pense que c'est le meilleur compromis, car il a la belle propriété de ne fonctionner que correctement les valeurs extrêmes. Cela signifie également que cela fonctionnerait pour tous les 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)

Personne n'a dit qu'il devait être apatride.

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

Tricher, mais pas autant que beaucoup d'exemples. Encore plus de mal serait de jeter un œil à la pile pour voir si l'adresse de votre appelant est & f, mais cela sera plus portable (bien que pas sûr pour les threads ... la version thread-safe utiliserait TLS). Encore plus de mal:

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

Bien sûr, ni l'un ni l'autre ne fonctionne trop bien dans le cas de MIN_INT32, mais vous ne pouvez pas faire grand-chose à ce sujet, sauf si vous êtes autorisé à renvoyer un type plus large.

Je pourrais imaginer utiliser le 31e bit comme un bit imaginaire ( i ) serait une approche qui prendrait en charge la moitié de la plage totale.

fonctionne pour 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
}

Le problème indique "des entiers signés 32 bits" mais ne spécifie pas s'ils sont à deux ou à un complément .

Si vous utilisez le complément à un, toutes les valeurs de 2 ^ 32 se produisent par cycles de longueur quatre - vous n'avez pas besoin d'un cas spécial pour zéro, et vous n'avez pas non plus besoin de conditions.

En C:

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

Cela fonctionne par

1. Échange des blocs haut et bas 16 bits
2. Inverser l'un des blocs

Après deux passes, nous avons l'inverse au niveau du bit de la valeur d'origine. Ce qui dans la représentation du complément à un équivaut à la négation.

Exemples:

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)

:RÉ

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

J'aimerais partager mon point de vue sur ce problème intéressant en tant que mathématicien. Je pense que j'ai la solution la plus efficace.

Si je me souviens bien, vous annulez un entier 32 bits signé en retournant simplement le premier bit. Par exemple, si n = 1001 1101 1110 1011 1110 0000 1110 1010, alors -n = 0001 1101 1110 1011 1110 0000 1110 1010.

Alors, comment définissons-nous une fonction f qui prend un entier signé 32 bits et renvoie un autre entier signé 32 bits avec la propriété que prendre deux fois f équivaut à retourner le premier bit?

Permettez-moi de reformuler la question sans mentionner les concepts arithmétiques comme les nombres entiers.

Comment définir une fonction f qui prend une séquence de zéros et de longueur 32 et renvoie une séquence de zéros et de même longueur, avec la propriété que prendre f deux fois équivaut à retourner le premier bit?

Observation: Si vous pouvez répondre à la question ci-dessus pour le cas 32 bits, vous pouvez également répondre pour le cas 64 bits, le cas 100 bits, etc. Vous appliquez simplement f au premier 32 bits.

Maintenant, si vous pouvez répondre à la question du cas 2 bits, Voila!

Et oui, il s'avère que changer les 2 premiers bits est suffisant.

Voici le pseudo-code

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.

Remarque: L'étape 2 et l'étape 3 ensemble peuvent être résumées comme (a, b) -> (-b, a). Ça vous semble familier? Cela devrait vous rappeler la rotation de 90 degrés de l'avion et la multiplication par la racine carrée de -1.

Si je venais de présenter le pseudo-code seul sans le long prélude, cela ressemblerait à un lapin sorti du chapeau, je voulais expliquer comment j'ai obtenu la solution.