ความท้าทาย: กำหนดxในลักษณะที่การแสดงออก(x == x+2)จะประเมินเป็นจริง

ฉันติดแท็กคำถามด้วย C แต่ยินดีต้อนรับคำตอบในภาษาอื่นตราบใดที่พวกเขามีความคิดสร้างสรรค์หรือเน้นแง่มุมที่น่าสนใจของภาษา

ฉันตั้งใจจะยอมรับโซลูชัน C แต่ภาษาอื่นสามารถรับการโหวตของฉันได้

1. ถูกต้อง - ทำงานกับการใช้งานที่ได้มาตรฐาน ข้อยกเว้น - สมมติว่ามีการใช้งานประเภทพื้นฐานหากเป็นการใช้งานทั่วไป (เช่นสมมติว่าintเป็นส่วนประกอบ 32 บิต 2) ก็โอเค
2. ง่าย - ควรมีขนาดเล็กใช้คุณสมบัติภาษาขั้นพื้นฐาน
3. น่าสนใจ - เป็นเรื่องส่วนตัวฉันยอมรับ ฉันมีตัวอย่างสำหรับสิ่งที่ฉันคิดว่าน่าสนใจ แต่ฉันไม่ต้องการให้คำแนะนำ อัพเดต : การหลีกเลี่ยงตัวประมวลผลล่วงหน้าเป็นสิ่งที่น่าสนใจ
4. ด่วน - คำตอบที่ดีแรกจะได้รับการยอมรับ

หลังจากได้รับคำตอบ 60 ครั้ง (ฉันไม่เคยคาดหวังว่าจะมีการคาดการณ์เช่นนี้) มันอาจเป็นการดีที่จะสรุปพวกเขา

60 คำตอบแบ่งเป็น 7 กลุ่มโดย 3 กลุ่มสามารถนำไปใช้ใน C ส่วนที่เหลือเป็นภาษาอื่น:

1. ตัวประมวลผลล่วงหน้า C #define x 2|0แนะนำ แต่มีความเป็นไปได้อื่น ๆ อีกมากมาย
2. จุดลอยตัว ตัวเลขขนาดใหญ่อินฟินิตี้หรือน่านทั้งหมดทำงานได้

3. เลขคณิตของตัวชี้ ตัวชี้ไปยังโครงสร้างขนาดใหญ่ทำให้การเพิ่ม 2 เพื่อตัด

   ส่วนที่เหลือไม่ทำงานกับ C:

4. โอเปอร์เรเตอร์ที่เกินพิกัด - A +ที่ไม่เพิ่มหรือ a ==ที่คืนค่าจริงเสมอ
5. ทำให้xการเรียกฟังก์ชั่น (บางภาษาให้มันได้โดยไม่ต้องx()ไวยากรณ์) จากนั้นมันจะคืนสิ่งอื่นทุกครั้ง
6. ชนิดข้อมูลหนึ่งบิต x == x+2 (mod 2)แล้วก็
7. การเปลี่ยน2- บางภาษาช่วยให้คุณกำหนด0ได้

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

เอาท์พุท 1

ลิงก์: http://ideone.com/dL6A5

Fortran IV:

2=0

หลังจากนี้ทุก 2 คงที่ในโปรแกรมเป็นศูนย์ เชื่อฉันสิฉันได้ทำสิ่งนี้แล้ว (ตกลง 25 ปีที่แล้ว)

ดูเหมือนว่าจะใช้งานได้:

#define x 2|0

(2|0 == 2|(0+2))โดยทั่วไปการแสดงออกที่มีการขยายไปยัง เป็นตัวอย่างที่ดีว่าทำไมคนเราควรใช้วงเล็บเมื่อกำหนดมาโคร

brainfuck

x

นี้แน่นอนยืด "ประเมินเป็นจริง" เล็กน้อยเพราะใน Brainfuck ไม่มีอะไรประเมินผลได้จริง- คุณเพียงจัดการเทป แต่ถ้าคุณต่อท้ายการแสดงออกของคุณ

x
(x == x+2)

โปรแกรมเทียบเท่า

+

(เพราะทุกอย่าง แต่<>+-[],.เป็นความคิดเห็น) ซึ่งไม่ทำอะไรเลยนอกจากการเพิ่มมูลค่าที่เราอยู่ตอนนี้ เทปถูกกำหนดค่าเริ่มต้นด้วยศูนย์ทั้งหมดดังนั้นเราจึงลงท้ายด้วย 1 บนตำแหน่งเคอร์เซอร์ซึ่งหมายความว่า "จริง": ถ้าตอนนี้เราเริ่มต้นส่วนที่มีเงื่อนไขด้วย[]มันจะเข้า / วน

F #

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

C

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

หมายเหตุ: อาจไม่ทำงานถ้าFLT_EVAL_METHOD != 0(ดูความคิดเห็นด้านล่าง)

C #

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

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

ไม่ใช่เตี้ย แต่ค่อนข้างหรูหรา

http://ideone.com/x56Ul

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

Haskell:กำหนดℤ / 2ℤบนBooleans:

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

แล้วสำหรับการใด ๆเราจะมีx :: Boolx == x + 2

อัปเดต:ขอบคุณสำหรับแนวคิดในความคิดเห็นฉันอัปเดตอินสแตนซ์ตามนั้น

หลาม

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

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

GNU Cรองรับโครงสร้างที่ไม่มีสมาชิกและขนาด 0:

struct {} *x = 0;

PHP:

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

หรือ:

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

เอาท์พุท:

บูล (จริง)

มันเป็นความเข้าใจผิดที่พบบ่อยใน C ช่องว่างไม่สำคัญ ฉันนึกภาพไม่ออกว่ามีใครบางคนไม่ได้ทำสิ่งนี้ใน 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;
}

1พิมพ์

C

มันเป็นเรื่องที่น่าสนใจมากขึ้นหากไม่ใช้มาโครและไม่ใช้ความไม่สิ้นสุด

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

ลองถ้าคุณไม่เชื่อ!

Mathematica:

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

ฉันคิดว่าวิธีนี้เป็นเรื่องแปลกเพราะใช้แนวคิดของค่านิยมของ Mathematica

แก้ไข:

ฉันกำลังขยายคำตอบของฉันจะอธิบายสิ่งที่ค่าหมายถึงในMathematica

xบรรทัดแรกเป็นหลักนอกจากนี้นิยามใหม่สำหรับสัญลักษณ์ ฉันโดยตรงสามารถเก็บคำนิยามในการทำงานระดับโลกที่มีความเกี่ยวข้องกับการ+สัญลักษณ์ แต่เช่นนิยามใหม่จะเป็นอันตรายเพราะนิยามใหม่อาจเผยแพร่อันเป็นผ่านMathematica ของในตัวอัลกอริทึม

แต่ใช้แท็กผมที่เกี่ยวข้องกับความหมายสัญลักษณ์x/: xตอนนี้เมื่อใดก็ตามที่Mathematicaเห็นสัญลักษณ์xก็จะตรวจสอบเพื่อดูว่ามันถูกดำเนินการโดยผู้ประกอบการเพิ่มเติม+ในรูปแบบของรูปแบบx + 2 + ___ที่สัญลักษณ์___หมายถึงลำดับโมฆะที่เป็นไปได้ของสัญลักษณ์อื่น ๆ

นิยามใหม่นี้มีความเฉพาะเจาะจงมากและใช้ความสามารถในการจับคู่รูปแบบที่กว้างขวางของ Mathematica ยกตัวอย่างเช่นการแสดงออกx+y+2ผลตอบแทนx+yแต่การแสดงออกx+3ผลตอบแทนx+3; เพราะในกรณีก่อนรูปแบบสามารถจับคู่ได้ แต่ในกรณีหลังรูปแบบไม่สามารถจับคู่ได้หากไม่มีการทำให้เข้าใจง่ายขึ้นเพิ่มเติม

javascript:

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

ทดสอบซอ

โครงการ

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

คำตอบที่ชัดเจน:

เมื่อสิ่งนี้สิ้นสุดลง:

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

นี่คือโซลูชันสำหรับ JavaScript ที่ไม่ใช้ประโยชน์จากInfinityและ-Infinityกรณีขอบของการเพิ่มจุดลอย สิ่งนี้ใช้ได้ทั้งใน Internet Explorer 8 และต่ำกว่าหรือในโหมดเข้มงวดในการเลือกใช้ ES5 ฉันจะไม่เรียกwithคำแถลงนี้และผู้ให้ข้อมูลโดยเฉพาะอย่างยิ่งฟีเจอร์ "ขั้นสูง"

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

แก้ไขเพื่อเพิ่ม:เคล็ดลับข้างต้นเป็นไปได้โดยไม่ใช้withและgetตามที่ระบุไว้โดยAndy Eในเคล็ดลับสำหรับการเล่นกอล์ฟใน JavaScriptและjncratonในหน้านี้:

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

ต่อไปนี้ไม่ได้เป็นไปตามมาตรฐานCแต่ควรทำงานบนแพลตฟอร์ม 64 บิตใด ๆ :

int (*x)[0x2000000000000000];

ปราชญ์:

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

ผลตอบแทนจริง

โดยทั่วไปสำหรับ GF (2 ** n) มันเป็นความจริงเสมอว่า x = x + 2 สำหรับ x ใด ๆ

นี่ไม่ใช่ข้อผิดพลาดหรือปัญหาเกี่ยวกับการล้นหรืออินฟินิตี้มันถูกต้องจริง

เสียงกระเพื่อมสามัญ

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

มันค่อนข้างง่ายเมื่อxไม่จำเป็นต้องเป็นค่าจริง

APL (Dyalog)

X←1e15
X=X+2

APL ไม่ได้มีอินฟินิตี้ก็เพียงว่าลอยจะไม่แม่นยำพอที่จะบอกความแตกต่างระหว่างและ1.000.000.000.000.000 1.000.000.000.000.002นี่คือเท่าที่ฉันรู้วิธีเดียวที่จะทำได้ใน APL

Perl 6

ฉันประหลาดใจที่ไม่เห็นโซลูชันนี้มาก่อน อย่างไรก็ตามการแก้ปัญหาคือ - สิ่งที่ถ้าxเป็น0และ2ในครั้งเดียว? my \xในตัวอย่างนี้ประกาศตัวแปร sigilless - คำถามนี้ถามเกี่ยวกับการxไม่ $xPerl ?? !!เป็นผู้ดำเนิน ternary

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

แต่...

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

xคือหลายค่าในครั้งเดียว xเท่ากับ0และ2ในครั้งเดียว x + 2เท่ากับ2และ4ในครั้งเดียว ดังนั้นในเชิงตรรกะพวกมันเท่ากัน

Python 2.X (การใช้นิยามใหม่ของจำนวนเต็ม (แคช))

ฉันสังเกตเห็นคำตอบหลามทั้งหมดได้กำหนดคลาสที่กำหนดตัว+ดำเนินการใหม่ ฉันจะตอบด้วยการสาธิตระดับต่ำยิ่งขึ้นของความยืดหยุ่นของงูหลาม (นี่เป็นข้อมูลโค้ดเฉพาะของ python2)

ในไพ ธ อนจำนวนเต็มจะถูกเก็บไว้ใน C:

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

นั่นคือโครงสร้างที่มีsize_t, void *และlongวัตถุในลำดับที่
เมื่อเราใช้และดังนั้นจึงเป็นจำนวนเต็มแคชเราสามารถใช้ctypesโมดูลของงูใหญ่เพื่อกำหนดจำนวนเต็มนั้นเพื่อที่ไม่เพียงx == x+2แต่2 == 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

พิมพ์

True
True

Perl

การใช้รูทีนย่อยที่มีผลข้างเคียงกับตัวแปรแพ็กเกจ:

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

เอาท์พุท: true!

หลาม

การใช้ประโยชน์จากความแม่นยำจุดลอยทำให้เรื่องนี้ง่ายมาก

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

เพื่อให้ระบบมีความเฉพาะเจาะจงน้อยลง

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

สิ่งนี้ควรทำงานในภาษาอื่นด้วย สิ่งนี้ทำงานได้เนื่องจากการพิมพ์ใหม่ของ 100000000000000000.0 และ 100000000000000002.0 นั้นเหมือนกันทุกประการสำหรับเครื่องเนื่องจากวิธีแสดงคะแนนลอยตัวภายในเครื่อง ดูhttp://en.wikipedia.org/wiki/IEEE_floating_pointสำหรับข้อมูลเพิ่มเติม

ดังนั้นสิ่งนี้จะใช้งานได้กับภาษาใด ๆ ที่อนุญาตให้คุณเพิ่มจำนวนเต็มเพื่อลอยและมีผลลัพธ์ของการลอยนี้

นี่คือวิธีการแก้ปัญหาสำหรับ C ++ โดยยึดตามการใช้งานเกินพิกัด มันต้องอาศัยการแปลงโดยปริยายจากไปยังenumint

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

ฉันรู้ว่ามันเป็นรหัสที่ท้าทาย ... แต่ฉันเล่นกอล์ฟ ขอโทษ

Ruby - 13 ตัวอักษร - วิธีแก้ปัญหาไม่มีที่สิ้นสุด

x=1e17;x==x+2

ผลตอบแทนจริง

Ruby - 41 ตัวอักษร - Op การแก้ปัญหาการโอเวอร์โหลด

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

หรือ

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

หากการใช้ประโยชน์จากคำถามเล็กน้อยฉันจะเพิ่ม Java ใหม่ เคล็ดลับนั้นแน่นอนไม่ใช่เรื่องใหม่ แต่อาจน่าสนใจว่านี่เป็นไปได้ใน 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));
}

และผลลัพธ์:

(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

โซลูชัน VBScript นี้ทำงานคล้ายกับโซลูชัน JavaScript ของฉัน ฉันไม่ได้ใช้ preprocessor แต่ดูเหมือนว่าวิธีแก้ปัญหาเล็กน้อย

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

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