Mesele: xİfadenin (x == x+2)doğru olarak değerlendirileceği şekilde tanımlayın .

Soruyu C ile etiketledim, ancak yaratıcı oldukları veya dilin ilginç bir yönünü vurguladıkları sürece diğer dillerde cevaplar açıktır.

Bir C çözümünü kabul etmek niyetindeyim, ancak diğer diller oyumu alabilir.

1. Doğru - standart uyumlu uygulamalar üzerinde çalışır. İstisna - eğer temel bir uygulama varsayalım, eğer ortak bir uygulama ise (örneğin int, 32bit 2'nin tamamlayıcısı olduğu varsayılır ) tamamdır.
2. Basit - küçük olmalı, temel dil özelliklerini kullanın.
3. İlginç - öznel, itiraf ediyorum. İlginç bulduğum şeyler için bazı örneklerim var, ancak ipucu vermek istemiyorum. Güncelleme : Önişlemciden kaçınmak ilginçtir.
4. Çabuk - İlk iyi cevap kabul edilecektir.

60 cevap aldıktan sonra (böyle bir beklenti beklemiyordum), onları özetlemek iyi olabilir.

60 cevap 7 gruba ayrılmıştır, bunlardan 3'ü diğer dillerdeki C dilinde uygulanabilir:

1. C önişlemcisi. #define x 2|0önerildi, ancak daha birçok olasılık var.
2. Kayan nokta. Büyük sayılar, sonsuzluk veya NaN hepsi işe yarar .

3. İşaretçi aritmetiği. Büyük bir yapıya bir işaretçi etrafına sarılmaya 2 ekleyerek neden olur.

   Gerisi C ile çalışmıyor:

4. Operatör aşırı yüklenmesi - +Eklemeyen veya ==her zaman doğru olan bir A.
5. xİşlev çağrısı yapma (bazı diller x()sözdizimi olmadan izin verir ). O zaman her seferinde başka bir şey döndürebilir.
6. Bir bit veri türü. Öyleyse x == x+2 (mod 2).
7. Değiştirme 2- bazı diller size atamanıza izin verir 0.

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

Çıkışlar 1.

Bağlantı: http://ideone.com/dL6A5

Fortran IV:

2=0

Bundan sonra programdaki her sabit 2 sıfırdır. İnan bana, bunu yaptım (tamam, 25 yıl önce)

Bu iş gibi görünüyor:

#define x 2|0

Temel olarak, ifade için genişletildi (2|0 == 2|(0+2)). Makroları tanımlarken parantez kullanmak neden güzel bir örnektir.

brainfuck

x

Bu elbette biraz “doğru” olarak değerlendirir, çünkü Brainfuck'ta hiçbir şey aslında hiçbir şeyi değerlendirmez - yalnızca bir kaseti manipüle edersiniz. Fakat şimdi ifadenizi eklerseniz

x
(x == x+2)

program eşdeğerdir

+

(çünkü her şey ama <>+-[],.bir yorumdur). Bu da hiçbir şey yapmıyor, şimdi bulunduğumuz değeri arttırıyor. Teyp tüm sıfırlarla başlatıldı, bu nedenle imleç konumunda 1 işaretini alıyoruz, bu da "true" anlamına geliyor: şuan koşullu bir bölümle başladığımızda [], / döngüsüne girecekti.

F #

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

C

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

Not: eğer işe yaramayabilir FLT_EVAL_METHOD != 0(aşağıdaki yorumlara bakınız).

C #

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

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

Bir shortie değil, ama biraz zarif.

http://ideone.com/x56Ul

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

Haskell: Yemeklerde ℤ / 2ℤ tanımlayın Bool:

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

o x :: Boolzaman sahip olacağımız her şey için x == x + 2.

Güncelleme: Yorumdaki fikirler için teşekkürler, örneği buna göre güncelledim.

piton

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

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

GNU C üye ve 0 beden olmayan yapıları destekler:

struct {} *x = 0;

PHP:

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

Veya:

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

Çıktı:

bool (true)

C'deki boşlukların önemli olmadığı yaygın bir yanılgıdır. GNU C’de birisinin bu olamadığını hayal edemiyorum:

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

Yazdırır 1.

C

Makro kullanmadan ve sonsuzluğa zarar vermeden daha ilginçtir.

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

İnanmıyorsan dene!

Mathematica:

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

Bence bu çözüm yeni çünkü Mathematica'nın Yukarı Değerler kavramını kullanıyor .

DÜZENLE:

Mathematica'da Yukarı Değerlerin ne anlama geldiğini açıklamak için cevabımı genişletiyorum .

İlk satır esasen sembolün ilavesini yeniden tanımlar x. Bu tür bir tanımı doğrudan +sembolle ilişkilendirilen global fonksiyonda saklayabilirim , ancak böyle bir yeniden tanımlamanın yapılması tehlikeli olabilir çünkü yeniden tanımlamanın Mathematica'nın yerleşik algoritmaları aracılığıyla tahmin edilemez şekilde yayılması mümkündür .

Bunun yerine, etiketi kullanarak x/:tanımı sembolle ilişkilendirdim x. Şimdi ne zaman Mathematica sembolü görür x, bu ek operatör tarafından ameliyat olup olmadığını görmek için denetler +şeklinde bir desen x + 2 + ___sembolü ___diğer sembollerin olası boş dizisi anlamına gelir.

Bu yeniden tanımlama çok spesifiktir ve Mathematica'nın kapsamlı desen eşleştirme yeteneklerini kullanır . Örneğin, ifade x+y+2döndürür x+y, ancak ifade x+3döndürür x+3; çünkü önceki durumda, kalıp eşleştirilebiliyordu, fakat ikinci durumda, kalıp basitleştirilmeden eşleştirilemedi.

JavaScript:

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

Fiddle'ı Test Et

düzen

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

Açık cevap:

Bu sonlandığında:

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

Burada, kayan nokta eklemeye ilişkin kenar Infinityve -Infinitykasa durumlarından faydalanmayan bir JavaScript çözümü sunulmaktadır . Bu, Internet Explorer 8 ve altında ya da ES5 katı modundayken çalışmaz. Ben demem withdeyimi ve alıcılar özellikle "gelişmiş" özellikleri.

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

: Eklemek Düzenlendi yukarıdaki hile kullanmadan da mümkündür withve gettarafından belirtildiği gibi, Andy E yılında JavaScript golf için İpuçları ve ayrıca tarafından jncraton bu sayfada:

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

Aşağıdakiler, C standartlarına uygun değildir , ancak hemen hemen tüm 64 bit platformlarda çalışmalıdır:

int (*x)[0x2000000000000000];

Adaçayı:

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

True döndürür

Genel olarak GF için (2 ** n) her zaman x için x = x + 2 olur.

Bu bir hata veya taşma veya sonsuzluk ile ilgili bir sorun değil, aslında doğru

Ortak Lisp

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

xGerçek bir değer olmak zorunda olmadığında oldukça kolaydır .

APL (Dyalog)

X←1e15
X=X+2

APL sonsuzluğa bile sahip değildir, sadece şamandıralar 1.000.000.000.000.000ve arasındaki farkı söyleyecek kadar kesin değildir 1.000.000.000.000.002. Bu, bildiğim kadarıyla APL'de bunu yapmanın tek yolu.

Perl 6

Bu çözümü daha önce görmeme şaşırdım. Neyse, çözüm - ne olur xolduğunu 0ve 2birden! my \xBu örnekte duyarsızlık değişkeni bildiriliyor - bu soru xPerl tarzı hakkında değil $x. ?? !!Üçlü operatörüdür.

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

Fakat...

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

xAynı anda çoklu değerlerdir. xaynı anda 0ve eşittir 2. x + 2aynı anda 2ve eşittir 4. Yani, mantıksal olarak eşittirler.

Python 2.X ((önbelleğe alınmış) tamsayıların yeniden tanımlanmasının kullanılması)

Tüm python cevaplarının +işleci yeniden tanımlayan sınıfları tanımladığını fark ettim . Python'un esnekliğinin daha düşük seviyeli bir gösterimi ile cevaplayacağım. (Bu bir python2'ye özgü snippet'tir)

Python'da tamsayılar C veya C'de bu şekilde az ya da çok depolanır:

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

Yani, bir ile bir yapıdır size_t, void *ve longbu sırayla nesnenin.
Kullandığımız ve bu nedenle bir tamsayı önbelleğe sonra, Python en kullanabilirsiniz ctypesböylece sadece demek ki tamsayı yeniden tanımlamak için modül x == x+2, ancak2 == 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

Baskılar

True
True

Perl

Bir paket değişkeninde yan etkileri olan bir alt yordam kullanmak:

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

Çıktı: true!

piton

kayan nokta hassasiyetinden yararlanmak bunu çok basit hale getirir.

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

Daha az sisteme özgü hale getirmek için ekstra bir ithalat gerektirir

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

Bu başka dillerde de çalışmalı. Bu, 100000000000000000000.0 ve 100000000000000002.0'ın yeniden yenilenmesinin, makine içerisinde kayan noktaların temsil edilmesinden dolayı tamamen aynı olması nedeniyle çalışır. bkz http://en.wikipedia.org/wiki/IEEE_floating_point fazla bilgi için.

Bu, temel olarak, yüzenlere tam sayılar eklemenizi sağlayan ve bunun bir sonuç olduğunu gösteren herhangi bir dilde çalışacaktır.

İşte operatör aşırı yüklemesine dayanan C ++ çözümü. Bir enumile bir arasında örtülü dönüştürmeye dayanır 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;
}

Kod zorluğunun olduğunu biliyorum ... ama ben golf oynamıştım. Üzgünüm.

Ruby - 13 karakter - Infinity çözümü

x=1e17;x==x+2

doğru döndürür

Ruby - 41 karakter - Op Aşırı Yükleme çözümleri

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

veya

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

Bu soruyu biraz kullanmam uygunsa, biraz daha Java ekleyeceğim. İşin püf noktası elbette yeni değil, ama bunun Java'da mümkün olması ilginç.

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

Ve sonuçlar:

(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

Bu VBScript çözümü, JavaScript çözümüme benzer şekilde çalışıyor. Önişlemci kullanmadım, ancak çözüm önemsiz görünüyor.

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

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