Cette idée ne m’appartient pas, mais je ne sais pas d’où elle vient. Je l'ai déjà rencontré dans un concours de programmation il y a très longtemps (1998, si je me souviens bien). La tâche consiste à écrire un programme dans votre langue préférée, qui en génère 2012 et uniquement 2012 . Le problème, c'est que le programme doit toujours sortir 2012après la modification de l' un de ses caractères. La modification peut être une insertion, une suppression ou un remplacement. Bien entendu, la modification sera telle que le programme est toujours syntaxiquement valide.

Comme je ne connais pas tous les langages de programmation, je dois demander au public de m'aider et de tester les réponses fournies.

Ajouté: Beaucoup ont fait remarquer que ma définition des modifications acceptables est trop vague. Voici ma deuxième tentative: les modifications autorisées laisseront votre programme syntaxiquement valide et ne le feront pas planter. Là, je pense que cela devrait couvrir toutes les erreurs de compilation, de liaison et d’exécution. Bien que je sois sûr qu'il y aura de toute façon un cas étrange dans certaines langues, nous examinerons cela individuellement.

C, 53 caractères

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

Un peu plus long que le langage de script répond, et suit le même principe de base. S'appuie sur le fait qu'en raison des contraintes de la syntaxe de C, les seules lettres qu'il serait possible de modifier sans rendre le programme invalide se trouvent dans les chaînes!

Edit: Rasé 4 personnages.

Rééditer: la robustesse a augmenté, rasé un personnage.

Re-redit: Plus long, mais plus robuste. Essayez juste votre &maintenant! (Correctement cette fois).

Mise à jour: raccourci un peu; défaites la plupart des approches vues jusqu'à présent.

Mise à jour: changé int en void; devrait vaincre la dernière approche possible pour le casser, je peux penser.

Mise à jour: je pense d'une autre approche; remplacer le dernier a(peut-il pourrir) avec 0; l’utilisation de noms à deux lettres devrait régler ce problème.

Mise à jour: dernière mise à jour révoquée; en supposant que les modifications causant des erreurs d'exécution sont interdites; afonctionnera très bien.

Mise à jour: revenir en arrière un peu plus; tenter de déréférencer *asera également une erreur de segmentation; voidil ne devrait donc pas être nécessaire d' utiliser une erreur de compilation.

Mise à jour: Et un raccourcissement final; cela repose sur la chaîne "2012"étant placée à une seule adresse (ce qui est commun); et que les chaînes littérales sont en lecture seule (également communes).

Mise à jour: Cela m'a coûté deux personnages, mais j'ai vaincu votre pauvre colon!

Haskell, 19 ans

(\xx@2012->xx)$2012

ou, en tant que programme complet,

29

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

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

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

Pour le rendre plus modifiable (en toute sécurité), nous pouvons également utiliser le numéro lui-même en tant qu'élément de liste - il suffit de le définir par des chaînes pour empêcher l'échange de virgules par un plus ':

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

Comme cette chaîne n'est que le résultat de l'expression, nous pouvons également la remplacer par celle-ci - ce n'est pas un problème grâce à la paresse de Haskell.

64 72

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

Le initagit comme "moins un, mais non négatif" ici.

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

Vous pouvez maintenant changer n'importe lequel uà l' pinverse, mais cela gâcherait toujours la profondeur des empilements de listes dans le deuxième élément du tuple et provoquerait ainsi une erreur lors de la compilation.

Cette idée pourrait être développée davantage de telle sorte que des textes entiers puissent être codés de manière compacte, faciles à lire et à modifier, tout en évitant de modifier des caractères uniques.

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

Je crois que ceci est une preuve d'erreur d'exécution, toute modification unique devrait entraîner une erreur de compilation ou une alerte unique indiquant 2012.

Edit: Code ferait une erreur d’exécution sur quelque chose comme if("alert(2012 "==r), j’ai déplacé la section try pour y faire face.

Edit: Nice one Vilx-, mais fixable :-) Il existe maintenant un décalage entre crochets pour l'insertion de ce point-virgule.

Edit: Mais alors une virgule pourrait faire la même chose que le point-virgule, c’est une multitude d’options, je pense l’avoir corrigée, mais il y a énormément de code maintenant.

Edit: un peu simplifié.

Edit: Un de plus dans une série infinie de corrections de bugs.

Edit: Cela se sent un peu plus long et compliqué que l'épreuve des balles, mais il faut au moins s'en occuper ~evalet !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 caractères

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

Sur la base de la réponse de JB , mais celle-ci répond effectivement aux spécifications . Un contrôle exhaustif indique que chaque suppression, insertion ou remplacement d'un caractère laisse la sortie inchangée ou provoque le blocage du programme lors de son exécution (indiqué par une valeur de retour non nulle et une sortie sur stderr), au moins aussi longtemps que des insertions et des modifications. les remplacements sont limités aux caractères imprimables ASCII.

(Sans restriction, la tâche est impossible en Perl: une fonction peu connue de l'analyseur Perl est son arrêt lors de la rencontre d'un caractère Ctrl-D ou d'un caractère Ctrl-Z. Il est donc inséré si l'un de ceux-ci se trouve devant un fichier. dans un programme Perl valide qui ne fait rien.)

Edit: Rasé un autre caractère en le remplaçant 1==printpar 0-print.

Brainfuck

J'essaie de me convaincre que c'est possible, et je suis assez certain d'avoir peut-être poussé trop loin. J'ai émis quelques hypothèses sur mon environnement:

1. Une boucle infinie est considérée comme un "crash". Une condition similaire pourrait éventuellement être obtenue en décrémentant au-delà de zéro ou à gauche de l'emplacement mémoire zéro dans certains interpréteurs. De nombreux interprètes sont difficiles à planter au moment de l'exécution. J'évite le problème d'arrêt en utilisant uniquement la boucle infinie la plus simple et la plus évidente.
2. Les accolades sans correspondance sont considérées comme une erreur de compilation.
3. Cela ne fonctionnera que dans un environnement où la sortie du programme est redirigée vers sa propre entrée. Je m'en sers pour vérifier qu'il a bien produit «2012». C’est le seul moyen pour moi de supprimer simplement l’un des caractères de sortie.

Malheureusement, si vous devenez plus strict, je crains que ce ne soit impossible. Voici ma solution:

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

Fondamentalement, vous pouvez modifier le code de sortie ou le code de vérification, mais pas les deux. L'un d'eux est garanti pour fonctionner. Si l'un d'entre eux ne le fait pas, il se «plantera».

Python2

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

Je devais changer légèrement le script de test de Ray pour le tester car la redirection stdout le cassait. Passer des dict vides à exec évite de polluer l'espace de noms

exec(prog, {}, {})

Brain-Flak , 44 + 3 = 47 bytes [Non compétitif]

Ceci utilise le -Adrapeau de Brain-Flak et envoie les caractères 2012à STDOUT

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

Essayez-le en ligne!

Alternative, 50 octets

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

Essayez-le en ligne!

Explication

Toute modification d'un seul caractère à l'un des codes ci-dessus entraînera une erreur du programme.

Sisi , non en compétition

Enfin, je pense avoir trouvé une de mes langues qui fonctionne. C'est horriblement long et le langage est plus récent que la question, mais cela ressemble toujours à un accomplissement.

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

À propos de Sisi

Sisi est un langage de jouet inspiré par l'assemblage et QBasic. C'est bon pour ce défi car sa syntaxe est extrêmement limitée.

• Il n'a que quatre commandes: set, print, jumpet jumpif.
• Toutes les commandes ont une arité fixe.
• Toutes les lignes doivent avoir des numéros de lignes, strictement croissants.
• Les expressions ne sont autorisées que dans les setinstructions. Ils ne peuvent contenir (au plus) qu'une opération, qui doit être binaire. En particulier: le passage print xxà print -xxest une erreur de syntaxe.
• Les noms de variables doivent être composés de lettres minuscules.
• Plus important encore: il n'y a pas de syntaxe de commentaire !

Le programme

Le noyau du programme est cette partie:

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

Nous stockons 2012dans xx, puis de vérifier si c'était réussi et stocker le résultat dans test y. Si yc'est vrai, passez à la ligne 55. (Passez à des numéros de ligne inexistants, faites simplement avancer rapidement à la ligne suivante.)

Durcissement par rayonnement

• Si l'assignation de la ligne 1 est modifiée, alors yc'est falsey, le saut n'a pas lieu et la ligne 4 est fixée xxà 2012.
• Si l'affectation de la ligne 2 ou la condition de saut de la ligne 3 est modifiée, cela nous est égal: nous xxallons définir à 2012 si nous prenons le saut ou non.
• La cible de saut de la ligne 3 peut être modifiée pour être aussi petite que 5 ou aussi grande que 955. Toute modification possible la printrenvoie tôt ou tard à la ligne 955. Avec une modification, il est impossible de revenir en arrière (création d'une boucle) ou après la fin du programme.
• Si l'affectation de la ligne 4 est modifiée, cela ne nous importe pas: l'affectation de la ligne 1 sera correcte et nous passerons à la ligne 4.
• Si la ligne 955 est modifiée, nous pouvons avoir un problème. La seule chose malheureuse à propos de Sisi est que les variables non initialisées sont configurées par défaut 0. Une modification telle que print axn'est donc pas une erreur. Les lignes 828-954 sont la solution laide mais efficace, car elles attribuent 2012 à toutes les variables possibles avec une distance d'édition de 1 à partir de xx. Cela garantit que toute modification apportée à la finale print xxsera toujours imprimée en 2012.
• Si un numéro de ligne est modifié, soit: 1) il sera hors d'usage et sera une erreur de syntaxe, ou 2) cela n'affectera pas le déroulement du programme. La principale modification qui nous inquiète peut-être - changer la ligne 4 en 94, pour l'insérer après le saut à 55 - n'a pas d'importance, car elle ne fait que réattribuer 2012 xx.

Python

Un peu commenté (maintenant avec un correctif pour ce point-virgule embêtant entre printet (!):

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

J'ai créé un script python pour juger de toutes les solutions python. Le script rompt les première et troisième solutions python, avec de nombreuses méthodes différentes. Et la deuxième solution utilise lambda pour se protéger, est incassable. La deuxième solution python est en python 3. Je l’ai modifiée au format python 2 puis j’ai jugé que le programme l’avait brisé.

Voici le script du juge.

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 caractères

Remarque: "/." signifie "remplacer"

2012/.Except@2012->2012

Javascript - 68, 77, 84 , 80 caractères

Voici une solution qui devrait fonctionner cette année :)

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

Voici le test de violon .

Mise à jour 1: Correction du problème où eval (+ a) le cassait (merci eBusiness).

Mise à jour 2: corrigé pour le '|' cas (merci encore eBusiness).

Mise à jour 3: Correction du cas '>' (merci encore à eBusiness). Et cassé pour le cas '1' :(

Ruby 1.9 - 43 caractères

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

Non testé, alors rompre.

Excel, 14 caractères (triche légèrement):

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

Toute modification valide du tableau aura une incidence sur le contenu des deux cellules. Toute tentative de modification d'une seule cellule déclenche un message d'erreur.

Bien sûr, cela ne tient pas compte du fait que vous considérez qu'il ne s'agit en réalité que d'une formule, par opposition à deux formules dont la contrainte est identique.

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

Explication:

1. Sans rien changer, il suivra le chemin suivant: 1 → 2 (et retournera ala valeur de 2012).
2. Si le contenu de String aest modifié de quelque manière que ce soit, il empruntera le chemin suivant: 1 → 3 → 5 (et la bvaleur non modifiée de celle-ci sera renvoyée 2012).
3. Si le contenu de String best modifié de quelque manière que ce soit, il empruntera le chemin suivant: 1 → 3 → 4 (et la avaleur non modifiée de celle-ci sera renvoyée 2012).
4. Si on a.equals(b)sur @ 1 est modifié en a.equals(a), b.equals(b)ou !a.equals(b)prendra toujours le même chemin suivant: 1 → 2 (et il retournera ala valeur inchangée de2012 ).
5. Si aon modifie @ 2, bil prendra toujours le chemin suivant: 1 → 2 (et la bvaleur inchangée sera retournée 2012).
6. Si l 'un aou l' autre best changé sur les lignes 3, 4 ou 5, il suivra toujours le chemin suivant: 1 → 2 (et la avaleur non modifiée sera renvoyée 2012)
7. Si le contenu de la chaîne sur @ 3 est modifié de quelque manière que ce soit, il suivra toujours le chemin suivant: 1 → 2 (et il retournera ala valeur inchangée de 2012)
8. Changer Mdans class Mou adansmain(String[]a) un autre caractère valide peut se faire sans modifier la fonctionnalité du code.
9. Toute autre modification entraînera une erreur de compilation (excluant certains des espaces / espaces, qui peuvent être supprimés / ajoutés).

Essayez toutes ces modifications ici, pour vérifier si elles sont toujours imprimées en 2012.

Si vous pouviez trouver un moyen de le briser en suivant les règles d'OP, j'aimerais bien le savoir, afin que je puisse penser à quelque chose pour y remédier.
Contrairement à la plupart des questions similaires où un seul caractère est modifié, cette question permet à la structure de base du langage de programmation en question d'être intacte, de sorte que Java puisse enfin entrer en concurrence dans une seule entrée (avouons-le, Java ne gagnera presque jamais rien sur cette SE xD).

Ruby 1.9

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

Je construis ce programme court mais simple que vous êtes invités à interrompre conformément aux règles ci-dessus. Je ne pouvais même pas trouver une position où la sortie était modifiée (sans casser le code) si un #est inséré afin de commenter le reste de la ligne.

Scala, 95

(ou 54 si ignorer les parties non significatives)

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

C #

Ce n'est sûrement pas aussi simple, n'est-ce pas? ...

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

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

Ok ce qui me manque?

PHP, 30

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

Taxi , 396 octets

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.

Formaté pour les humains, c'est:

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.

À la lecture des autres réponses, la solution semble être de choisir une langue fragile, de définir la valeur, de vérifier la valeur, d’imprimer la valeur.

SmileBASIC

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

Tout d'abord, nous activons le mode strict. Cela vous oblige à déclarer toutes les variables avant de les utiliser et empêche des choses comme de changer? A $ en? B $.

Ensuite, une variable de chaîne appelée "A $" est créée et la valeur est définie sur "@ 2012". Pour s'assurer que la valeur de A $ n'a pas été altérée, le programme essaiera de passer à une étiquette, et la seule étiquette du programme est @ 2012.

Maintenant, A $ est définitivement "@ 2012", mais avant de l’imprimer, le @ doit être supprimé. SHIFT () supprime le premier élément d'une chaîne ou d'un tableau (exactement comme pop (), mais de l'autre extrémité). Pour supprimer la valeur renvoyée par SHIFT, elle est transmise à un bloc IF / THEN, qui ne fait rien. Juste au cas où quelqu'un essaierait de commenter cette ligne, nous déclarons une variable "B", qui sera utilisée plus tard. Si le VAR est commenté, la dernière ligne générera une erreur de variable non définie.

Maintenant, A $ est imprimé et il existe un autre VAR pour empêcher les commentaires. La dernière ligne s'assure simplement que les variables B et C ont toutes deux été déclarées.

Haskell, 65 ans

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;

Approche ratée:

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

Rubis ( 57 36)

EDIT Et un autre en 36 caractères.

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

J'imagine que l'utilisation de chaînes est assez sécurisée, car ce problème ne fonctionne plus.

EDIT next try (36 caractères) [ça ne fait rien, en ajoutant un- après présultats dans -2012]

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

Celui-ci ne fonctionnera que cette année, mais aussi pour des concours similaires à l'avenir :) (15.chars)

p Time.now.year

Notez que cette substitution fonctionne également:

p Time.new.year

57 caractères. Si vous comptez les sauts de ligne, vous avez également 76 caractères.

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 .. laissez-moi essayer:

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 caractères sans les espaces.

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

J'espère que c'est incassable :)

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