Thách thức: Xác định xtheo cách mà biểu thức (x == x+2)sẽ đánh giá là đúng.

Tôi đã gắn thẻ câu hỏi bằng C, nhưng câu trả lời bằng các ngôn ngữ khác đều được chào đón, miễn là chúng sáng tạo hoặc làm nổi bật một khía cạnh thú vị của ngôn ngữ.

Tôi dự định chấp nhận giải pháp C, nhưng các ngôn ngữ khác có thể nhận được phiếu bầu của tôi.

1. Đúng - hoạt động trên các triển khai tuân thủ tiêu chuẩn. Ngoại lệ - giả sử triển khai các loại cơ bản, nếu đó là cách triển khai phổ biến (ví dụ: giả sử intlà bổ sung 32 bit 2) là OK.
2. Đơn giản - nên nhỏ, sử dụng các tính năng ngôn ngữ cơ bản.
3. Thú vị - đó là chủ quan, tôi thừa nhận. Tôi có một số ví dụ cho những gì tôi cho là thú vị, nhưng tôi không muốn đưa ra gợi ý. Cập nhật : Tránh tiền xử lý là thú vị.
4. Nhanh chóng - Câu trả lời tốt đầu tiên sẽ được chấp nhận.

Sau khi nhận được 60 câu trả lời (tôi không bao giờ mong đợi như vậy), có thể tốt để tóm tắt chúng.

60 câu trả lời chia thành 7 nhóm, 3 trong số đó có thể được thực hiện bằng C, phần còn lại bằng các ngôn ngữ khác:

1. Bộ tiền xử lý C. #define x 2|0đã được đề xuất, nhưng có nhiều khả năng khác.
2. Điểm nổi. Số lượng lớn, vô cùng hoặc NaN đều hoạt động.

3. Con trỏ số học. Một con trỏ tới một cấu trúc khổng lồ gây ra thêm 2 để bao quanh.

   Phần còn lại không hoạt động với C:

4. Quá tải toán tử - A +không thêm hoặc a ==luôn trả về giá trị true.
5. Thực hiện xmột cuộc gọi chức năng (một số ngôn ngữ cho phép nó mà không cần x()cú pháp). Sau đó, nó có thể trả lại một cái gì đó mỗi lần.
6. Một kiểu dữ liệu một bit. Sau đó x == x+2 (mod 2).
7. Thay đổi 2- một số ngôn ngữ cho phép bạn gán 0cho nó.

main()
{
double x=1.0/0.0;
printf("%d",x==x+2);
}

Đầu ra 1.

Liên kết: http://ideone.com/dL6A5

Pháo đài IV:

2=0

Sau đó, mỗi hằng số 2 trong chương trình bằng không. Tin tôi đi, tôi đã làm điều này (ok, 25 năm trước)

Điều này dường như làm việc:

#define x 2|0

Về cơ bản, biểu thức được mở rộng đến (2|0 == 2|(0+2)). Đó là một ví dụ tốt về lý do tại sao người ta nên sử dụng dấu ngoặc đơn khi xác định macro.

Brainfuck

x

Điều này tất nhiên kéo dài "đánh giá thành đúng" một chút, bởi vì trong Brainfuck không có gì thực sự đánh giá bất cứ điều gì - bạn chỉ thao tác một cuộn băng. Nhưng nếu bây giờ bạn thêm biểu thức của bạn

x
(x == x+2)

chương trình tương đương với

+

(bởi vì tất cả mọi thứ nhưng <>+-[],.là một nhận xét). Mà không làm gì ngoài việc tăng giá trị nơi chúng ta đang ở. Băng được khởi tạo với tất cả các số không, vì vậy chúng tôi kết thúc bằng 1 trên vị trí con trỏ, có nghĩa là "đúng": nếu bây giờ chúng tôi bắt đầu một phần có điều kiện [], nó sẽ nhập / lặp.

ĐỤ#

let (==) _ _ = true
let x = 0
x == (x + 2) //true

C

int main() { float x = 1e10; printf("%d\n", x == x + 2); }

Lưu ý: có thể không hoạt động nếu FLT_EVAL_METHOD != 0(xem bình luận bên dưới).

C #

class T {
  static int _x;
  static int X { get { return _x -= 2; } }

  static void Main() { Console.WriteLine(X == X + 2); }
}

Không phải là một shortie, nhưng hơi thanh lịch.

http://ideone.com/x56Ul

Scala: { val x = Set(2); (x == x + 2) }

Haskell: Xác định / 2ℤ trên Booleans:

instance Num Bool where
    (+) = (/=)
    (-) = (+)
    (*) = (&&)
    negate = id
    abs    = id
    signum = id
    fromInteger = odd

sau đó cho bất kỳ x :: Boolchúng ta sẽ có x == x + 2.

Cập nhật: Cảm ơn các ý tưởng trong bình luận, tôi đã cập nhật ví dụ cho phù hợp.

Con trăn

class X(int):__add__=lambda*y:0
x=X()

# Then (x == x+2) == True

GNU C hỗ trợ các cấu trúc không có thành viên và kích thước 0:

struct {} *x = 0;

PHP:

$x = true;
var_dump($x == $x+2);

Hoặc là:

var_dump(!($x==$x+2));

Đầu ra:

bool (đúng)

Đó là một quan niệm sai lầm phổ biến rằng trong C, khoảng trắng không thành vấn đề. Tôi không thể tưởng tượng ai đó đã không nghĩ ra điều này trong GNU C:

#include <stdio.h>
#define CAT_IMPL(c, d) (c ## d)
#define CAT(c, d) CAT_IMPL(c, d)
#define x CAT(a, __LINE__)

int main()
{
    int a9 = 2, a10 = 0;
    printf("%d\n", x ==
        x + 2);
    return 0;
}

In 1.

C

Thật thú vị hơn khi không sử dụng macro và không lạm dụng vô hạn.

/////////////////////////////////////
// At the beginning                 /
// We assume truth!                 /

int truth = 1;
int x = 42;

/////////////////////////////////////
// Can the truth really be changed??/
truth = (x == x + 2);

/////////////////////////////////////
// The truth cannot be changed!     /
printf("%d",truth);

Hãy thử nếu bạn không tin!

Toán học:

x /: x + 2 := x
x == x + 2

Tôi nghĩ rằng giải pháp này là cuốn tiểu thuyết vì nó sử dụng Mathematica của khái niệm về giá trị Up.

BIÊN TẬP:

Tôi đang mở rộng câu trả lời của mình để giải thích ý nghĩa của Up Values ​​trong Mathicala .

Dòng đầu tiên về cơ bản xác định lại bổ sung cho biểu tượng x. Tôi có thể trực tiếp lưu trữ như một định nghĩa trong hàm toàn cầu được liên kết với các +biểu tượng, nhưng là một sự tái định nghĩa như vậy sẽ nguy hiểm vì các định nghĩa lại có thể tuyên truyền thất thường qua Mathematica của thuật toán tích hợp.

Thay vào đó, bằng cách sử dụng thẻ x/:, tôi liên kết định nghĩa với biểu tượng x. Bây giờ, bất cứ khi nào Mathicala nhìn thấy biểu tượng x, nó sẽ kiểm tra xem liệu nó có được vận hành bởi toán tử cộng +trong một mẫu có dạng x + 2 + ___biểu tượng trong đó biểu tượng ___có nghĩa là một chuỗi null có thể có của các ký hiệu khác hay không.

Định nghĩa lại này rất cụ thể và sử dụng các khả năng khớp mẫu mở rộng của Mathistica. Ví dụ, biểu thức x+y+2trả về x+y, nhưng biểu thức x+3trả về x+3; bởi vì trong trường hợp trước, mẫu có thể được khớp, nhưng trong trường hợp sau, mẫu không thể được khớp mà không cần đơn giản hóa thêm.

Javascript:

var x = 99999999999999999;
alert(x == x+2);​

Kiểm tra Fiddle

kế hoạch

(define == =)
(define (x a b c d) #t)
(x == x + 2)
;=> #t

Câu trả lời rõ ràng:

Khi điều này chấm dứt:

while (x != x+2) { }
printf("Now");

Đây là một giải pháp cho JavaScript không khai thác Infinityvà -Infinitycác trường hợp cạnh của phép cộng dấu phẩy động. Điều này không hoạt động trong Internet Explorer 8 trở xuống cũng như trong chế độ nghiêm ngặt chọn tham gia ES5. Tôi sẽ không gọi các withtuyên bố và getters đặc biệt là các tính năng "nâng cao".

with ({ $: 0, get x() {return 2 * this.$--;} }) {
    console.log(x == x+2);
}

Chỉnh sửa để thêm: Thủ thuật trên cũng có thể thực hiện mà không cần sử dụng withvà get, như Andy E đã lưu ý trong Mẹo chơi golf trong JavaScript và cũng bởi jncraton trên trang này:

var x = { $: 0, valueOf: function(){return 2 * x.$++;} };
console.log(x == x+2);

Dưới đây không phải là tiêu chuẩn C tuân thủ , nhưng sẽ hoạt động trên bất kỳ nền tảng 64 bit nào:

int (*x)[0x2000000000000000];

Hiền nhân:

x=Mod(0,2)
x==x+2

trả về True

Nói chung cho GF (2 ** n), luôn luôn đúng x = x + 2 với mọi x

Đây không phải là một lỗi hoặc một vấn đề với tràn hoặc vô cùng, nó thực sự chính xác

Lisp thường gặp

* (defmacro x (&rest r) t)
X
* (x == x+2)
T

Nó khá dễ dàng khi xkhông phải là một giá trị thực tế.

APL (Dyalog)

X←1e15
X=X+2

APL thậm chí không có vô cực, chỉ là những chiếc phao không đủ chính xác để nói lên sự khác biệt giữa 1.000.000.000.000.000và 1.000.000.000.000.002. Theo tôi biết, đây là cách duy nhất để làm điều này trong APL.

Perl 6

Tôi ngạc nhiên khi không thấy giải pháp này trước đây. Dù sao, giải pháp là - nếu xlà 0và 2cùng một lúc? my \xtrong ví dụ này khai báo biến sigilless - câu hỏi này hỏi về x, không phải kiểu Perl $x. Các ?? !!nhà điều hành ternary.

$ perl6 -e 'my \x = 0|2; say x == x + 2 ?? "YES" !! "NO"'
YES

Nhưng...

$ perl6 -e 'my \x = 0|2; say x == x + 3 ?? "YES" !! "NO"'
NO

xlà nhiều giá trị cùng một lúc. xbằng 0và 2cùng một lúc. x + 2bằng 2và 4cùng một lúc. Vì vậy, về mặt logic, chúng bằng nhau.

Python 2.X (Sử dụng xác định lại số nguyên (được lưu trong bộ nhớ cache))

Tôi đã nhận thấy tất cả các câu trả lời python đã xác định các lớp xác định lại +toán tử. Tôi sẽ trả lời bằng một minh chứng thậm chí ở mức độ thấp hơn về tính linh hoạt của trăn. (Đây là đoạn mã dành riêng cho python2)

Trong python, số nguyên được lưu trữ ít nhiều theo cách này trong C:

typedef struct {            // NOTE: Macros have been expanded
    Py_ssize_t ob_refcnt;
    PyTypeObject *ob_type;
    long ob_ival;
} PyIntObject;

Đó là, một cấu trúc với một size_t, void *và longđối tượng, theo thứ tự đó.
Khi chúng ta sử dụng và do đó lưu trữ một số nguyên, chúng ta có thể sử dụng ctypesmô-đun của python để xác định lại số nguyên đó, để không chỉ có x == x+2mà còn2 == 0

import ctypes
two = 2 # This will help us access the address of "2" so that we may change the value

# Recall that the object value is the third variable in the struct. Therefore,
# to change the value, we must offset the address we use by the "sizeof" a 
# size_t and a void pointer
offset = ctypes.sizeof(ctypes.c_size_t) + ctypes.sizeof(ctypes.c_voidp)

# Now we access the ob_ival by creating a C-int from the address of 
# our "two" variable, offset by our offset value.
# Note that id(variable) returns the address of the variable.
ob_ival = ctypes.c_int.from_address(id(two)+offset)

#Now we change the value at that address by changing the value of our int.
ob_ival.value = 0

# Now for the output
x = 1
print x == x+2
print 2 == 0

Bản in

True
True

Perl

sử dụng chương trình con với các tác dụng phụ trên biến gói:

sub x () { $v -= 2 }
print "true!\n" if x == x + 2;

Đầu ra: true!

Con trăn

khai thác chính xác điểm nổi làm cho điều này rất đơn giản.

>>> x = 100000000000000000.0
>>> (x == x+2)
True

Để làm cho nó ít cụ thể hơn hệ thống yêu cầu nhập thêm

>>> import sys
>>> x = float(sys.maxint + 1)
>>> (x == x+2)
True

Điều này cũng nên làm việc trong các ngôn ngữ khác. Điều này hoạt động vì sự giới thiệu của 100000000000000000.0 và 100000000000000002.0 hoàn toàn giống nhau cho máy, vì cách các điểm nổi được thể hiện bên trong máy. xem http://en.wikipedia.org/wiki/IEEE_floating_point để biết thêm thông tin.

Vì vậy, điều này về cơ bản sẽ hoạt động trong bất kỳ ngôn ngữ nào cho phép bạn thêm số nguyên vào số float và kết quả của việc này là số float.

Đây là một giải pháp cho C ++ dựa trên quá tải toán tử. Nó dựa vào chuyển đổi ngầm định từ một enumsang một int.

#include <iostream>

enum X {};
bool operator==(X x, int y)
{
    return true;
}

int main()
{
    X x;
    std::cout << std::boolalpha << (x == x+2) << std::endl;
    return 0;
}

Tôi biết đó là một thử thách mã ... nhưng tôi đã đánh gôn nó. Lấy làm tiếc.

Ruby - 13 ký tự - Giải pháp vô cực

x=1e17;x==x+2

trả về đúng

Ruby - 41 ký tự - Giải pháp quá tải Op

class Fixnum;def + y;0 end end;x=0;x==x+2

hoặc là

class A;def self.+ y;A end end;x=A;x==x+2

Nếu có thể khai thác câu hỏi một chút, thì tôi sẽ thêm một số Java mới. Thủ thuật này chắc chắn không mới, nhưng có lẽ thú vị là điều này có thể có trong Java.

static void pleaseDoNotDoThis() throws Exception {
    Field field = Boolean.class.getField("FALSE");
    field.setAccessible(true);
    Field modifiersField = Field.class.getDeclaredField("modifiers");
    modifiersField.setAccessible(true);
    modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
    field.set(null, true);
}

public static void main(String args[]) throws Exception {
    pleaseDoNotDoThis();
    doit(1);
    doit("NO");
    doit(null);
    doit(Math.PI);
}

static void doit(long x) {
    System.out.format("(x == x + 2) = (%d == %d) = %s\n", x, x+2, (x == x + 2));
}

static void doit(String x) {
    System.out.format("(x == x + 2) = (%s == %s) = %s\n", x, x+2, (x == x + 2));
}

static void doit(double x) {
    System.out.format("(x == x + 2) = (%f == %f) = %s\n", x, x+2, (x == x + 2));
}

Và kết quả:

(x == x + 2) = (1 == 3) = true
(x == x + 2) = (NO == NO2) = true
(x == x + 2) = (null == null2) = true
(x == x + 2) = (3,141593 == 5,141593) = true
(x == x + 2) = (Infinity == Infinity) = true

Giải pháp VBScript này hoạt động tương tự như giải pháp JavaScript của tôi. Tôi đã không sử dụng một bộ tiền xử lý nhưng giải pháp có vẻ tầm thường.

y = 0
Function x
x = y
y = -2
End Function

If x = x + 2 Then
    WScript.Echo "True"
Else
    WScript.Echo "False"
End If