Merancang fungsi f (f (n)) == -n

Sebuah pertanyaan yang saya dapatkan pada wawancara terakhir saya:

Desain suatu fungsi f, sedemikian rupa sehingga:

f(f(n)) == -n

Di mana integer bertandan 32 bit ; Anda tidak dapat menggunakan aritmatika bilangan kompleks.

Jika Anda tidak dapat mendesain fungsi seperti itu untuk seluruh jajaran angka, rancanglah untuk rentang semaksimal mungkin.

Ada ide?

Bagaimana tentang:

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

Dengan 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 secara otomatis mempromosikan bilangan bulat ke panjang sewenang-wenang. Dalam bahasa lain, bilangan bulat positif terbesar akan meluap, sehingga bilangan bulat akan berfungsi untuk semua bilangan bulat kecuali yang itu.

Untuk membuatnya berfungsi untuk bilangan real, Anda harus mengganti n in (-1) ⁿ dengan { ceiling(n) if n>0; floor(n) if n<0 }.

Di C # (berfungsi untuk sembarang ganda, kecuali dalam situasi luapan):

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

Anda tidak mengatakan bahasa apa yang mereka harapkan ... Ini solusi statis (Haskell). Ini pada dasarnya mengacaukan 2 bit paling signifikan:

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

Jauh lebih mudah dalam bahasa dinamis (Python). Periksa apakah argumennya adalah angka X dan kembalikan lambda yang mengembalikan -X:

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

Berikut adalah bukti mengapa fungsi semacam itu tidak ada, untuk semua angka, jika tidak menggunakan informasi tambahan (kecuali 32 bit int):

Kita harus memiliki f (0) = 0. (Bukti: Misalkan f (0) = x. Kemudian f (x) = f (f (0)) = -0 = 0. Sekarang, -x = f (f (x (x) )) = f (0) = x, yang berarti bahwa x = 0.)

Selanjutnya, untuk apa pun xdan y, misalkan f(x) = y. Kami menginginkannya f(y) = -x. Dan f(f(y)) = -y => f(-x) = -y. Untuk meringkas: jika f(x) = y, maka f(-x) = -y, dan f(y) = -x, dan f(-y) = x.

Jadi, kita perlu membagi semua bilangan bulat kecuali 0 ke dalam set 4, tetapi kami memiliki jumlah ganjil dari bilangan bulat tersebut; tidak hanya itu, jika kita menghapus bilangan bulat yang tidak memiliki pasangan positif, kita masih memiliki 2 (mod4) angka.

Jika kita menghapus 2 angka maksimal yang tersisa (berdasarkan nilai abs), kita bisa mendapatkan fungsinya:

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

Tentu saja pilihan lain, adalah tidak mematuhi 0, dan mendapatkan 2 angka yang kami hapus sebagai bonus. (Tapi itu konyol jika.)

Berkat kelebihan muatan di 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));
}

Atau, Anda dapat menyalahgunakan preprosesor:

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

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

Ini berlaku untuk semua angka negatif.

    f (n) = abs (n)

Karena ada satu angka lebih negatif daripada angka positif untuk dua integer komplemen, f(n) = abs(n)valid untuk satu kasus lebih dari f(n) = n > 0 ? -n : nsolusi yang sama dengan f(n) = -abs(n). Punya satu per satu ...: D

MEMPERBARUI

Tidak, itu tidak berlaku untuk satu kasus lagi karena saya baru saja dikenali oleh komentar litb ... abs(Int.Min)hanya akan meluap ...

Saya berpikir tentang menggunakan informasi mod 2 juga, tetapi menyimpulkan, itu tidak berfungsi ... untuk awal. Jika dilakukan dengan benar, ini akan berfungsi untuk semua angka kecuali Int.Minkarena ini akan meluap.

MEMPERBARUI

Saya bermain dengannya sebentar, mencari trik manipulasi bit yang bagus, tetapi saya tidak dapat menemukan satu-liner yang bagus, sedangkan solusi mod 2 cocok untuk satu.

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

Di C #, ini menjadi yang berikut:

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

Untuk membuatnya berfungsi untuk semua nilai, Anda harus mengganti Math.Abs()dengan (n > 0) ? +n : -ndan memasukkan perhitungan dalam satu uncheckedblok. Kemudian Anda bahkan Int.Mindipetakan ke dirinya sendiri seperti halnya negasi yang tidak terkendali.

MEMPERBARUI

Terinspirasi oleh jawaban lain saya akan menjelaskan bagaimana fungsi bekerja dan bagaimana membangun fungsi seperti itu.

Mari kita mulai dari awal. Fungsi fini berulang kali diterapkan pada nilai yang diberikan nmenghasilkan urutan nilai.

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

Pertanyaannya menuntut f(f(n)) = -n, yaitu dua aplikasi berturut-turut fmeniadakan argumen. Dua aplikasi lebih lanjut dari f- total empat - meniadakan argumen lagi menghasilkan nlagi.

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

Sekarang ada siklus panjang empat yang jelas. Mengganti x = f(n)dan mencatat bahwa persamaan yang diperoleh f(f(f(n))) = f(f(x)) = -xberlaku, menghasilkan yang berikut.

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

Jadi kita mendapatkan siklus panjang empat dengan dua angka dan dua angka dinegasikan. Jika Anda membayangkan siklus sebagai persegi panjang, nilai yang dinegasikan terletak di sudut yang berlawanan.

Salah satu solusi untuk membangun siklus seperti itu adalah yang berikut dimulai dari n.

 n => meniadakan dan kurangi satu
-n - 1 = - (n +1) => tambahkan satu
-n => negate dan tambahkan satu
 n +1 => kurangi satu
 n

Contoh konkret dari siklus semacam itu adalah +1 => -2 => -1 => +2 => +1. Kami hampir selesai. Memperhatikan bahwa siklus yang dikonstruksi mengandung bilangan positif ganjil, bahkan penggantinya, dan kedua bilangan tersebut meniadakan, kita dapat dengan mudah mempartisi bilangan bulat menjadi banyak siklus semacam itu ( 2^32merupakan kelipatan empat) dan telah menemukan fungsi yang memenuhi kondisi.

Tetapi kami memiliki masalah dengan nol. Siklus harus mengandung 0 => x => 0karena nol dinegasikan ke dirinya sendiri. Dan karena siklus menyatakan sudah 0 => xmengikuti 0 => x => 0 => x. Ini hanya siklus panjang dua dan xdiubah menjadi dirinya sendiri setelah dua aplikasi, bukan menjadi -x. Untungnya ada satu kasus yang menyelesaikan masalah. Jika Xsama dengan nol kita memperoleh siklus panjang yang hanya mengandung nol dan kita memecahkan masalah itu dengan menyimpulkan bahwa nol adalah titik tetap f.

Selesai? Hampir. Kami memiliki 2^32angka, nol adalah angka tetap yang meninggalkan titik 2^32 - 1, dan kami harus mempartisi angka itu menjadi siklus empat angka. Buruk itu 2^32 - 1bukan kelipatan empat - akan tetap ada tiga angka tidak dalam siklus dengan panjang empat.

Saya akan menjelaskan bagian yang tersisa dari solusi menggunakan set yang lebih kecil dari 3 bit yang ditandatangani mulai dari -4ke +3. Kita selesai dengan nol. Kami memiliki satu siklus lengkap +1 => -2 => -1 => +2 => +1. Sekarang mari kita buat siklus mulai dari +3.

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

Masalah yang muncul adalah yang +4tidak direpresentasikan sebagai integer 3 bit. Kami akan memperoleh +4dengan meniadakan -3ke +3- apa yang masih merupakan integer 3 bit yang valid - tetapi kemudian menambahkan satu ke +3(biner 011) menghasilkan 100biner. Ditafsirkan sebagai bilangan bulat yang tidak ditandatangani, +4tetapi kita harus menafsirkannya sebagai bilangan bulat yang ditandatangani -4. Jadi sebenarnya -4untuk contoh ini atau Int.MinValuedalam kasus umum adalah titik tetap kedua negasi aritmatika bilangan bulat - 0 dan Int.MinValuedipetakan ke mereka sendiri. Jadi siklusnya sebenarnya sebagai berikut.

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

Ini adalah siklus dengan panjang dua dan juga +3memasuki siklus melalui -4. Karena -4itu dipetakan dengan benar ke dirinya sendiri setelah dua aplikasi fungsi, +3dipetakan dengan benar ke -3setelah dua aplikasi fungsi, tetapi -3dipetakan secara keliru ke dirinya sendiri setelah dua aplikasi fungsi.

Jadi kami membangun fungsi yang bekerja untuk semua bilangan bulat kecuali satu. Bisakah kita berbuat lebih baik? Tidak, kita tidak bisa. Mengapa? Kita harus membuat siklus dengan panjang empat dan mampu mencakup seluruh rentang integer hingga empat nilai. Nilai yang tersisa adalah dua titik tetap 0dan Int.MinValueyang harus dipetakan untuk diri mereka sendiri dan dua bilangan bulat sewenang-wenang xdan -xyang harus dipetakan satu sama lain oleh dua aplikasi fungsi.

Untuk memetakan xke -xdan sebaliknya mereka harus membentuk empat siklus dan mereka harus berada di sudut yang berlawanan dari siklus itu. Karena itu 0dan Int.MinValueharus berada di sudut yang berlawanan juga. Ini akan memetakan dengan benar xdan -xtetapi menukar dua titik tetap 0dan Int.MinValuesetelah dua aplikasi fungsi dan meninggalkan kita dengan dua input yang gagal. Jadi tidak mungkin untuk membangun fungsi yang bekerja untuk semua nilai, tetapi kami memiliki satu yang berfungsi untuk semua nilai kecuali satu dan ini adalah yang terbaik yang bisa kami capai.

Menggunakan bilangan kompleks, Anda dapat secara efektif membagi tugas meniadakan angka menjadi dua langkah:

• kalikan n dengan i, dan Anda mendapatkan n * i, yang diputar 90 ° berlawanan arah jarum jam
• kalikan lagi dengan saya, dan Anda mendapatkan -n

Yang hebat adalah Anda tidak memerlukan kode penanganan khusus. Hanya mengalikan dengan saya melakukan pekerjaan.

Tapi Anda tidak diizinkan menggunakan angka kompleks. Jadi Anda harus entah bagaimana membuat sumbu imajiner Anda sendiri, menggunakan bagian dari rentang data Anda. Karena Anda membutuhkan nilai imajiner (menengah) persis seperti nilai awal, Anda hanya memiliki separuh rentang data.

Saya mencoba memvisualisasikan ini pada gambar berikut, dengan asumsi data 8-bit yang ditandatangani. Anda harus skala ini untuk bilangan bulat 32-bit. Kisaran yang diizinkan untuk awal n adalah -64 hingga +63. Inilah yang fungsinya untuk n positif:

• Jika n ada di 0..63 (rentang awal), pemanggilan fungsi menambah 64, memetakan n ke kisaran 64..127 (rentang menengah)
• Jika n berada di 64..127 (rentang menengah), fungsi mengurangi n dari 64, memetakan n ke kisaran 0 ..- 63

Untuk n negatif, fungsi ini menggunakan rentang menengah -65 ..- 128.

Berfungsi kecuali int.MaxValue dan 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));
    }

Pertanyaannya tidak mengatakan apa-apa tentang apa jenis input dan nilai balik fungsi fharus (setidaknya bukan cara Anda mempresentasikannya) ...

... Hanya saja ketika n adalah bilangan bulat 32-bit lalu f(f(n)) = -n

Jadi, bagaimana dengan sesuatu seperti

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

Jika n adalah bilangan bulat 32-bit maka pernyataan itu f(f(n)) == -nakan benar.

Jelas, pendekatan ini dapat diperluas untuk bekerja untuk rentang nomor yang lebih luas ...

untuk javascript (atau bahasa yang diketik secara dinamis lainnya) Anda dapat memiliki fungsi menerima int atau objek dan mengembalikan yang lain. yaitu

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

memberi

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

atau Anda dapat menggunakan overloading dalam bahasa yang sangat diketik meskipun itu bisa melanggar aturan yaitu

int f(long n) {
    return n;
}

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

Bergantung pada platform Anda, beberapa bahasa memungkinkan Anda menjaga status dalam fungsi. VB.Net, misalnya:

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

    Return n * flag
End Function

IIRC, C ++ mengizinkan ini juga. Saya curiga mereka mencari solusi yang berbeda.

Gagasan lain adalah karena mereka tidak menentukan hasil dari panggilan pertama ke fungsi, Anda bisa menggunakan keanehan untuk mengontrol apakah akan membalikkan tanda:

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

Tambahkan satu ke besarnya semua angka genap, kurangi satu dari besarnya semua angka ganjil. Hasil dari dua panggilan memiliki besaran yang sama, tetapi satu panggilan di mana itu bahkan kita menukar tandanya. Ada beberapa kasus di mana ini tidak akan berhasil (-1, maks atau int min), tetapi ini bekerja jauh lebih baik daripada apa pun yang disarankan sejauh ini.

Memanfaatkan pengecualian JavaScript.

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

f(f(0)) => 0

f(f(1)) => -1

Untuk semua nilai 32-bit (dengan peringatan bahwa -0 adalah -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);
}

Anda pada dasarnya perlu memasangkan setiap -x => x => -x loop dengan ay => -y => y loop. Jadi saya memasangkan sisi yang berlawanan split.

mis. Untuk bilangan bulat 4 bit:

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

Versi C ++, mungkin sedikit menekuk aturan tetapi berfungsi untuk semua tipe numerik (float, ints, doubles) dan bahkan tipe kelas yang membebani minus unary:

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

Kode diperiksa, semua bilangan bulat 32bit yang mungkin terlewati, kesalahan dengan -2147483647 (underflow).

Menggunakan global ... tapi begitu?

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

Solusi Perl ini berfungsi untuk bilangan bulat, pelampung, dan string .

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

Coba beberapa data uji.

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

Keluaran:

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

Tidak ada yang pernah mengatakan f (x) harus bertipe sama.

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


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

Saya tidak benar-benar mencoba memberikan solusi untuk masalah itu sendiri, tetapi memiliki beberapa komentar, karena pertanyaan menyatakan masalah ini diajukan adalah bagian dari wawancara (pekerjaan?):

• Pertama-tama saya akan bertanya, "Mengapa fungsi seperti itu dibutuhkan? Apa masalah yang lebih besar dari ini?" alih-alih mencoba memecahkan masalah yang ditimbulkan langsung di tempat. Ini menunjukkan bagaimana saya berpikir dan bagaimana saya mengatasi masalah seperti ini. Siapa tau? Itu bahkan mungkin menjadi alasan sebenarnya pertanyaan itu ditanyakan dalam sebuah wawancara. Jika jawabannya "Tidak apa-apa, anggap itu perlu, dan tunjukkan kepada saya bagaimana Anda akan merancang fungsi ini." Saya kemudian akan terus melakukannya.
• Kemudian, saya akan menulis kode kasus uji C # yang akan saya gunakan (yang jelas: loop dari int.MinValueke int.MaxValue, dan untuk masing-masing ndalam rentang panggilan f(f(n))dan memeriksa hasilnya -n), mengatakan saya kemudian akan menggunakan Test Driven Development untuk mendapatkan fungsi seperti itu.
• Hanya jika pewawancara terus meminta saya untuk menyelesaikan masalah yang diajukan, saya benar-benar akan mulai mencoba dan mencoret kode semu selama wawancara itu sendiri untuk mencoba dan mendapatkan semacam jawaban. Namun, saya tidak benar-benar berpikir saya akan melompat untuk mengambil pekerjaan itu jika pewawancara akan menjadi indikasi seperti apa perusahaan itu ...

Oh, jawaban ini menganggap wawancara itu untuk posisi terkait pemrograman C #. Tentu saja akan menjadi jawaban yang konyol jika wawancara itu untuk posisi terkait matematika. ;-)

Saya akan Anda mengubah 2 bit paling signifikan.

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

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

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

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

Seperti yang Anda lihat, itu hanya tambahan, meninggalkan bit yang dibawa.

Bagaimana saya mendapat jawaban? Pikiran pertama saya hanyalah kebutuhan akan simetri. 4 putaran untuk kembali ke tempat saya mulai. Pada awalnya saya pikir, itu kode 2bits Gray. Lalu saya pikir sebenarnya biner standar sudah cukup.

Berikut adalah solusi yang terinspirasi oleh persyaratan atau klaim bahwa bilangan kompleks tidak dapat digunakan untuk menyelesaikan masalah ini.

Mengalikan dengan akar kuadrat dari -1 adalah sebuah ide, yang sepertinya gagal karena -1 tidak memiliki akar kuadrat di atas bilangan bulat. Tetapi bermain-main dengan program seperti Mathematica memberi misalnya persamaan

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

dan ini hampir sama baiknya dengan memiliki akar kuadrat dari -1. Hasil dari fungsi harus berupa bilangan bulat yang ditandatangani. Oleh karena itu saya akan menggunakan mod operasi modulo yang dimodifikasi (x, n) yang mengembalikan integer y kongruen ke x modulo n yang paling dekat dengan 0. Hanya sedikit bahasa pemrograman yang memiliki operasi modulo, tetapi dapat dengan mudah didefinisikan . Misalnya dalam python adalah:

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

Menggunakan persamaan di atas, masalah sekarang dapat diselesaikan sebagai

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

Ini memuaskan f(f(x)) = -xuntuk semua bilangan bulat dalam jangkauan . Hasil dari juga dalam kisaran ini, tetapi tentu saja perhitungan akan membutuhkan bilangan bulat 64-bit.[-231-2, 231-2]f(x)

C # untuk rentang 2 ^ 32 - 1 angka, semua nomor int32 kecuali (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

cetakan:

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

Pada dasarnya fungsi harus membagi rentang yang tersedia menjadi siklus ukuran 4, dengan -n di ujung siklus n. Namun, 0 harus menjadi bagian dari siklus ukuran 1, karena jika tidak0->x->0->x != -x . Karena 0 sendirian, harus ada 3 nilai lain dalam rentang kami (yang ukurannya merupakan kelipatan 4) tidak dalam siklus yang tepat dengan 4 elemen.

Saya memilih nilai-nilai ekstra aneh ini menjadi MIN_INT, MAX_INT, dan MIN_INT+1. Selanjutnya, MIN_INT+1akan memetakan dengan MAX_INTbenar, tetapi terjebak di sana dan tidak memetakan kembali. Saya pikir ini adalah kompromi terbaik, karena ia hanya memiliki properti bagus dari nilai-nilai ekstrem yang tidak berfungsi dengan benar. Juga, itu berarti itu akan bekerja untuk semua 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)

Tidak ada yang mengatakan itu harus tanpa kewarganegaraan.

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

Curang, tapi tidak sebanyak contoh. Yang lebih jahat adalah dengan mengintip tumpukan untuk melihat apakah alamat pemanggil Anda adalah & f, tetapi ini akan menjadi lebih portabel (meskipun bukan utas aman ... versi utas aman akan menggunakan TLS). Yang lebih jahat:

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

Tentu saja, tak satu pun dari ini bekerja dengan baik untuk kasus MIN_INT32, tetapi ada sedikit yang berharga yang dapat Anda lakukan tentang hal itu kecuali Anda diizinkan untuk mengembalikan tipe yang lebih luas.

Saya bisa membayangkan menggunakan bit ke-31 sebagai bit imajiner ( i ) akan menjadi pendekatan yang akan mendukung setengah rentang total.

bekerja untuk 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
}

Masalahnya menyatakan "integer bertanda 32-bit" tetapi tidak menentukan apakah keduanya komplemen dua atau satu .

Jika Anda menggunakan komplemen satu maka semua nilai 2 ^ 32 terjadi dalam siklus dengan panjang empat - Anda tidak memerlukan kasing khusus untuk nol, dan Anda juga tidak memerlukan persyaratan.

Dalam C:

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

Ini bekerja dengan

1. Saling menukar blok 16-bit tinggi dan rendah
2. Menghindari salah satu blok

Setelah dua lintasan kami memiliki bitwise kebalikan dari nilai aslinya. Yang dalam representasi satu komplemen sama dengan negasi.

Contoh:

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

Saya ingin berbagi pandangan saya tentang masalah menarik ini sebagai ahli matematika. Saya pikir saya punya solusi paling efisien.

Jika saya ingat dengan benar, Anda meniadakan integer 32-bit yang ditandatangani dengan hanya membalik bit pertama. Misalnya, jika n = 1001 1101 1110 1011 1110 0000 1110 1010, maka -n = 0001 1101 1110 1011 1110 0000 1110 1010.

Jadi bagaimana kita mendefinisikan fungsi f yang mengambil bilangan bulat 32-bit yang ditandatangani dan mengembalikan bilangan bulat 32-bit lainnya dengan properti yang mengambil f dua kali sama dengan membalik bit pertama?

Biarkan saya ulangi pertanyaannya tanpa menyebutkan konsep aritmatika seperti bilangan bulat.

Bagaimana kita mendefinisikan fungsi f yang mengambil urutan nol dan yang panjang 32 dan mengembalikan urutan nol dan yang sama panjang, dengan properti yang mengambil f dua kali sama dengan membalik bit pertama?

Pengamatan: Jika Anda dapat menjawab pertanyaan di atas untuk kasing 32 bit, maka Anda juga dapat menjawab kasing 64 bit, kasing 100 bit, dll. Anda tinggal menerapkan f ke bit 32 pertama.

Sekarang jika Anda dapat menjawab pertanyaan untuk case 2 bit, Voila!

Dan ya ternyata mengubah 2 bit pertama sudah cukup.

Ini kode semu

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.

Catatan: Langkah 2 dan langkah 3 bersama-sama dapat disingkat sebagai (a, b) -> (-b, a). Terlihat tidak asing? Itu akan mengingatkan Anda tentang rotasi 90 derajat pesawat dan perkalian dengan akar kuadrat dari -1.

Jika saya hanya menyajikan pseudo-code saja tanpa pembuka yang lama, itu akan terlihat seperti kelinci, saya ingin menjelaskan bagaimana saya mendapatkan solusinya.