Hàm thiết kế f (f (n)) == -n

Một câu hỏi tôi nhận được trong cuộc phỏng vấn cuối cùng của mình:

Thiết kế một chức năng f, sao cho:

f(f(n)) == -n

Số nguyên kýn 32 bit ở đâu ; bạn không thể sử dụng số học số phức.

Nếu bạn không thể thiết kế một hàm như vậy cho toàn bộ phạm vi số, hãy thiết kế nó cho phạm vi lớn nhất có thể.

Có ý kiến ​​gì không?

Làm thế nào về:

f (n) = dấu (n) - (-1) n * n

Trong 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 tự động thúc đẩy các số nguyên cho độ dài tùy ý. Trong các ngôn ngữ khác, số nguyên dương lớn nhất sẽ tràn, vì vậy nó sẽ hoạt động cho tất cả các số nguyên ngoại trừ số nguyên đó.

Để làm cho nó hoạt động với số thực, bạn cần thay n trong (-1) ⁿ bằng { ceiling(n) if n>0; floor(n) if n<0 }.

Trong C # (hoạt động cho mọi gấp đôi, ngoại trừ trong các tình huống tràn):

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

Bạn đã không nói loại ngôn ngữ nào họ mong đợi ... Đây là một giải pháp tĩnh (Haskell). Về cơ bản, nó gây rối với 2 bit quan trọng nhất:

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

Nó dễ dàng hơn nhiều trong một ngôn ngữ động (Python). Chỉ cần kiểm tra xem đối số có phải là số X không và trả về lambda trả về -X:

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

Đây là một bằng chứng về lý do tại sao một hàm như vậy không thể tồn tại, đối với tất cả các số, nếu nó không sử dụng thêm thông tin (ngoại trừ 32 bit của int):

Ta phải có f (0) = 0. (Chứng minh: Giả sử f (0) = x. Sau đó f (x) = f (f (0)) = -0 = 0. Bây giờ, -x = f (f (x (x (x) )) = f (0) = x, có nghĩa là x = 0.)

Hơn nữa, cho bất kỳ xvà y, giả sử f(x) = y. Chúng tôi muốn f(y) = -xsau đó. Và f(f(y)) = -y => f(-x) = -y. Để tóm tắt: nếu f(x) = y, sau đó f(-x) = -y, và f(y) = -x, và f(-y) = x.

Vì vậy, chúng ta cần chia tất cả các số nguyên trừ 0 thành các bộ 4, nhưng chúng ta có một số lẻ các số nguyên như vậy; không chỉ vậy, nếu chúng ta loại bỏ số nguyên không có đối tác dương, chúng ta vẫn có 2 (mod4).

Nếu chúng ta loại bỏ 2 số tối đa còn lại (theo giá trị abs), chúng ta có thể nhận được hàm:

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

Tất nhiên, một lựa chọn khác, là không tuân thủ 0 và lấy 2 số mà chúng tôi đã xóa làm phần thưởng. (Nhưng đó chỉ là một sự ngớ ngẩn nếu.)

Nhờ quá tải trong 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));
}

Hoặc, bạn có thể lạm dụng bộ tiền xử lý:

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

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

Điều này đúng với tất cả các số âm.

    f (n) = abs (n)

Bởi vì có một số âm nhiều hơn số dương cho các số nguyên bổ sung twos, nên f(n) = abs(n)có giá trị cho một trường hợp nhiều hơn so với f(n) = n > 0 ? -n : ngiải pháp giống như f(n) = -abs(n). Có bạn bởi một ...: D

CẬP NHẬT

Không, nó không hợp lệ cho một trường hợp nữa vì tôi vừa nhận ra bằng nhận xét của litb ... abs(Int.Min)sẽ chỉ tràn ...

Tôi cũng nghĩ về việc sử dụng thông tin mod 2, nhưng kết luận, nó không hoạt động ... sớm. Nếu được thực hiện đúng, nó sẽ hoạt động cho tất cả các số trừ Int.Minvì điều này sẽ tràn.

CẬP NHẬT

Tôi đã chơi với nó một lúc, tìm kiếm một mẹo thao tác bit đẹp, nhưng tôi không thể tìm thấy một lớp lót đẹp, trong khi giải pháp mod 2 phù hợp với một.

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

Trong C #, điều này trở thành như sau:

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

Để làm cho nó làm việc cho tất cả các giá trị, bạn phải thay thế Math.Abs()với (n > 0) ? +n : -nvà bao gồm việc tính toán trong một uncheckedkhối. Sau đó, bạn thậm chí Int.Minđược ánh xạ tới chính nó như phủ định không được kiểm soát.

CẬP NHẬT

Lấy cảm hứng từ một câu trả lời khác tôi sẽ giải thích cách thức hoạt động của chức năng và cách xây dựng một chức năng như vậy.

Hãy bắt đầu ngay từ đầu. Hàm fnày được lặp đi lặp lại cho một giá trị nhất định nmang lại một chuỗi các giá trị.

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

Câu hỏi đòi hỏi f(f(n)) = -n, đó là hai ứng dụng liên tiếp fphủ định lập luận. Hai ứng dụng nữa của f- tổng cộng bốn - phủ nhận lại lập luận một nlần nữa.

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

Bây giờ có một chu kỳ rõ ràng của chiều dài bốn. Thay thế x = f(n)và lưu ý rằng phương trình thu được f(f(f(n))) = f(f(x)) = -xgiữ, mang lại kết quả như sau.

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

Vì vậy, chúng ta có được một chu kỳ có độ dài bốn với hai số và hai số bị phủ định. Nếu bạn tưởng tượng chu trình là một hình chữ nhật, các giá trị phủ định được đặt ở các góc đối diện.

Một trong nhiều giải pháp để xây dựng một chu trình như vậy là sau đây bắt đầu từ n.

 n => phủ định và trừ đi một
-n - 1 = - (n + 1) => thêm một
-n => phủ nhận và thêm một
 n + 1 => trừ đi một
 n

Một ví dụ cụ thể là của một chu kỳ như vậy +1 => -2 => -1 => +2 => +1. Chúng ta đang gần hoàn tất. Lưu ý rằng chu trình được xây dựng chứa một số dương lẻ, kế tiếp của nó và cả hai số đều phủ định, chúng ta có thể dễ dàng phân chia các số nguyên thành nhiều chu kỳ như vậy ( 2^32là bội số của bốn) và đã tìm thấy một hàm thỏa mãn các điều kiện.

Nhưng chúng tôi có một vấn đề với số không. Chu trình phải chứa 0 => x => 0bởi vì số 0 được phủ định cho chính nó. Và bởi vì các trạng thái chu kỳ đã 0 => xtheo sau nó 0 => x => 0 => x. Đây chỉ là một chu kỳ có độ dài hai và xđược biến thành chính nó sau hai ứng dụng, không phải vào -x. May mắn thay, có một trường hợp giải quyết vấn đề. Nếu Xbằng 0, chúng ta có được một chu kỳ có độ dài chỉ bằng 0 và chúng ta đã giải quyết vấn đề đó kết luận rằng số 0 là một điểm cố định f.

Làm xong? Hầu hết. Chúng ta có các 2^32số, số 0 là một điểm cố định để lại các 2^32 - 1số và chúng ta phải phân chia số đó thành các chu kỳ gồm bốn số. Xấu 2^32 - 1không phải là bội số của bốn - sẽ vẫn còn ba số không thuộc bất kỳ chu kỳ nào có độ dài bốn.

Tôi sẽ giải thích phần còn lại của giải pháp bằng cách sử dụng tập hợp nhỏ hơn 3 bit có chữ ký khác nhau từ -4đến +3. Chúng tôi được thực hiện với số không. Chúng tôi có một chu kỳ hoàn chỉnh +1 => -2 => -1 => +2 => +1. Bây giờ hãy để chúng tôi xây dựng chu kỳ bắt đầu từ +3.

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

Vấn đề phát sinh +4là không thể biểu diễn dưới dạng số nguyên 3 bit. Chúng tôi sẽ có được +4bằng cách phủ nhận -3đến +3- những gì vẫn còn là một chút 3 số nguyên hợp lệ - nhưng sau đó thêm một đến +3(nhị phân 011) mang 100nhị phân. Được hiểu là số nguyên không dấu +4nhưng chúng ta phải hiểu nó là số nguyên đã ký -4. Vì vậy, thực sự -4cho ví dụ này hoặc Int.MinValuetrong trường hợp chung là một điểm cố định thứ hai của phủ định số học số nguyên - 0 và Int.MinValueđược ánh xạ tới themselve. Vì vậy, chu kỳ thực sự là như sau.

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

Đó là một chu kỳ có độ dài hai và thêm +3vào chu kỳ thông qua -4. Do đó, -4ánh xạ chính xác đến chính nó sau hai ứng dụng chức năng, +3được ánh xạ chính xác đến -3sau hai ứng dụng chức năng, nhưng -3được ánh xạ nhầm sang chính nó sau hai ứng dụng chức năng.

Vì vậy, chúng tôi đã xây dựng một hàm hoạt động cho tất cả các số nguyên trừ một số nguyên. Chúng ta có thể làm tốt hơn không? Không chúng tôi không thể. Tại sao? Chúng ta phải xây dựng các chu kỳ có độ dài bốn và có thể bao phủ toàn bộ phạm vi số nguyên lên đến bốn giá trị. Các giá trị còn lại là hai điểm cố định 0và Int.MinValuephải được ánh xạ tới chính chúng và hai số nguyên tùy ý xvà -xphải được ánh xạ với nhau bởi hai ứng dụng chức năng.

Để ánh xạ xtới -xvà ngược lại, chúng phải tạo thành một chu kỳ bốn và chúng phải được đặt ở các góc đối diện của chu kỳ đó. Trong hậu quả 0và Int.MinValuephải ở các góc đối diện, quá. Điều này sẽ ánh xạ chính xác xvà -xnhưng trao đổi hai điểm cố định 0và Int.MinValuesau hai ứng dụng chức năng và để lại cho chúng tôi hai đầu vào không thành công. Vì vậy, không thể xây dựng một hàm hoạt động cho tất cả các giá trị, nhưng chúng ta có một hàm hoạt động cho tất cả các giá trị ngoại trừ một giá trị và đây là cách tốt nhất chúng ta có thể đạt được.

Sử dụng các số phức, bạn có thể phân chia hiệu quả nhiệm vụ phủ định một số thành hai bước:

• nhân n với i và bạn nhận được n * i, được n quay 90 ° ngược chiều kim đồng hồ
• nhân lại với tôi và bạn nhận được -n

Điều tuyệt vời là bạn không cần bất kỳ mã xử lý đặc biệt nào. Chỉ cần nhân với tôi làm công việc.

Nhưng bạn không được phép sử dụng số phức. Vì vậy, bạn phải bằng cách nào đó tạo trục ảo của riêng mình, sử dụng một phần của phạm vi dữ liệu của bạn. Vì bạn cần chính xác nhiều giá trị tưởng tượng (trung gian) như các giá trị ban đầu, nên bạn chỉ còn lại một nửa phạm vi dữ liệu.

Tôi đã cố gắng hình dung điều này trên hình dưới đây, giả sử dữ liệu 8 bit đã ký. Bạn sẽ phải chia tỷ lệ này cho số nguyên 32 bit. Phạm vi được phép cho n ban đầu là -64 đến +63. Đây là những gì chức năng làm cho tích cực n:

• Nếu n ở 0..63 (phạm vi ban đầu), lệnh gọi hàm thêm 64, ánh xạ n vào phạm vi 64..127 (phạm vi trung gian)
• Nếu n nằm trong 64..127 (phạm vi trung gian), hàm sẽ trừ n từ 64, ánh xạ n đến phạm vi 0 ..- 63

Đối với n âm, hàm sử dụng phạm vi trung gian -65 ..- 128.

Hoạt động ngoại trừ int.MaxValue và 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));
    }

Câu hỏi không nói gì về loại đầu vào và giá trị trả về của hàm fphải là gì (ít nhất không phải là cách bạn đã trình bày) ...

... chỉ là khi n là số nguyên 32 bit thì f(f(n)) = -n

Vì vậy, làm thế nào về một cái gì đó như

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

Nếu n là số nguyên 32 bit thì câu lệnh f(f(n)) == -nsẽ đúng.

Rõ ràng, cách tiếp cận này có thể được mở rộng để hoạt động cho một phạm vi số rộng hơn nữa ...

đối với javascript (hoặc các ngôn ngữ được nhập động khác), bạn có thể có chức năng chấp nhận một int hoặc một đối tượng và trả về đối tượng kia. I E

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

cho

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

cách khác, bạn có thể sử dụng quá tải trong một ngôn ngữ được gõ mạnh mặc dù điều đó có thể phá vỡ các quy tắc tức là

int f(long n) {
    return n;
}

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

Tùy thuộc vào nền tảng của bạn, một số ngôn ngữ cho phép bạn giữ trạng thái trong chức năng. VB.Net, ví dụ:

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

    Return n * flag
End Function

IIRC, C ++ cũng cho phép điều này. Tôi nghi ngờ họ đang tìm kiếm một giải pháp khác nhau mặc dù.

Một ý tưởng khác là vì họ không xác định kết quả của cuộc gọi đầu tiên đến chức năng, bạn có thể sử dụng số lẻ / chẵn để kiểm soát xem có đảo ngược dấu hiệu hay không:

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

Thêm một vào độ lớn của tất cả các số chẵn, trừ đi một từ độ lớn của tất cả các số lẻ. Kết quả của hai cuộc gọi có cùng độ lớn, nhưng cuộc gọi mà ngay cả khi chúng ta trao đổi ký hiệu. Có một số trường hợp điều này sẽ không hoạt động (-1, max hoặc min int), nhưng nó hoạt động tốt hơn nhiều so với bất kỳ điều gì khác được đề xuất cho đến nay.

Khai thác ngoại lệ JavaScript.

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

f(f(0)) => 0

f(f(1)) => -1

Đối với tất cả các giá trị 32 bit (với cảnh báo -0 là -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);
}

Về cơ bản, bạn cần ghép từng vòng lặp -x => x => -x với vòng lặp ay => -y => y. Vì vậy, tôi bắt cặp đối diện của split.

ví dụ: Đối với số nguyên 4 bit:

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

Một phiên bản C ++, có thể bẻ cong các quy tắc một chút nhưng hoạt động cho tất cả các loại số (float, ints, double) và thậm chí các loại lớp làm quá tải phép trừ 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 (kiểu 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

Đã kiểm tra mã, tất cả các số nguyên 32 bit có thể được thông qua, lỗi với -2147483647 (tràn).

Sử dụng toàn cầu ... nhưng vì vậy?

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

Giải pháp Perl này hoạt động cho số nguyên, số float và chuỗi .

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

Hãy thử một số dữ liệu thử nghiệm.

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

Đầu ra:

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

Không ai từng nói f (x) phải cùng loại.

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


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

Tôi thực sự không cố gắng đưa ra giải pháp cho vấn đề, nhưng có một vài ý kiến, vì câu hỏi nêu vấn đề này được đặt ra là một phần của một cuộc phỏng vấn (công việc?):

• Trước tiên tôi sẽ hỏi "Tại sao một chức năng như vậy lại cần thiết? Vấn đề lớn hơn đây là một phần của cái gì?" thay vì cố gắng giải quyết vấn đề đặt ra thực tế tại chỗ. Điều này cho thấy cách tôi suy nghĩ và cách tôi giải quyết các vấn đề như thế này. Ai biết? Đó thậm chí có thể là lý do thực sự của câu hỏi được hỏi trong một cuộc phỏng vấn ở nơi đầu tiên. Nếu câu trả lời là "Không bao giờ bạn bận tâm, giả sử nó cần thiết và chỉ cho tôi cách bạn sẽ thiết kế chức năng này." Sau đó tôi sẽ tiếp tục làm như vậy.
• Sau đó, tôi sẽ viết C # test mã tôi sẽ sử dụng (điều hiển nhiên: vòng lặp từ int.MinValueđể int.MaxValue, và đối với từng nở chỗ gọi phạm vi f(f(n))và kiểm tra kết quả là -n), nói sau đó tôi sẽ sử dụng Test Driven Development để có được một chức năng như vậy.
• Chỉ khi người phỏng vấn tiếp tục yêu cầu tôi giải quyết vấn đề đặt ra, tôi mới thực sự bắt đầu thử và viết nguệch ngoạc trong suốt cuộc phỏng vấn để thử và đưa ra một câu trả lời. Tuy nhiên, tôi không thực sự nghĩ rằng tôi sẽ nhảy việc để nhận công việc nếu người phỏng vấn sẽ là bất kỳ dấu hiệu nào cho thấy công ty giống như thế nào ...

Ồ, câu trả lời này giả định rằng cuộc phỏng vấn dành cho vị trí liên quan đến lập trình C #. Tất nhiên sẽ là một câu trả lời ngớ ngẩn nếu cuộc phỏng vấn dành cho một vị trí liên quan đến toán học. ;-)

Tôi sẽ thay đổi 2 bit quan trọng nhất.

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

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

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

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

Như bạn có thể thấy, nó chỉ là một bổ sung, bỏ đi phần mang theo.

Làm thế nào tôi có câu trả lời? Suy nghĩ đầu tiên của tôi chỉ là sự cần thiết cho sự đối xứng. 4 lượt để quay lại nơi tôi bắt đầu. Lúc đầu tôi nghĩ, đó là 2 bit mã Gray. Sau đó, tôi nghĩ rằng thực sự nhị phân tiêu chuẩn là đủ.

Đây là một giải pháp được lấy cảm hứng từ yêu cầu hoặc tuyên bố rằng các số phức không thể được sử dụng để giải quyết vấn đề này.

Nhân với căn bậc hai của -1 là một ý tưởng, điều đó dường như chỉ thất bại vì -1 không có căn bậc hai trên các số nguyên. Nhưng chơi xung quanh với một chương trình như mathicala chẳng hạn, cho phương trình

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

và điều này gần như là có căn bậc hai của -1. Kết quả của hàm cần phải là một số nguyên đã ký. Do đó tôi sẽ sử dụng một mod hoạt động modulo đã sửa đổi (x, n) trả về số nguyên y đồng dạng với x modulo n gần nhất với 0. Chỉ có rất ít ngôn ngữ lập trình có hoạt động modulo, nhưng có thể dễ dàng xác định nó . Ví dụ, trong python, nó là:

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

Sử dụng phương trình trên, vấn đề bây giờ có thể được giải quyết như

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

Điều này thỏa mãn f(f(x)) = -xcho tất cả các số nguyên trong phạm vi . Kết quả cũng nằm trong phạm vi này, nhưng tất nhiên việc tính toán sẽ cần các số nguyên 64 bit.[-231-2, 231-2]f(x)

C # cho phạm vi 2 ^ 32 - 1 số, tất cả các số int32 ngoại trừ (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

in:

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

Về cơ bản, hàm phải chia phạm vi khả dụng thành các chu kỳ có kích thước 4, với -n ở cuối đối diện của chu kỳ n. Tuy nhiên, 0 phải là một phần của chu kỳ kích thước 1, vì nếu không0->x->0->x != -x . Do 0 ở một mình, nên có 3 giá trị khác trong phạm vi của chúng tôi (có kích thước là bội số của 4) không theo một chu kỳ thích hợp với 4 phần tử.

Tôi chọn những giá trị lạ thêm được MIN_INT, MAX_INT, và MIN_INT+1. Hơn nữa, MIN_INT+1sẽ ánh xạ MAX_INTchính xác, nhưng bị mắc kẹt ở đó và không ánh xạ trở lại. Tôi nghĩ rằng đây là sự thỏa hiệp tốt nhất, bởi vì nó có thuộc tính tốt đẹp chỉ có các giá trị cực đoan không hoạt động chính xác. Ngoài ra, nó có nghĩa là nó sẽ hoạt động cho tất cả các BigInt.

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)

Không ai nói nó phải không quốc tịch.

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

Gian lận, nhưng không nhiều như nhiều ví dụ. Thậm chí còn tệ hơn là nhìn trộm ngăn xếp để xem địa chỉ của người gọi của bạn có phải là & f hay không, nhưng điều này sẽ dễ mang theo hơn (mặc dù không an toàn cho luồng ... phiên bản an toàn luồng sẽ sử dụng TLS). Thậm chí còn ác hơn:

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

Tất nhiên, cả hai cách này đều không hoạt động tốt cho trường hợp MIN_INT32, nhưng có rất ít thứ bạn có thể làm về điều đó trừ khi bạn được phép trả lại loại rộng hơn.

Tôi có thể tưởng tượng sử dụng bit thứ 31 như một bit tưởng tượng ( i ) sẽ là một cách tiếp cận hỗ trợ một nửa tổng phạm vi.

hoạt động cho 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
}

Vấn đề nêu rõ "số nguyên có chữ ký 32 bit" nhưng không xác định liệu chúng có bổ sung twos không hay bổ sung .

Nếu bạn sử dụng bổ sung cho nhau thì tất cả 2 ^ 32 giá trị xảy ra theo chu kỳ có độ dài bốn - bạn không cần trường hợp đặc biệt bằng 0 và bạn cũng không cần điều kiện.

Trong C:

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

Điều này hoạt động bởi

1. Trao đổi khối 16 bit cao và thấp
2. Đảo ngược một trong các khối

Sau hai lần vượt qua, chúng ta có nghịch đảo bit của giá trị ban đầu. Mà trong đại diện bổ sung tương đương với phủ định.

Ví dụ:

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

Tôi muốn chia sẻ quan điểm của tôi về vấn đề thú vị này với tư cách là một nhà toán học. Tôi nghĩ rằng tôi có giải pháp hiệu quả nhất.

Nếu tôi nhớ chính xác, bạn phủ nhận số nguyên 32 bit đã ký bằng cách lật bit đầu tiên. Ví dụ: nếu n = 1001 1101 1110 1011 1110 0000 1110 1010, thì -n = 0001 1101 1110 1011 1110 0000 1110 1010.

Vậy làm thế nào để chúng ta xác định hàm f lấy số nguyên 32 bit đã ký và trả về một số nguyên 32 bit đã ký khác với thuộc tính lấy f hai lần giống như lật bit đầu tiên?

Hãy để tôi viết lại câu hỏi mà không đề cập đến các khái niệm số học như số nguyên.

Làm thế nào để chúng ta xác định một hàm f lấy một chuỗi các số 0 và một số có độ dài 32 và trả về một chuỗi các số không và các số có cùng độ dài, với thuộc tính lấy f hai lần giống như lật bit đầu tiên?

Quan sát: Nếu bạn có thể trả lời câu hỏi trên cho trường hợp 32 bit, thì bạn cũng có thể trả lời cho trường hợp 64 bit, trường hợp 100 bit, v.v. Bạn chỉ cần áp dụng f cho 32 bit đầu tiên.

Bây giờ nếu bạn có thể trả lời câu hỏi cho trường hợp 2 bit, Voila!

Và vâng, hóa ra 2 bit đầu tiên là đủ.

Đây là mã giả

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.

Ghi chú: Bước 2 và bước 3 cùng nhau có thể được mùa hè là (a, b) -> (-b, a). Trông quen quen? Điều đó sẽ nhắc nhở bạn về góc quay 90 độ của mặt phẳng và phép nhân với căn bậc hai của -1.

Nếu tôi chỉ trình bày mã giả một mình mà không có khúc dạo đầu dài, nó có vẻ giống như một con thỏ ra khỏi mũ, tôi muốn giải thích làm thế nào tôi có được giải pháp.