Tantangannya: Tetapkan xsedemikian rupa sehingga ekspresi (x == x+2)akan dievaluasi menjadi benar.

Saya menandai pertanyaan dengan C, tetapi jawaban dalam bahasa lain dapat diterima, asalkan mereka kreatif atau menyoroti aspek menarik dari bahasa tersebut.

Saya bermaksud menerima solusi C, tetapi bahasa lain bisa mendapatkan suara saya.

1. Benar - berfungsi pada implementasi yang sesuai standar. Pengecualian - dengan asumsi implementasi tipe dasar, jika itu implementasi umum (mis. Asumsi intadalah komplemen 32bit 2) adalah OK.
2. Sederhana - harus berukuran kecil, gunakan fitur bahasa dasar.
3. Menarik - saya akui itu subjektif. Saya punya beberapa contoh untuk apa yang saya anggap menarik, tetapi saya tidak ingin memberikan petunjuk. Pembaruan : Menghindari preprocessor itu menarik.
4. Cepat - Jawaban bagus pertama akan diterima.

Setelah mendapatkan 60 jawaban (saya tidak pernah mengharapkan partisipasi semacam itu), mungkin baik untuk merangkumnya.

60 jawaban dibagi menjadi 7 kelompok, 3 di antaranya dapat diimplementasikan dalam C, sisanya dalam bahasa lain:

1. Preprosesor C. #define x 2|0disarankan, tetapi ada banyak kemungkinan lain.
2. Titik mengambang. Sejumlah besar, tak terbatas atau NaN semuanya berfungsi.

3. Aritmatika petunjuk. Pointer ke struct besar menyebabkan menambahkan 2 untuk membungkus.

   Sisanya tidak bekerja dengan C:

4. Operator overloading - A +yang tidak menambah atau ==yang selalu mengembalikan true.
5. Membuat xpanggilan fungsi (beberapa bahasa mengizinkannya tanpa x()sintaks). Maka itu dapat mengembalikan sesuatu yang lain setiap kali.
6. Tipe data satu bit. Lalu x == x+2 (mod 2).
7. Mengubah 2- beberapa bahasa memungkinkan Anda menetapkannya 0.

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

Output 1.

Tautan: http://ideone.com/dL6A5

Fortran IV:

2=0

Setelah ini, setiap konstanta 2 dalam program adalah nol. Percayalah, saya telah melakukan ini (ok, 25 tahun yang lalu)

Ini sepertinya berhasil:

#define x 2|0

Pada dasarnya, ekspresi diperluas ke (2|0 == 2|(0+2)). Ini adalah contoh yang bagus mengapa seseorang harus menggunakan tanda kurung ketika mendefinisikan makro.

Brainfuck

x

Ini tentu saja sedikit meregangkan "mengevaluasi benar", karena dalam Brainfuck tidak ada yang benar-benar mengevaluasi apa pun - Anda hanya memanipulasi kaset. Tetapi jika sekarang Anda menambahkan ekspresi Anda

x
(x == x+2)

program ini setara dengan

+

(karena semuanya kecuali <>+-[],.komentar). Yang tidak melakukan apa-apa selain meningkatkan nilai di mana kita berada sekarang. Rekaman diinisialisasi dengan semua nol, jadi kita berakhir dengan 1 pada posisi kursor, yang berarti "benar": jika kita sekarang memulai bagian bersyarat [], itu akan masuk / loop.

F #

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

C

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

Catatan: mungkin tidak berfungsi jika FLT_EVAL_METHOD != 0(lihat komentar di bawah).

C #

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

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

Bukan shortie, tapi agak elegan.

http://ideone.com/x56Ul

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

Haskell: Tentukan ℤ / 2ℤ pada Booleans:

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

maka untuk apa pun yang x :: Boolkita miliki x == x + 2.

Pembaruan: Terima kasih atas ide-ide dalam komentar, saya memperbarui contoh sesuai.

Python

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

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

GNU C mendukung struktur tanpa anggota dan ukuran 0:

struct {} *x = 0;

PHP:

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

Atau:

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

Keluaran:

bool (benar)

Ini adalah kesalahpahaman umum bahwa dalam C, spasi putih tidak masalah. Saya tidak bisa membayangkan seseorang belum menemukan ini di 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;
}

Cetakan 1.

C

Ini lebih menarik tanpa menggunakan macro dan tanpa menyalahgunakan infinity.

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

Cobalah jika Anda tidak percaya!

Mathematica:

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

Saya pikir solusi ini adalah novel karena menggunakan konsep Nilai Up Mathematica .

SUNTING:

Saya memperluas jawaban saya untuk menjelaskan apa arti Nilai Up dalam Mathematica .

Baris pertama pada dasarnya mendefinisikan ulang penambahan untuk simbol x. Saya bisa langsung menyimpan definisi seperti itu dalam fungsi global yang dikaitkan dengan +simbol, tetapi definisi ulang seperti itu akan berbahaya karena redefinisi dapat menyebar secara tak terduga melalui algoritma bawaan Matematika .

Sebagai gantinya, menggunakan tag x/:, saya menghubungkan definisi dengan simbol x. Sekarang setiap kali Mathematica melihat simbol x, itu memeriksa untuk melihat apakah itu sedang dioperasikan oleh operator tambahan +dalam pola bentuk di x + 2 + ___mana simbol ___berarti kemungkinan urutan nol dari simbol lain.

Redefinisi ini sangat spesifik dan memanfaatkan kemampuan pencocokan pola yang luas dari Mathematica . Misalnya, ekspresi x+y+2kembali x+y, tetapi ekspresi x+3kembali x+3; karena dalam kasus sebelumnya, polanya dapat dicocokkan, tetapi dalam kasus yang terakhir, polanya tidak dapat dicocokkan tanpa penyederhanaan tambahan.

Javascript:

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

Tes Fiddle

skema

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

Jawaban yang jelas:

Ketika ini berakhir:

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

Berikut ini adalah solusi untuk JavaScript yang tidak mengeksploitasi kasus tepi Infinitydan -Infinitypenambahan floating-point. Ini tidak bekerja di Internet Explorer 8 dan di bawah atau dalam mode ketat opt-in ES5. Saya tidak akan menyebut withpernyataan dan getter terutama fitur "canggih".

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

Diedit untuk menambahkan: Trik di atas juga dimungkinkan tanpa menggunakan withdan get, seperti dicatat oleh Andy E dalam Tips untuk bermain golf di JavaScript dan juga oleh jncraton pada halaman ini:

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

Yang berikut ini bukan standar yang sesuai C , tetapi harus bekerja pada hampir semua platform 64-bit:

int (*x)[0x2000000000000000];

Sage:

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

mengembalikan True

Secara umum untuk GF (2 ** n) selalu benar bahwa x = x + 2 untuk setiap x

Ini bukan bug atau masalah dengan overflow atau infinity, itu sebenarnya benar

Gangguan umum

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

Sangat mudah ketika xtidak harus menjadi nilai aktual.

APL (Dyalog)

X←1e15
X=X+2

APL bahkan tidak memiliki infinity, hanya saja mengapung tidak cukup tepat untuk membedakan antara 1.000.000.000.000.000dan 1.000.000.000.000.002. Sejauh ini yang saya tahu, ini satu-satunya cara untuk melakukan ini di APL.

Perl 6

Saya terkejut tidak melihat solusi ini sebelumnya. Pokoknya, solusinya adalah - bagaimana jika xyang 0dan 2sekaligus? my \xdalam contoh ini menyatakan variabel sigilless - pertanyaan ini bertanya tentang x, bukan gaya-Perl $x. The ?? !!adalah operator ternary.

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

Tapi...

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

xadalah beberapa nilai sekaligus. xsama dengan 0dan 2sekaligus. x + 2sama dengan 2dan 4sekaligus. Jadi, secara logis mereka setara.

Python 2.X (Menggunakan redefinisi integer (cache))

Saya perhatikan semua jawaban python telah mendefinisikan kelas yang mendefinisikan ulang + operator. Saya akan menjawab dengan demonstrasi fleksibilitas ular piton tingkat rendah. (Ini adalah potongan python2 khusus)

Dalam python, integer disimpan kurang lebih dengan cara ini di C:

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

Artinya, struct dengan size_t, void *, dan longobjek, dalam urutan itu.
Setelah kita menggunakan, dan karena itu men-cache integer, kita dapat menggunakan ctypesmodul python untuk mendefinisikan kembali integer itu, sehingga tidak hanya melakukannya x == x+2, tetapi2 == 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

Cetakan

True
True

Perl

menggunakan subrutin dengan efek samping pada variabel paket:

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

Keluaran: true!

Python

mengeksploitasi presisi floating point membuat ini sangat sederhana.

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

Untuk membuatnya kurang spesifik sistem, diperlukan impor tambahan

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

Ini juga bisa digunakan dalam bahasa lain. Ini bekerja karena reprensentasi 100000000000000000000.0 dan 100000000000000002.0 persis sama untuk mesin, karena cara floating point diwakili di dalam mesin. lihat http://en.wikipedia.org/wiki/IEEE_floating_point untuk informasi lebih lanjut.

Jadi ini pada dasarnya akan bekerja dalam bahasa apa pun yang memungkinkan Anda untuk menambahkan bilangan bulat ke float dan hasilnya adalah float.

Berikut ini adalah solusi untuk C ++ berdasarkan overloading operator. Itu bergantung pada konversi implisit dari sebuah enumke 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;
}

Saya tahu ini tantangan kode ... tapi saya pegolf. Maaf.

Ruby - 13 karakter - Solusi Infinity

x=1e17;x==x+2

mengembalikan true

Ruby - 41 karakter - Solusi Op Overloading

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

atau

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

Jika OK untuk mengeksploitasi pertanyaan sedikit, maka saya akan menambahkan beberapa Java baru. Triknya pasti bukan hal baru, tetapi mungkin menarik bahwa ini mungkin di Jawa.

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

Dan hasilnya:

(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

Solusi VBScript ini bekerja mirip dengan solusi JavaScript saya. Saya tidak menggunakan preprosesor namun solusinya tampaknya sepele.

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

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