Essa ideia não é minha, embora eu não saiba de onde se originou. Uma vez eu o conheci em um concurso de programação há muito tempo (1998, se bem me lembro). A tarefa é escrever um programa em seu idioma favorito que produz 2012 e somente 2012 . O problema é que o programa ainda deve ser produzido 2012depois que qualquer um de seus caracteres for modificado. A modificação pode ser inserção, exclusão ou substituição. Obviamente, a modificação será tal que o programa ainda é sintaticamente válido.

Como não conheço todas as linguagens de programação, tenho que pedir à audiência que me ajude e teste as respostas enviadas.

Adicionado: Muitos comentaram que minha definição de modificações aceitáveis ​​é muito vaga. Aqui está minha segunda tentativa: As modificações permitidas deixarão seu programa sintaticamente válido e não causarão falha. Lá, acho que isso deve cobrir todos os erros de tempo de compilação, tempo de link e tempo de execução. Embora eu tenha certeza de que, de alguma forma, haverá algum caso estranho em algum idioma, então, quando isso surgir, veremos isso individualmente.

C, 53 caracteres

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

Um pouco mais do que a linguagem de script responde e segue o mesmo princípio básico. Confia no fato de que, devido às restrições da sintaxe de C, as únicas letras que seriam possíveis de serem alteradas sem invalidar o programa estão dentro das strings!

Editar: Raspou 4 caracteres.

Reedit: Robustez aumentada, raspou um personagem.

Re-redit: Mais longo, mas mais robusto. Apenas tente o seu &agora! (Corretamente desta vez).

Atualização: Encurtado um pouco; derrota a maioria das abordagens vistas até agora.

Atualização: Int alterado para anular; deve derrotar a última abordagem possível para quebrá-la que eu possa pensar.

Atualização: Pensei em outra abordagem; substituindo o último a(pode apodrecer) por 0; o uso de nomes de duas letras deve lidar com esse problema.

Atualização: Última atualização revogada; assumindo que alterações que causam erros de tempo de execução não são permitidas; avai funcionar muito bem.

Atualização: Retrocedendo um pouco mais; a tentativa de desreferenciar *atambém irá falhar; portanto, usar voidpara provocar um erro de compilação não deve ser necessário.

Atualização: E um encurtamento final; depende da cadeia "2012"ser colocada em apenas um endereço (o que é comum); e que cadeias literais são somente leitura (também comuns).

Atualização: custou-me dois personagens, mas eu derrotei seu ponto-e-vírgula insignificante!

Haskell, 19

(\xx@2012->xx)$2012

ou, como um programa completo,

29

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

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

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

Para torná-lo mais modificável (com segurança), também podemos usar o próprio número como elemento de lista - basta criar strings para impedir a troca de vírgulas por mais ':

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

Como essa string é apenas o resultado da expressão, também podemos substituí-la novamente por isso - não é um problema, graças à preguiça de Haskell

64 72

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

Os initatos como "um menos, mas não negativo" aqui.

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" )

Agora você pode alterar qualquer um uparap vice-versa, mas isso sempre atrapalha a profundidade dos empilhamento de listas no segundo elemento da tupla e, assim, desencadeia um erro em tempo de compilação.

Essa idéia poderia ser expandida ainda mais, de forma que textos inteiros pudessem ser codificados de maneira compacta, fácil de ler e editar e ainda protegidos da modificação de caracteres únicos.

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

Acredito que seja à prova de erro de tempo de execução, qualquer alteração única deve resultar em um erro de compilação ou em um único alerta dizendo 2012.

Edit: Código cometeria um erro de execução em algo como if("alert(2012 "==r), mudei a seção try para lidar com isso.

Edit: Nice one Vilx-, mas corrigível :-) Agora há uma incompatibilidade de colchetes para inserir esse ponto e vírgula.

Edit: Mas então uma vírgula poderia fazer a mesma coisa que o ponto-e-vírgula, que é uma série de opções, eu acho que corrigi-lo, mas há uma enorme quantidade de código agora.

Edit: Simplificado um pouco.

Editar: Mais uma em uma série infinita de correções.

Edit: Isso meio que parece mais longo e complicado do que à prova de balas, mas deve pelo menos cuidar de ~evale !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 caracteres

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

Baseado na resposta de JB , mas este realmente satisfaz as especificações . Uma verificação exaustiva indica que cada exclusão, inserção ou substituição de um caractere mantém a saída inalterada ou causa a falha do programa durante a execução (como indicado por um valor de retorno diferente de zero e a saída para stderr), pelo menos enquanto inserções e as substituições são restritas a caracteres ASCII imprimíveis.

(Sem a restrição, a tarefa é impossível no Perl: um recurso pouco conhecido do analisador Perl é que ele pára quando encontra um caractere Ctrl-D ou Ctrl-Z, inserindo qualquer um deles na frente de qualquer arquivo em um programa Perl válido que não faz nada.)

Edit: Raspou mais um char, substituindo 1==printpor 0-print.

Brainfuck

Estou tentando me convencer de que isso é possível e tenho certeza de que talvez tenha me esticado um pouco demais. Fiz algumas suposições sobre meu ambiente:

1. Um loop infinito é considerado um 'travamento'. Uma condição semelhante poderia ser alcançada diminuindo o zero passado ou à esquerda do local zero da memória em certos intérpretes. Muitos intérpretes são difíceis de travar no tempo de execução. Evito o problema da parada usando apenas o loop infinito mais simples e óbvio.
2. Colchetes não correspondentes são considerados um erro de compilação.
3. Isso funcionará apenas em um ambiente em que a saída do programa seja canalizada de volta para sua própria entrada. Uso isso para verificar se realmente produziu '2012'. Esta é a única maneira que eu poderia contornar simplesmente excluindo um dos caracteres de saída.

Infelizmente, se você ficar mais rigoroso, temo que isso seja impossível. Aqui está a minha solução:

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

Basicamente, você pode alterar o código de saída ou o código de verificação, mas não os dois. Um deles é garantido para o trabalho. Se um deles não, ele irá 'travar'.

Python2

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

Eu tive que mudar um pouco o script de teste de Ray para testar isso, pois o redirecionamento stdout estava quebrando. Passar dicts vazios para exec evita poluir o espaço para nome

exec(prog, {}, {})

Flacidez Cerebral , 44 + 3 = 47 bytes [Não Competente]

Isso usa a -Abandeira do Brain-Flak e gera os caracteres 2012para STDOUT

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

Experimente online!

Alternativa, 50 bytes

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

Experimente online!

Explicação

Qualquer modificação de caractere único em qualquer um dos códigos acima causará erro no programa.

Sisi , não concorrente

Finalmente, acho que encontrei um dos meus idiomas que funciona. É terrivelmente longo, e a linguagem é mais nova que a pergunta, mas ainda parece uma conquista.

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

Sobre Sisi

Sisi é uma linguagem de brinquedo inspirada em assembly e QBasic. É bom para esse desafio porque sua sintaxe é extremamente limitada.

• Ele tem apenas quatro comandos: set, print, jump, e jumpif.
• Todos os comandos têm aridade fixa.
• Todas as linhas devem ter números de linha, que estão aumentando estritamente.
• Expressões são permitidas apenas em setinstruções. Eles podem conter apenas (no máximo) uma operação, que deve ser binária. Em particular: mudar print xxpara print -xxé um erro de sintaxe.
• Os nomes das variáveis ​​devem ser compostos por letras minúsculas.
• Mais importante: não há sintaxe para comentários !

O programa

O núcleo do programa é esta parte:

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

Nós armazenamos 2012em xx, em seguida, testar se que foi bem sucedida e armazenar o resultado do teste no y. Se yfor verdade, pule para a linha 55. (Salta para números de linhas inexistentes, basta avançar rapidamente para a próxima linha.)

Endurecimento por radiação

• Se a atribuição na linha 1 for modificada, então yé falsey, o salto não acontece e a linha 4 é definida xxpara 2012.
• Se a atribuição na linha 2 ou a condição de salto na linha 3 for modificada, não nos importamos: xxserá definido como 2012 se fizermos o salto ou não.
• O alvo de salto na linha 3 pode ser alterado para 5 ou 955. Qualquer modificação possível o coloca printna linha 955 mais cedo ou mais tarde. Não é possível com uma modificação saltar para trás (criando um loop) ou passar o final do programa.
• Se a atribuição na linha 4 for modificada, não nos importamos: a atribuição da linha 1 estará correta e passaremos da linha 4.
• Se a linha 955 for modificada, podemos ter um problema. A única coisa infeliz sobre Sisi é que variáveis ​​não inicializadas são padronizadas 0, portanto, uma modificação como print axnão é um erro. A solução feia mas eficaz são as linhas 828-954, que atribuem 2012 a todas as variáveis ​​possíveis com uma distância de edição de 1 a partir de xx. Isso garante que qualquer modificação na final print xxainda seja impressa em 2012.
• Se um número de linha for modificado, 1) estará fora de ordem e será um erro de sintaxe ou 2) não afetará o fluxo do programa. A principal modificação com a qual podemos nos preocupar - alterar a linha 4 para 94, inserindo-a após o salto para 55 - não importa, porque tudo o que faz é atribuir 2012 xxnovamente.

Pitão

Um pouco detalhado (agora com uma correção para esse ponto printe vírgula irritante entre e (!):

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')

Eu fiz um script python para julgar todas as soluções python. O script quebra a primeira e a terceira soluções python, com muitos métodos diferentes. E a segunda solução, use lambda para se proteger, é inquebrável. A segunda solução python está no python 3. Modifiquei-o no formato python 2 e depois julguei que o programa o quebrou.

Aqui está o script do juiz.

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 caracteres

Nota: "/." significa "substituir"

2012/.Except@2012->2012

Javascript - 68, 77, 84 , 80 caracteres

Aqui está uma solução que deve funcionar este ano :)

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

Aqui está o teste .

Atualização 1: Foi corrigido o problema em que eval (+ a) o quebrou (graças ao eBusiness).

Atualização 2: corrigida para o '|' case (obrigado novamente eBusiness).

Atualização 3: Corrigida para o caso '>' (obrigado novamente eBusiness). E quebrou para o caso '1' :(

Ruby 1.9 - 43 caracteres

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

Não testado, então se afaste.

Excel, 14 caracteres (trapaça ligeiramente):

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

Qualquer alteração válida na matriz afetará o conteúdo de ambas as células, e a tentativa de alterar apenas uma célula aciona uma mensagem de erro.

Obviamente, isso será quebrado se você considerar que é realmente apenas uma fórmula, em oposição a duas fórmulas restritas a serem idênticas.

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

Explicação:

1. Sem alterar nada, ele seguirá o seguinte caminho: 1 → 2 (e retornará ao valor de 2012).
2. Se o conteúdo de String afor modificado de qualquer forma, ele seguirá o seguinte caminho: 1 → 3 → 5 (e retornará bo valor inalterado de 2012).
3. Se o conteúdo de String bfor modificado de qualquer forma, ele seguirá o seguinte caminho: 1 → 3 → 4 (e retornará ao valor inalterado de 2012).
4. Se a.equals(b)em @ 1 é modificado para a.equals(a), b.equals(b)ou !a.equals(b)ainda vai tomar o mesmo caminho seguinte: 1 → 2 (e ele irá retornar a's valor inalterado de 2012).
5. Se aon @ 2 for alterado, bele ainda seguirá o seguinte caminho: 1 → 2 (e retornará bo valor inalterado de 2012).
6. Se um aou bfor alterado para o oposto nas linhas 3, 4 ou 5, ainda seguirá o seguinte caminho: 1 → 2 (e retornará ao valor inalterado de 2012)
7. Se o conteúdo da String em @ 3 for modificado de qualquer forma, ele ainda seguirá o seguinte caminho: 1 → 2 (e retornará ao valor inalterado de2012 )
8. Mudando Mdentro class Mou aemmain(String[]a) para outro caractere válido pode ser feito sem quaisquer alterações à funcionalidade do código.
9. Qualquer outra alteração resultará em um erro de compilação (excluindo alguns espaços entre / espaços em branco, que podem ser removidos / adicionados).

Experimente todas essas modificações aqui, para verificar se elas ainda imprimem 2012.

Se você encontrar alguma maneira de quebrá-lo, seguindo as regras do OP, eu adoraria saber, para que eu possa pensar em algo para corrigi-lo.
Diferentemente da maioria das perguntas semelhantes em que um único caractere é modificado, essa pergunta permite que a estrutura básica da linguagem de programação em questão fique intacta, para que o Java possa finalmente competir em um entre um (vamos ser sinceros, o Java quase nunca ganhará nada) este SE xD).

Ruby 1.9

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

Eu construo este programa curto, mas simples, que você está convidado a quebrar de acordo com as regras acima. Eu não conseguia nem encontrar uma posição em que a saída fosse alterada (sem quebrar o código) se a #fosse inserida para comentar o restante da linha.

Scala, 95

(ou 54 se pular partes não significativas)

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

C #

Certamente não é assim tão simples, é? ...

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

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

Ok, o que eu sinto falta?

PHP, 30

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

Táxi , 396 bytes

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.

Formatado para humanos, é isso:

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.

Ao ler outras respostas, a solução parece ser escolher um idioma frágil, definir o valor, verificar o valor, imprimir o valor.

SmileBASIC

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

Primeiro, habilitamos o modo estrito. Isso força você a declarar todas as variáveis ​​antes de usá-las e evita coisas como alterar? A $ para? B $.

Em seguida, uma variável de cadeia chamada "A $" é criada e o valor é definido como "@ 2012". Para garantir que o valor de A $ não seja afetado, o programa tentará pular para um rótulo e o único rótulo no programa é @ 2012.

Agora, A $ é definitivamente "@ 2012", mas antes de imprimi-lo, o @ precisa ser removido. SHIFT () remove o primeiro item de uma string ou matriz (assim como pop (), mas do outro lado). Para descartar o valor retornado por SHIFT, ele é passado para um bloco IF / THEN, que não faz nada. Apenas no caso de alguém tentar comentar essa linha, declaramos uma variável "B", que será usada posteriormente. Se o VAR for comentado, a última linha lançará um erro de variável indefinida.

Agora, A $ é impresso e há outro VAR para evitar comentários. A linha final apenas garante que as variáveis ​​B e C tenham sido declaradas.

Haskell, 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;

Abordagem falhada:

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

Rubi ( 57 36)

EDITAR E outro em 36 caracteres.

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

Eu acho que o uso de strings é bastante seguro, porque essa coisa de menos não funciona mais.

EDITAR próxima tentativa (36 caracteres) [não importa, adicionando um-p resultados posteriores em -2012]

p [2012,2012] .find (2012) .first || 2012

Este só funcionará este ano, mas também para concursos semelhantes no futuro :) (15.chars)

p Time.now.year

Observe que esta substituição também está funcionando:

p Time.new.year

57 caracteres. Se você contar as novas linhas, também serão 76 caracteres.

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

Q, 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

etc

Hmm .. deixe-me tentar:

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 caracteres sem o espaço em branco.

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

Espero que seja inquebrável :)

$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

Lua

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