Bestimmung der Funktion f(f(n)) == -n

Question

Eine Frage, die mir bei meinem letzten Vorstellungsgespräch gestellt wurde:

Eine Funktion entwerfen f , so dass:

f(f(n)) == -n

Wo n ist ein 32-Bit vorzeichenbehaftete Ganzzahl Sie können nicht mit komplexen Zahlen arithmetisch rechnen.

Wenn Sie eine solche Funktion nicht für den gesamten Zahlenbereich entwickeln können, entwickeln Sie sie für den größtmöglichen Bereich.

Irgendwelche Ideen?

Answer 1

In Python

f=lambda n:n[0]if type(n)is list else[-n]

Answer 2

Gute Frage!

Ich habe etwa 35 Sekunden gebraucht, um darüber nachzudenken und es zu schreiben:

int f(int n){
    static int originalN=0;
    if (n!=0)
        originalN=n;
    return n-originalN;
}

Answer 3

Scala :

def f(x: Any): Any = x match {
  case i: Int => new { override def hashCode = -i }
  case i @ _  => i.hashCode
}

Dasselbe gilt für Java:

public static Object f(final Object x) {
  if(x instanceof Integer) {
    return new Object() {
      @Override 
      public int hashCode() {
        return -(Integer)x;
      }
    };
  }
  return x.hashCode();
}

Answer 4

Eine weitere Javascript-Lösung, die Kurzschlüsse nutzt.

function f(n) {return n.inv || {inv:-n}}

f(f(1)) => -1
f(f(-1)) => 1

Answer 5

Ich dachte, ich versuche es mal mit dieser Frage, ohne mir vorher die Antworten anderer Leute anzusehen:

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>

int f(int n) {
    if(n > 0) {  
        if(n % 2)
            return -(++n);
        else {
            return (--n);

        }
    }
    else {
        if(n % 2)
            return -(--n);
        else {
            return (++n);

        }
    }
}

int main(int argc, char\* argv\[\]) {
    int n;
    for(n = INT\_MIN; n < INT\_MAX; n++) {
        int N = f(f(n));

        if(N != -n) {
            fprintf(stderr, "FAIL! %i != %i\\n", N, -n);
        }
    }
    n = INT\_MAX;
    int N = f(f(n));
    if(N != -n) {
        fprintf(stderr, "FAIL! n = %i\\n", n);
    }
    return 0;
}

Ausgabe: [nichts]