这个想法不是我的，尽管我不知道它的起源。很久以前（1998年，如果我没记错的话），我曾经在一次编程竞赛中遇到过它。任务是用您喜欢的语言编写一个2012 仅 输出的程序2012。值得注意的是，程序的2012任何一个字符被修改后，仍然必须输出。修改可以是插入，删除或替换。当然，修改将使该程序在语法上仍然有效。

由于我不懂所有的编程语言，因此我必须请听众帮助我并测试提交的答案。

补充：许多人评论说我对可接受修改的定义太模糊。这是我的第二次尝试：允许的修改将使您的程序在语法上仍然有效，并且不会导致程序崩溃。在那里，我认为应该涵盖所有编译时，链接时和运行时错误。尽管我确信无论如何某种语言都会出现一些奇怪的情况，所以当出现这种情况时，我们将逐一进行研究。

C，53个字符

main(){register*a="2012";(puts("2012"==a?a:"2012"));}

比脚本语言的答案长一点，并且遵循相同的基本原理。依赖于这样的事实，由于C语法的限制，在不使程序无效的情况下，唯一可以更改的字母就在字符串中！

编辑：削减4个字符。

重新编辑：增强鲁棒性，减少了一个字符。

重新编辑：更长，但更强大。&现在就尝试！（这次正确）。

更新：缩短了一点；击败了迄今为止所见的大多数方法。

更新：将int更改为void；应该击败我能想到的最后一种打破它的方法。

更新：我想出了另一种方法；将最后一个a（可能会腐烂）替换为0；使用两个字母的名称应该可以解决该问题。

更新：上次更新被撤销；假设不允许导致运行时错误的更改；a会很好。

更新：回溯更多；尝试取消引用*a也会导致段错误；因此void，不必从中挑出编译错误。

更新：最后的缩短；依赖于"2012"放置在一个地址（常见）上的字符串；并且文字字符串是只读的（也是常见的）。

更新：它花了我两个字符，但我打败了您那微不足道的分号！

19岁的Haskell

(\xx@2012->xx)$2012

或者，作为一个完整程序，

29

main=print$(\xx@2012->xx)2012

(\l@(_:_:t:[])->t:l)['0'..'2']

map(head.show.length)[[(),()],[],[()],[(),()]]

为了使其更易于修改（安全），我们还可以将数字本身用作列表元素–只需将其设置为字符串即可，以防止将逗号换成加号：

map(head.show.length)[["2012","2012"],[],["2012"],["2012","2012"]]

由于该字符串只是表达式的结果，因此我们也可以再次用它替换它-由于Haskell的懒惰，这不是问题

64 72

a=map(head.show.length.init)[[a,a,a],[a],[a,a],[a,a,a]]
main=putStrLn a

init此处的行为为“减一，但非负”。

u :: Enum a => (a,[b])->(a,b)
u(a,[b]) = (succ a , b)
p :: (a,b)->(a,[b])
p(a,b) = (a,[b])

ι :: (Int,())           -- Integral type to make sure you can't make it 0/0
ι = (\n -> (n-n,()))0

twothousandandtwelve = map(head.show.fst) [ u.p.u.p$ι , ι , u.p$ι , u.p.u.p$ι ]

（GHCi> twothousandandtwelve≡> "2012"）

现在您可以更改任何一个u，p反之亦然，但这总是会弄乱第二个tuple元素中列表堆栈的深度，从而触发编译时错误。

这个想法可以进一步扩展，以使整个文本可以紧凑地编码，易于阅读和编辑，并且仍然可以安全地修改单个字符。

main = print N2012
data Counter = Τv |Πy |Υj |Cε |Ho |Φϑ |Ωm |Sg |Πl |Pt |Yϑ |Γσ |Km |Φz |Εα |Av |Ζρ |Ηρ |Εv |Κs |Rζ |Γϑ |Οc |Dι |Rυ |Λd |Bγ |Wt |Xε |Ωη |Ιa |Hζ |Ed |Qj |Wπ |Κw |Qu |Γο |Oι |Mσ |Ωκ |Yg |Kυ |Aj |Du |Λζ |Nζ |Θτ |Pε |Yf |Βa |Τγ |Qx |Jη |Pδ |Iq |Ωn |Fv |Kl |Ψη |Δj |Θσ |Hd |Θq |Υs |Ht |Fρ |Jh |Lζ |Hμ |Υι |Ρζ |Ρv |Dυ |Wo |Iχ |Iζ |Γy |Kr |Sσ |Iμ |Μο |Xw |Εμ |Cσ |Yξ |Aq |Jf |Hσ |Oq |Hq |Nυ |Lo |Jκ |Ρz |Οk |Θi |Θα |Αη |Gh |Lξ |Jm |Ων |Zu |Μc |Qη |Κγ |Αψ |Χζ |Hρ |Γρ |Uϑ |Rj |Χγ |Rw |Mω |Πζ |Θρ |Ωd |Υh |Nt |Tη |Qψ |Θω |Εχ |Iw |Σx |Ηn |Mτ |Xt |Yx |Φε |Hh |Wη |Mf |Ψχ |Νγ |Βξ |Aϑ |Qp |Τϑ |Φm |Uy |Gy |Cd |Bχ |Λl |Οτ |Εa |Df |Li |Aι |Yi |Νκ |Vc |Γx |Φρ |Φp |Nξ |Kf |Tw |Λξ |Φn |Λa |Oψ |Υχ |Fψ |Xω |Τq |Οσ |Σj |Θψ |Το |Νr |Ιπ |Τi |Dτ |Φf |Μn |Χm |Ηε |Wa |Αχ |Uδ |Λf |Ρu |Qk |Wα |Uρ |Τζ |Lg |Qy |Τν |Jϑ |Βδ |Mε |Μι |Πβ |Bη |Eκ |Κz |Ηh |Fδ |Σp |Εγ |Qφ |Μτ |Νχ |Ψν |Pw |Χz |Εϑ |We |Nπ |Tυ |Wg |Bh |Tρ |Ζν |Λm |Ag |Dσ |Πι
                |Oη |Nν |Χl |Χp |Sξ |Πt |Οϑ |Wο |Yη |Cp |Tm |Ξs |Εβ |Ιb |Ρρ |Fs |Um |Ep |Jλ |Rρ |Ρξ |Ua |Οq |Γξ |Zη |Nη |Qτ |Nc |Ez |Xσ |Yφ |Ρy |Yε |Ετ |Φκ |Λω |Ωα |Μκ |Φw |Mt |Tk |Sf |Ηξ |Οb |Νπ |Κε |Mι |Kz |Vi |Ξx |Ψs |Αο |Qδ |Kt |Aσ |Οm |Ψδ |Λγ |Ακ |Hα |Wϑ |Τμ |Γγ |Jδ |Ικ |Ηϑ |Μp |Zo |Κn |Qz |Δe |Pe |Jο |Qι |Tu |Jν |Ξμ |Πω |Αm |Θw |Nε |Dy |Zξ |Υα |Dβ |Hο |Χv |Gr |Ωl |Jb |Σl |Vζ |Ξ  |Nx |Qs |Βh |Qg |Νx |Co |Rσ |Νυ |Χg |Ρt |Wy |Ηκ |Οa |Yμ |Uj |Uξ |Op |Μr |Ζα |Ξw |Mυ |Ar |Ργ |Zζ |Sv |Vy |Βo |Κι |Vϑ |Ξι |Uζ |Fμ |Su |Ιξ |Fϑ |Hi |Hw |Mv |Χχ |Θg |Sν |Pp |Mπ |Pk |Bκ |Lυ |Ρλ |Ιr |Uλ |Νo |Κο |Nh |Lε |Sw |Ξλ |Zυ |Mr |Bv |Κπ |Aγ |Dv |Pd |Ξσ |Μg |Oπ |Χξ |Nj |Kψ |Ξπ |Mκ |Gn |Ωe |Gγ |Pν |Yz |Nl |Οο |Ic |Pz |Ξf |Νω |Υμ |Ηq |Nw |Θm |Μx |Jε |Φy |Οz |Ξz |Ti |Οψ |Φγ |Tψ |Oγ |Zϑ |Ιk |Σw |Rf |Υi |Ωp |Vr |Υτ |Xl |Οβ |Πb |Δν |Οu |Jα |Ττ |Κl |Pf |Iκ |Gk |Πe |Σu |Δβ |Ωh |Nλ |Ξt |My |Πs |Βr |Mγ |Δω |Le |Zρ |Θv |Σs |Ηd |
               Bn |Κu |Δξ |Pτ |Ηα |Δu |Πμ |Ρh |Bω |Τλ |Gt |Αρ |Sh |Aο |Θδ |Δπ |Wq |Tφ |Γo |Γf |Λβ |Xυ |Mη |Δw |Qυ |Vν |Βτ |Γα |Μm |Μπ |Κζ |Θd |Fε |Ρτ |Οn |Αs |Wu |Ξh |Μz |Αν |Aε |Yq |Τε |Cz |Ωu |Ec |Ds |Wρ |Θϑ |Κp |Τδ |Mδ |Ηy |Go |Sb |Rξ |Σϑ |Yο |Jg |Vh |Kσ |Nδ |Ηψ |Γh |Rk |Eο |Μk |Ζk |Ψο |Ψμ |Zσ |Pβ |Ρd |Us |Hυ |Βi |Mχ |Σr |Βι |Sχ |Zγ |Δα |Sτ |Γp |Ns |Sn |Νn |Pξ |Νa |Sω |Σi |Τφ |Xο |Eδ |Ba |To |Vj |Sl |Κκ |Δh |Τχ |Gυ |Ρϑ |Bs |Dh |Μσ |Vd |Iϑ |Kg |Νμ |Dμ |Σγ |Πg |Γg |Εt |Fa |Ψn |Ρx |Αj |Mβ |Kλ |Ξψ |Fω |Qζ |Θj |Kπ |Gf |Oe |Yυ |Κk |Wω |Bδ |Lο |Cβ |Nf |Ol |Σo |Fn |Τβ |Βω |Dn |Ha |Πλ |Ss |Σy |Kϑ |Lp |Dδ |Dψ |Ωo |Xγ |Χk |Ωσ |Δa |Sκ |Jμ |Κt |Rc |Ηc |Lχ |Oε |Μλ |Cs |Il |Tι |Ra |Zα |Ωr |Ob |Wβ |Ον |Γν |St |Xλ |Kv |No |Rε |Kd |Mν |Np |Ωc |Δζ |Nβ |Zπ |Ok |Vι |Tδ |Vδ |Γz |Χα |Μs |Βυ |Xc |Xo |Vp |Γχ |Υf |Θπ |Πj |Pi |Γj |By |Φk |Υq |Ny |Rο |Γd |Ωj |Αy |Εo |Κy |Uc |Rm |Ph |Αδ |Ιl |Ιx |Δτ |Zt |Nq |Ct |Φi |Uv |Eπ
                |Κm |Rλ |Vu |Χσ |Τn |Μe |Φη |Ξβ |Εz |Σω |Bb |Ψε |Sε |Ρm |Δο |Vξ |Φo |Ωε |Zb |Σc |Dζ |Ξp |Rη |Ιψ |Δσ |Χη |Kj |Eμ |Qν |Ri |Ip |La |Νξ |Αγ |As |Nr |Δi |Oν |Ζx |Xκ |Pr |Ελ |Λb |Ψk |Ωβ |Pl |Ιy |Cμ |Ζc |Αg |Σρ |Dw |Ρq |Ιη |Pζ |Σa |Uq |Ρμ |Lω |Fh |Ζδ |Αd |Cψ |Κσ |It |Qκ |Fν |Αb |Ηg |Ιν |Ls |Jr |Ow |Je |Zx |Ld |Jl |Ζd |Μo |Χτ |Kα |Μβ |Mo |Σλ |Xρ |Μq |Ψb |Νd |Ρβ |Wδ |Μf |Κρ |Ηb |Ξτ |Qα |Λv |Zψ |Φt |Sδ |Εh |Rκ |Rμ |Χι |Κυ |Ηj |Pχ |Pη |Jσ |Ρσ |Ιχ |Kζ |Εδ |Nω |Iψ |Γμ |Vσ |Ψρ |Χυ |Αw |Kn |Al |Gj |Zj |Αc |Aζ |Ζi |Bz |Vπ |Πw |Αu |Qf |Bf |Ξo |Ρε |Λy |En |Ey |Wi |Σχ |Τc |Dχ |Fg |Ρo |Zm |Ψω |Fq |Μa |Ηt |Wc |Kε |Κτ |Χψ |Κβ |Λφ |Κq |Υm |Πx |Pj |Mi |Δy |Κχ |Lϑ |Wτ |Lη |Nd |Ωk |Iπ |Tα |Bο |Uε |Lc |Rp |Θx |Ρη |Lu |Μζ |Εd |Gρ |Χμ |Vγ |Ιζ |Πυ |El |Uk |Hc |Ξξ |Λx |Ιο |Μy |Ζm |Jw |Iε |Σφ |Αk |Σf |Ac |Ab |Αq |Δf |Θκ |Υa |Ζτ |Jc |Xμ |Sι |Κv |Ζj |Ει |Oω |Ηδ |Φv |Dα |Fτ |Ko |Et |Ψζ |Jx |Mk |Th |Βλ |Λχ |Οo |Υπ |
               Cζ |Θy |Λk |Γδ |Iυ |Σξ |Υϑ |Cι |Cχ |Εσ |Βψ |Iα |Τη |Eυ |Lφ |Lδ |Υw |Ξο |Uσ |Δb |Nϑ |Ζγ |Δz |Cο |Mb |Ξy |Γυ |Εk |Αζ |Vα |Τυ |Ιω |Wυ |Cτ |Ιγ |Yω |Ωy |Ηp |Ψψ |Ah |Dq |Βv |Ιw |Ox |Ξv |Οζ |Tχ |Πψ |Qb |Rδ |Aψ |Zμ |Ζg |Ψφ |Nφ |Δρ |Χe |Vχ |Ηυ |Ml |Σσ |Ζμ |Sz |Πκ |Sγ |Kq |Dη |Υk |Dt |Ξe |Sc |Νs |Μv |Ev |Ji |Rχ |Xπ |Αo |Lμ |Gδ |Fσ |Λϑ |Λe |Σb |Id |Hb |Γι |Βz |Sβ |Tg |Ζο |Δk |Dl |Λσ |Κϑ |Aw |Uγ |Lx |Uψ |Hs |Ωχ |Δφ |Wσ |Π  |Εe |Ro |Λο |Ud |Fχ |Δψ |Νh |Θμ |Zd |Kb |Οδ |Ex |Να |Φσ |Φω |Pm |Λυ |Xq |Si |Σδ |Gα |Bu |Βw |Eχ |Ρι |Gβ |Vο |Yh |Σε |Χq |Hι |Re |Zχ |Ζp |Eρ |Ωγ |Bξ |Hδ |Oξ |Γc |Μγ |Wφ |Πη |Wj |Ιq |Γs |Πο |Κj |Un |Rι |Dφ |Τl |Ωz |Pμ |Wr |Gω |Gi |Εu |Σq |Ρl |Iν |Zy |Rb |Νk |Ky |Uκ |Ησ |Hy |Ir |Tp |Εc |Bw |Εο |Cm |Εw |Ψf |Yχ |Ιρ |Hβ |Ιz |Vλ |Εj |Oδ |Qρ |Θν |Aρ |Ov |Zω |Gψ |Ij |Ξη |Ps |Φh |Οg |Dp |Ta |Ty |Οe |Uο |Rγ |Οr |Θp |Hλ |Νι |Vk |Νz |Tl |Ψi |Λs |Hη |Ζκ |Rz |Hx |Fξ |Ξn |Φe |Sπ |Ηw |Dκ |Ζω
                |Sr |Vψ |Ντ |Vω |Lv |Νg |Fκ |Jψ |Ζs |Oβ |Υζ |Δg |Fυ |Yκ |Χd |Zf |Φμ |Lt |Ξd |Oφ |Τp |Κh |Ψx |Vυ |Qπ |Θφ |Nψ |Ρχ |Rx |Υz |Ξκ |Ξχ |Qn |Pu |Υψ |Az |Xj |Σd |Φξ |Ws |Xα |Βm |Βf |Lh |Hv |Aω |Hν |Kχ |Ρψ |Aδ |Χx |Sη |Φx |Cκ |Jz |Dr |Xu |Ηζ |Ξζ |Gτ |Ca |Af |Aν |Bι |Mc |Ψg |Ωv |Ωs |Qω |Mψ |Lλ |Μα |Kμ |Vl |Yσ |Οι |Ve |Dν |Eg |Ιυ |Xι |Zν |Xϑ |Νζ |Ni |Sφ |Se |Ζa |Xδ |Νv |Wι |Jv |Jt |Ιh |Υv |Cη |Τd |Ψι |Τu |Ge |Πc |Bυ |Mϑ |Χλ |Δλ |Σψ |Μϑ |Απ |Vg |Κα |Sψ |Ζz |Λδ |Aκ |Λκ |Ga |Κb |Db |Jo |Τa |Fw |Τs |Βϑ |Eτ |Wk |Ξu |Ψl |Αι |Νψ |Δι |Qμ |Υn |Bτ |Ηs |Yw |Ye |Iο |Dο |Γe |Rβ |Qv |Xs |Ηη |Yo |Χj |Dω |Οπ |Uβ |Mλ |Qh |Fο |Βd |Ζr |Οv |Zφ |Αi |Dλ |Pb |Οx |Rv |Uz |Εν |Ψτ |Na |Aη |Βu |Ιd |Ηm |Υd |Wn |Qσ |Οp |Αr |Ηλ |Σι |Br |Cu |Ωζ |Θγ |Qo |Bρ |Bψ |Zβ |Πφ |Ρκ |Qϑ |Bj |Vε |Zz |Ζϑ |Za |Θt |Τψ |Ρο |Jq |Πf |Jφ |Τα |Xχ |Χn |Vo |Αt |Bg |Gs |Bi |Rϑ |Nι |Ρa |Υr |Υν |Λo |Γφ |Δo |Yρ |Χc |Ξα |Gq |Γm |Ωμ |Ζυ |Wζ |At |Mw |
               Cf |Επ |Fo |Οh |Tσ |Ηv |Sα |Ζq |Dk |Jπ |Ιm |Mj |Oi |Ψa |Qγ |Rn |Dξ |De |Γk |Ψm |Lα |Cl |Θο |Γq |Λc |Tx |Nm |Ki |Υο |Χr |Φs |Κi |Φλ |Vq |Αω |Ch |Tμ |Xb |Ζπ |Ym |Ζn |Eω |Ξj |Υκ |Τg |Uo |Ai |Sy |Τe |Ητ |Tτ |Λg |Bp |Δq |Χo |Pπ |Dγ |Δγ |Yπ |Ys |Ωδ |Ψσ |Sζ |Πξ |Rφ |Hj |Uf |Td |Ξk |Xψ |Οj |Cx |Φπ |Gλ |Φδ |Ej |Yψ |Ae |Φφ |Jγ |Qχ |Ξγ |Δp |Σg |Is |Eσ |Λπ |Cδ |Ιe |Cυ |Oh |Hm |Tb |Qi |Οl |Bε |Eψ |Hn |Ja |Σν |Γr |Ηu |Ζξ |Ζb |Nu |Θξ |Κd |Qο |Lq |Λw |Ηf |Kξ |Ευ |Rr |Τm |Εξ |Ψp |Χh |Ξi |Fπ |Μφ |Fu |Cξ |Aα |Pγ |Sk |Cω |Ηr |Αp |Ββ |Bx |Fp |Tζ |Pω |Λp |Lm |Jp |Bl |Φc |Vf |Τz |Εy |Λμ |Rd |Νf |Πρ |Ηx |Μψ |Γη |Bα |Συ |Iσ |Γt |Κξ |Io |Ζφ |Γl |Θf |Γλ |Υγ |Ψh |Xg |Tn |Iu |Bφ |Πχ |Λq |Χπ |Bϑ |Εm |Κφ |Λt |Ιu |Ρs |Ιβ |Ωg |Yν |Lσ |Ζι |Eι |Aτ |Φa |Pα |Θz |Ψκ |Θs |Θη |Ηl |Φζ |Bt |Ρυ |On |Ξε |Tf |Gp |Mα |Μi |Kβ |Σο |Ωξ |Νl |Iz |Fk |Dj |Bπ |Nz |Xr |Mp |Χω |Sϑ |Hu |Αμ |Js |Βn |If |Τw |Ηz |Σz |Po |Yj |Ημ |Yβ |Σm |Do
                |Ηχ |Κg |Θo |Ζh |Ψj |Ψu |Ωφ |Δμ |Γa |Bν |Ιε |Oz |Νq |Υp |Qλ |Υc |Υy |Kc |Kh |Ew |Wγ |Νβ |Ωλ |Οξ |Zι |Yr |Sυ |Γπ |Bm |Μj |Pa |Os |Χδ |Κδ |Εx |Iγ |Eη |Fλ |Tγ |Yλ |Hξ |Φq |Τξ |Ql |Δn |Zn |Ot |Sa |Φψ |Nμ |Ξr |Ξc |Φj |Gl |Oλ |Rπ |Am |Mο |Gx |Fd |Cg |Χu |Lι |Wv |Ζt |Jυ |Pσ |Σκ |Wκ |Pv |Ιg |Ωι |Δx |Φl |Eb |Δυ |Cr |Nχ |Ογ |Νφ |Gu |Ασ |Λi |Rτ |Eh |Xη |Md |Wm |Tt |Πα |Υe |Βk |Ju |Dρ |Χβ |Οs |Γi |Kι |Κe |Mm |Χf |Oκ |Vb |Γβ |Οy |Vv |Νϑ |Hl |Λα |Wξ |Om |Βφ |Ρp |Φβ |Βb |Αυ |Υδ |Χφ |Pλ |Νρ |Υλ |Ul |Kγ |Qc |Νm |Πz |Hφ |Es |Ψπ |Xm |Xξ |Tν |Eλ |Ao |Ak |Ka |Ζη |Xk |Γψ |Βπ |Fβ |Βρ |Xx |Βζ |Iτ |Pϑ |Εb |Ψγ |Τk |Gm |Yn |Xν |Νu |Hϑ |Εr |Τπ |Uw |Mh |Og |Μυ |Tj |Λν |Qm |Xn |Ην |Νi |Kη |Zv |Ιι |Ση |Yk |Dx |Aχ |Ou |Fy |Cα |Θl |Γκ |Ax |Vκ |Cn |Cλ |Ξϑ |Wε |Υl |Ψt |Ωa |Θe |Ξω |Ηo |Ll |Bζ |Kw |Αβ |Δc |Oυ |Βj |Jβ |Νε |Eϑ |Ξg |Tz |Cc |Ry |Sρ |Ψz |Yα |Pq |Υg |Jn |Vμ |Σk |Ck |Ωt |Zg |Pι |Hω |Λλ |Aμ |Wλ |Ιλ |Βc |Ξa |
               Jk |Πϑ |Ιt |Εψ |Hε |Ωϑ |Εη |Ie |Κω |Yc |Iβ |Ου |Hg |Θr |Nn |Uμ |Ζv |Ζχ |Jρ |Pο |Ng |Be |Δv |Fζ |Ρe |Qe |Cq |Κf |Θλ |Tϑ |Ξq |Me |Βq |Oα |Θc |Qr |Δt |Dm |Yu |Ru |Σh |Λr |Yy |Εε |Μχ |Mφ |Δδ |Kφ |Cγ |Ζσ |Iω |Au |Wb |Κc |Πq |Ωω |Pυ |Γn |Nγ |Cv |Βχ |Φg |Gο |Ug |Kο |Βκ |Wμ |Hτ |Hχ |Ue |Οw |Sμ |Sm |Υω |Yb |Χa |Ιi |Κν |Πu |Κψ |Uτ |Lβ |Fj |Pn |Εf |Τσ |Qε |Ψo |Λρ |Oϑ |Πν |Ts |Ηο |Μρ |Ff |Ψβ |Ne |Nκ |Bλ |Bσ |Mx |Πp |Υσ |Ιn |Αz |Fz |Ηa |Uν |Mζ |Δϑ |Yι |Ζe |Ψα |Tο |Βg |Lπ |Ζf |Αλ |Em |Θh |Gπ |Γω |Kω |Tξ |Σn |So |Im |Φυ |Ξb |Ii |Λι |Xz |Kδ |Μω |Uυ |Wf |Χb |Sλ |Lγ |Οη |Ιs |Xβ |Pκ |Bc |Ιp |Od |Αn |Va |Tω |Ζw |Ιτ |Θε |Ρi |Gι |Τh |Υx |Nτ |Δη |Εφ |Kx |Xa |Gν |Ft |Yt |Qd |Gσ |Ξυ |Εs |Nσ |Νc |Λj |Υu |Ρc |Ψξ |Δm |Qβ |Μu |Υb |Nk |Ωτ |Κr |Δd |Iλ |Πa |Ωρ |Χν |Μh |Jξ |Μμ |Fc |Iφ |Zr |Ux |Φb |Πo |Gd |Eζ |Αα |Νν |Λz |Vη |Pψ |Ωf |Lρ |Cb |Ν |Α |Χ |Ω |Zτ |Τκ |Αε |Bβ |Uι |Fi |Ui |Βx |Ωq |Βp |Λh |Uu |Ωw |Xp |Ζβ |Λτ
 | N2012 deriving(Enum); instance Show Counter where show = show . fromEnum

的JavaScript

我相信这是运行时错误的证明，任何单个更改都应该导致编译错误或单个警告说2012。

编辑：代码会在类似的地方产生运行时错误if("alert(2012 "==r)，我移动了try部分来处理它。

编辑：不错的一个Vilx-，但是可修复的:-)现在插入该分号的括号不匹配。

编辑：但是，逗号可以和分号做同样的事情，即有很多选择，我想我已经解决了，但是现在有很多代码。

编辑：简化了一点。

编辑：在一系列的错误修正中的另一个。

编辑：这种感觉比防弹更长，更复杂，但是至少应该注意~eval和!eval。

var q="alert(2012 "
var p=1
try{
    if("alert(2012 "==q){
        if(eval(((p=5,q+")")||alert(2012)))){
            if(p!==5){
                alert(2012)
            }
        }
    }
    else{
        alert(2012)
    }
}
catch(e){
    alert(2012)
}

Perl，49个字符

  do{
use strict;$_=2012;;2012==$_&&0-print||die}

根据JB的回答，但这实际上满足了规范。详尽的检查表明，每个单字符删除，插入或替换都会使输出保持不变，或者导致程序在运行时崩溃（由非零返回值指示，并输出到stderr），至少与插入和删除的时间相同。替换仅限于可打印的ASCII字符。

（没有限制，该任务在Perl中是不可能的：Perl解析器的一个鲜为人知的功能是，它在遇到Ctrl-D或Ctrl-Z字符时会停止，因此将其中一个插入任何文件之前将其导入不执行任何操作的有效Perl程序。）

编辑：通过更换刮了一个多字符1==print用0-print。

脑干

我试图说服自己这是可能的，并且我可以肯定地说，我可能已经做得太过分了。我对环境做了一些假设：

1. 无限循环被认为是“崩溃”。在某些解释器中，可以通过递减零或在存储位置零的左侧来实现类似的条件。许多解释器很难在运行时崩溃。我仅通过使用最简单，最明显的无限循环来避免停顿问题。
2. 方括号不匹配被视为编译错误。
3. 这仅在程序输出通过管道返回到其自身输入的环境中有效。我用它来验证它确实输出了“ 2012”。这是我可以删除所有输出字符之一的唯一方法。

不幸的是，如果您采取更严格的措施，我担心这将是不可能的。这是我的解决方案：

++++++++++++++++++++++++++++++++++++++++++++++++++
.--.+.+.
,--------------------------------------------------[]
,------------------------------------------------[]
,-------------------------------------------------[]
,--------------------------------------------------[]
,[]EOF = 0

基本上，您可以更改输出代码或验证代码，但不能两者都更改。其中之一保证可以工作。如果其中之一没有，它将“崩溃”。

Python2

import sys;xx='2012';(
1/(sys.stdout.write(xx=='2012' and xx or 2012)==None))

我必须稍稍更改Ray的测试脚本以对其进行测试，因为stdout重定向会破坏它。将空的dict传递给exec可以避免污染名称空间

exec(prog, {}, {})

Brain-Flak，44 + 3 = 47字节[不竞争]

这使用Brain-Flak的-A标志并将字符输出2012到STDOUT

((((((((()()()){}){}){}()){})[()])[()])()())

在线尝试！

备用，50字节

(((((()()()()){}){}){}){})({({}[()])}{}[()()()()])

在线尝试！

说明

对以上任一代码进行任何单个字符修改都会导致程序出错。

思思，非竞争

最终，我认为我找到了一种有效的语言。它长得令人难以置信，而且语言比问题要新，但仍然感觉像是一种成就。

1 set xx 2012
2 set y xx=2012
3 jumpif y 55
4 set xx 2012
828 set x xx
829 set ax xx
830 set xa xx
831 set axx xx
832 set xax xx
833 set xxa xx
834 set bx xx
835 set xb xx
836 set bxx xx
837 set xbx xx
838 set xxb xx
839 set cx xx
840 set xc xx
841 set cxx xx
842 set xcx xx
843 set xxc xx
844 set dx xx
845 set xd xx
846 set dxx xx
847 set xdx xx
848 set xxd xx
849 set ex xx
850 set xe xx
851 set exx xx
852 set xex xx
853 set xxe xx
854 set fx xx
855 set xf xx
856 set fxx xx
857 set xfx xx
858 set xxf xx
859 set gx xx
860 set xg xx
861 set gxx xx
862 set xgx xx
863 set xxg xx
864 set hx xx
865 set xh xx
866 set hxx xx
867 set xhx xx
868 set xxh xx
869 set ix xx
870 set xi xx
871 set ixx xx
872 set xix xx
873 set xxi xx
874 set jx xx
875 set xj xx
876 set jxx xx
877 set xjx xx
878 set xxj xx
879 set kx xx
880 set xk xx
881 set kxx xx
882 set xkx xx
883 set xxk xx
884 set lx xx
885 set xl xx
886 set lxx xx
887 set xlx xx
888 set xxl xx
889 set mx xx
890 set xm xx
891 set mxx xx
892 set xmx xx
893 set xxm xx
894 set nx xx
895 set xn xx
896 set nxx xx
897 set xnx xx
898 set xxn xx
899 set ox xx
900 set xo xx
901 set oxx xx
902 set xox xx
903 set xxo xx
904 set px xx
905 set xp xx
906 set pxx xx
907 set xpx xx
908 set xxp xx
909 set qx xx
910 set xq xx
911 set qxx xx
912 set xqx xx
913 set xxq xx
914 set rx xx
915 set xr xx
916 set rxx xx
917 set xrx xx
918 set xxr xx
919 set sx xx
920 set xs xx
921 set sxx xx
922 set xsx xx
923 set xxs xx
924 set tx xx
925 set xt xx
926 set txx xx
927 set xtx xx
928 set xxt xx
929 set ux xx
930 set xu xx
931 set uxx xx
932 set xux xx
933 set xxu xx
934 set vx xx
935 set xv xx
936 set vxx xx
937 set xvx xx
938 set xxv xx
939 set wx xx
940 set xw xx
941 set wxx xx
942 set xwx xx
943 set xxw xx
944 set yx xx
945 set xy xx
946 set yxx xx
947 set xyx xx
948 set xxy xx
949 set zx xx
950 set xz xx
951 set zxx xx
952 set xzx xx
953 set xxz xx
954 set xxx xx
955 print xx

关于思思

Sisi是一种受汇编和QBasic启发的玩具语言。应对这一挑战很有用，因为其语法非常受限制。

• 它只有四个命令：set，print，jump，和jumpif。
• 所有命令都有固定的对等。
• 所有行都必须具有行号，该行号严格增加。
• 表达式仅允许在set语句中使用。它们最多只能包含一个操作，该操作必须是二进制的。特别是：更改print xx为print -xx语法错误。
• 变量名称必须由小写字母组成。
• 最重要的是：没有注释语法！

该程序

该程序的核心是这一部分：

1 set xx 2012
2 set y xx=2012
3 jumpif y 55
4 set xx 2012
955 print xx

我们将其存储2012在中xx，然后测试是否成功，然后将测试结果存储在中y。如果y是真实的，则跳到第55行。（跳到不存在的行号只需快速前进到下一行。）

辐射硬化

• 如果第1行中的分配被修改，y则为false，则不会发生跳转，第4行设置xx为2012。
• 如果修改了第2行中的分配或第3行中的跳转条件，则我们不在乎：xx无论是否跳转，都将设置为2012。
• 第3行中的跳转目标可以更改为小至5或大至955。任何可能的修改都会print或早或晚将其更改为在线955。一种修改不可能向后跳（创建循环）或越过程序末尾。
• 如果第4行中的分配被修改，我们将不在乎：第1行的分配是正确的，我们将跳过第4行。
• 如果第955行被修改，我们可能会有问题。关于Sisi的一件不幸的事是，未初始化的变量默认为0，因此这样的修改print ax不是错误。丑陋但有效的解决方案是第828-954行，该行将2012分配给每个可能的变量，且与的编辑距离为1 xx。这样可以确保对决赛的任何修改print xx仍将在2012年进行。
• 如果修改了行号，则：1）它将不正常并且是语法错误，或者2）不会影响程序流程。我们可能会担心的主要修改-将第4行更改为94，从而在跳转到55之后插入它-没关系，因为它所做的只是将2012 xx重新分配给了该行。

蟒蛇

有点冗长（现在已修复了print和之间的那个讨厌的分号(）：

a=[0]
(lambda x:print(
set(['2012']).intersection(set(["2012"])).pop()))(
*a)

T-SQL 2012、55

DECLARE @n CHAR(4)='2012'PRINT IIF(@n='2012',@n,'2012')

我已经制作了一个python脚本来判断所有python解决方案。该脚本使用许多不同的方法打破了第一个和第三个python解决方案。第二种使用lambda保护自身的解决方案是坚不可摧的。第二个python解决方案在python 3中。我将其修改为python 2格式，然后判断程序是否将其破坏。

这是评委脚本。

from StringIO import StringIO
import sys

def run(prog, atexp=True):
    stdout = sys.stdout
    fakeOut = StringIO()
    try:
        sys.stdout = fakeOut
        # exec prog # running exec directly will break some solutions by mistake
        exec(prog, {}, {}) 
        return fakeOut.getvalue().rstrip() == '2012'
    except:
        return atexp
    finally:
        sys.stdout = stdout
    return True

def judge(prog):
    RED = '\x1b[31m'
    WHITE = '\x1b[37m'
    ans = True
    chars = """abcdefghijklmnopqABCDEFGHIJKLMNOP`~1234567890!@#$%^&*()_+-=[]{};:'"<>,./?"""
    # attack by replace
    if not run(prog):
        print "Are you joking...This program don't print 2012 itself."
        return False
    p = list(prog)
    for i in xrange(len(prog)):
        for c in chars:
            p[i] = c
            r = run(''.join(p))
            if not r:
                print 'Attack by replace success'
                print 'origin:\n'+prog
                print 'modified:\n'+''.join(p[:i])+RED+c+WHITE+''.join(p[i+1:])
                ans = False
        p[i] = prog[i]
    # attack by delete
    for i in xrange(len(prog)):
        p = prog[:i]+prog[i+1:]
        r = run(''.join(p))
        if not r:
            print 'Attack by delete success'
            print 'origin:\n'+prog
            print 'modified:\n'+''.join(p[:i])+RED+'{|}'+WHITE+''.join(p[i:])
            ans = False
    # attack by insert
    for i in xrange(len(prog)+1):
        p = list(prog)
        p.insert(i, ' ')
        for c in chars:
            p[i] = c
            r = run(''.join(p))
            if not r:
                print 'Attack by insert success'
                print 'origin:\n'+prog
                print 'modified:\n'+''.join(p[:i])+RED+c+WHITE+''.join(p[i+1:])
                ans = False
    if ans: 
        print 'Amazing! judgement passed'
    return ans

p1="""xx='2012'
print(xx if xx=='2012' else
'2012')
"""
p2="""import sys
a=[0]
(lambda x:sys.stdout.write(
set(['2012']).intersection(set(["2012"])).pop()))(
*a)
"""

p3="""print sorted(['2012',
'2012','2012']).__getitem__(1)
"""
p4="""print 2012
"""
judge(p3) 

Mathematica，23个字符

注意： ”/。” 表示“替换”

2012/.Except@2012->2012

使用Javascript - 68，77，84，80个字符

这是今年应该可行的解决方案：）

a="eval(alert(new Date().getFullYear()))" 
a.length==37?eval(a||a||a):alert(2012)

这是测试小提琴。

更新1：修复了eval（+ a）破坏了它的问题（感谢eBusiness）。

更新2：固定为'|' 案例（再次感谢eBusiness）。

更新3：修复了'>'情况（再次感谢eBusiness）。并打破了'1'的情况:(

Ruby 1.9-43个字符

qq=[:p,2012]
b if qq!=[:p,2012]
send(
*qq)

未经测试，所以脱离。

Excel，14个字符（略作弊）：

{=2012} (in a 2x1 array with one cell hidden)

对数组的任何有效更改都会影响两个单元格的内容，并且仅更改一个单元格就会触发错误消息。

当然，如果您认为它实际上只是一个公式，而不是被约束为相同的2个公式，则这种情况会破裂。

Java 7

class M{
  static String c(){
    String a = "2012",
           b = "2012";
    return a.equals(b)           // 1
            ? a                  // 2
            : a.equals("2012")   // 3
               ? a               // 4
               : b;              // 5
  }

  public static void main(String[]a){
    System.out.print(c());
  }
}

说明：

1. 不更改任何内容，它将采用以下路径：1→2（并且将返回a的值2012）。
2. 如果a以任何方式修改String的内容，它将采用以下路径：1→3→5（它将返回b的不变值2012）。
3. 如果b以任何方式修改String的内容，它将采用以下路径：1→3→4（并且将返回a的不变值2012）。
4. 如果a.equals(b)在@ 1上将@修改为a.equals(a)，，b.equals(b)否则!a.equals(b)它将仍然采用相同的以下路径：1→2（并且将返回a的不变值2012）。
5. 如果a将@ 2更改为on b，它将仍然采用以下路径：1→2（它将返回b的不变值2012）。
6. 如果第3、4或5行中的a或b变为相反，它仍将采用以下路径：1→2（并且将返回a的不变值2012）。
7. 如果以任何方式修改@ 3上String的内容，它仍将采用以下路径：1→2（并且将返回a的不变值2012）。
8. 改变M的class M或者a在main(String[]a)另一个有效的字符可以在没有任何更改代码的功能来完成。
9. 任何其他更改都将导致编译错误（某些回车符/空格可能会被删除/添加）。

在这里尝试所有这些修改，以确认它们仍然可以打印2012。

如果您想按照我想知道的OP规则找到打破它的任何方法，那么我可以想出一些办法解决它。
与大多数类似的问题不同，该问题只修改了一个字符，该问题允许所讨论的编程语言的基本结构完整无缺，因此Java最终可以一人参与竞争（让我们面对现实，Java几乎-永远不会赢得任何回报）。此SE xD）。

Ruby 1.9

puts (
rx=2012
)==2012?rx:2012.send(
:abs)

我构建了一个简短但简单的程序，请您根据上述规则进行破解。如果#插入a 以注释掉该行的其余部分，我什至找不到输出发生变化的位置（不破坏代码）。

斯卡拉，95岁

（如果跳过无意义的部分，则为54）

object Main{def main(ar:Array[String]){print(((s:String)=>if(s=="2012")s else"2012")("2012"))}}

C＃

当然不是那么简单吗？...

class program
{
    static void Main()
    {
        var result = "2012";

        if (result == "2012")
            Console.WriteLine(result);
        else
            Console.WriteLine("2012");
    }
}

好吧，我想念什么？

PHP，30岁

<?=$i=2012;$i==2012?$i:2012;?>

出租车，396字节

2012 is waiting at Starchild Numerology.2012 is waiting at Starchild Numerology.Go to Starchild Numerology: w 1 r 3 l 2 l 3 l 2 r.Pickup a passenger going to Equal's Corner.Pickup a passenger going to Equal's Corner.Go to Equal's Corner: w 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery: n 3 r 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office: n 1 l 1 r.

为人类格式化，即：

2012 is waiting at Starchild Numerology.
2012 is waiting at Starchild Numerology.
Go to Starchild Numerology: w 1 r 3 l 2 l 3 l 2 r.
Pickup a passenger going to Equal's Corner.
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner: w 1 l.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: n 3 r 1 r 1 r.
Pickup a passenger going to Post Office.
Go to Post Office: n 1 l 1 r.

通过阅读其他答案，解决方案似乎是选择一种脆弱的语言，设置值，检查值，打印值。

SmileBASIC

OPTION STRICT
VAR A$=@2012
GOTO A$@2012
IF SHIFT(A$)THEN VAR B
?A$VAR C
B=C

首先，我们启用严格模式。这迫使您在使用所有变量之前先声明它们，并防止诸如将？A $更改为？B $之类的事情。

接下来，创建一个名为“ A $”的字符串变量，并将其值设置为“ @ 2012”。为了确保A $的值没有被弄乱，该程序将尝试跳转到标签，并且程序中唯一的标签为@ 2012。

现在，A $绝对是“ @ 2012”，但是在打印之前，需要删除@。SHIFT（）删除字符串或数组中的第一项（就像pop（）一样，但从另一端开始）。要丢弃SHIFT返回的值，该值将传递到IF / THEN块，该块不执行任何操作。万一有人试图注释掉该行，我们声明一个变量“ B”，稍后将使用它。如果将VAR注释掉，则最后一行将引发Undefined variable错误。

现在，将打印A $，并且还有另一个VAR来防止注释。最后一行只是确保变量B和C都已声明。

哈斯克尔，65岁

import Data.List
nub$filter(\x->x==2012||x==2012)([2012]++[2012])

Perl，84岁

use strict;use English;$ARG=
2032;s/.*/2012/unless$ARG eq 2012;$SUBSEP=2012;print;

失败的方法：

use strict;use English;"2012 2012"=~
/2012|2012|2012/;print$MATCH||$MATCH;

PHP， 43 48

 $a='2012';echo($a==date('Y')?abs($a):date('Y'));

红宝石（57 36）

编辑和36个字符中的另一个。

p((x,y='2012','2012';x=='2012'?x:y)) 

我猜想使用字符串是很安全的，因为那个减号不再起作用。

编辑下一个尝试（36个字符）[没关系，在-之后添加一个p结果-2012]

p [2012,2012] .find（2012）.first || 2012

这只适用于今年，但将来也适用于类似的竞赛:)（15.chars）

p Time.now.year

请注意，这种替换也有效：

p Time.new.year

57个字符。如果算上换行符，它也是76个字符。

p( 
#
#
#
#
#
#
#
#
#
#
__LINE__.to_s.prepend(
#
#
#
#
#
#
#
__LINE__.to_s))

问23

{$[2012~m:2012;m;2012]}

。

q){$[2012~m:2012;m;2012]}`
2012
q){$[1012~m:2012;m;2012]}`
2012
q){$[2012~m:1012;m;2012]}`
2012
q){$[2012~m:2012;m;1012]}`
2012
q){$[2012~\m:2012;m;2012]}`
2012
q){$[2012~/m:2012;m;2012]}`
2012
q){$[2012~'m:2012;m;2012]}`
2012

等等

嗯..让我尝试：

class a {
  int i=2012, j=2012;
  public static void main(String[] args){if (i==j)
    {System.out.println(i);}else{System.out.println(i);}
  }
}

不含空格的128个字符。

class a{int i=2012, j=2012;public static void main(String[] args){if(i==j){System.out.println(i);}else{System.out.println(i);}}}

的PHP

我希望它坚不可摧:)

$a="2012";ob_start();function c(){ob_clean();return"2012";}function ee($s){return crc32($s)+printf($s);}
print(ee($a)==1367825560?die()
:c());

Groovy：26

x=2012;print x^2012?2012:x

a

print(- -(function(ab,ba)assert(ab==ba)return- -ab end)(2012,2012))