讓你覺得驚嘆無比的代碼片段或者正則表達式？
如題，來說說那些讓你看過之後，覺得簡直太聰明，太精妙的Code Snippet 或者 Regular Expression. 相信大家在工作學習中，上網搜集材料，或者同事review code時候都會碰到。
其實老實說各種奇淫巧技我見得多了，以前也寫得多。
各種奇淫巧技譬如說之前被各種遞歸調用實現斐波那契數列的例子弄煩了，隨手用C#寫的迭代演算法：
int a = 1, b = 1;
while ( b &> 0 ){ Console.WriteLine( a ); b = a + (a = b); }//循環條件的b&>0是溢出就終止。
很多小白看到這種代碼一般都會頂禮膜拜，驚嘆無比，一般在論壇上會這樣形容：不到十個字元就完成了斐波那契迭代中的累加和推移操作，真是神一樣的代碼。
不過這段代碼我可不保證在C/C++編譯器上能得到確定和同樣的結果。So，別學這個，你要在生產環境這麼寫信不信我把你趕出去。
return service = GetService();
或是賦值並作為循環條件判斷：
while( ( data = Read() ) != null )
或是連續賦值：
i = j = 1;
賦值子表達式的玩法很多，還有一個經典的是不使用第三個變數交換倆變數這種無聊的需求
a = b + (b = a) * 0;
溫馨提示，這個也別學，否則被老大從窗戶扔出去本人概不負責。
學會了這些奇淫巧技，就足夠寫出各種讓小白程序員驚嘆的代碼了。不過在這裡我想說的是，真正的精彩的代碼，不在於這些奇淫巧技。
真正牛逼的技巧不在於看起來多牛逼，而是用起來特別爽，突然發現我操這個設計太棒了。
譬如說LINQ的鏈式調用：
var result = data
.GroupBy( item =&> item.Name )
.Where( group =&> group.Count() &> 0 )
.OrderBy( group =&> group.Count() )
.Select( group =&> group.Key );
看起來平平無奇，鏈式調用沒啥稀奇，函數式語法沒啥稀奇，但是真正做出來讓程序員玩的爽，讓別人用的時候有一種我操這個設計太棒了，不容易。
再比如說LINQ for XML的Add方法可以一次性把所有的子元素，子元素的子元素....全部搞定
document.Add(
new XElement( "Member", new XAttribute( "name", "Ivony" ),
new XElement( "Role", new XAttribute( "admin" "true" ), new XText( "Administrator" ) )
)
）;
譬如說async、await語法，譬如說DLR，都在此列。
好吧，最後夾帶一些私貨好了，在我的類庫裡面，提供了一個擴展方法，這個擴展方法簡單到只有一行代碼：
public static T CastTo&
{
return (T) obj;
}
看起來太TM弱智了，這種擴展方法存在的意義是什麼？
這個擴展方法的意義對於很多場景來說，極其深遠，其實這個擴展方法是為了改善C#語言坑爹的強制類型轉換語法的。
我們經常會遇到這樣的場景，通過某個表達式獲取一個對象，然後強制類型轉換，再調用其中一個成員方法或是賦值給某個屬性。
首先我們會寫一個表達式獲取對象：
GetDataObject()|
那個|表示游標所在的位置（下同，不再贅述）。
然後我們發現，這個對象TMD類型不對，我要強轉一下：
(Member)| GetDataObject()
然後把游標挪到前面去，輸入括弧類型括弧。
然後又發現強轉的優先順序低於.運算符，所以我還得改一下：
((Member) GetDataObject()).Name|
這下終於完事了（注意過程中的游標跳躍）
當然，有經驗的程序員一般會起手直接雙括弧寫類型，再寫表達式。
((Member) |
但很多時候，你不可能老是這樣預判，尤其是在表達式特別長的時候，來回的游標跳動，莫名奇妙的括弧，都會帶來各種噁心的事兒：
((Member) Db.GetEntities( "SELECT * FROM Members WHERE MemberID = xxx" ).Filter(xxx).(xxx).....
而這個擴展方法解決了這個問題，用極其簡單的方式，它使得
((Member) GetDataObject()).Name
可以寫成：
GetDataObject().CastTo&
表面上看起來，代碼量更多了，尖括弧輸入也不如圓括弧方便。
但實際上它降低了括弧嵌套的層次，避免了游標亂竄，不打斷程序員的思路。
最後小聲說一句，其實前端寫的JS腳本經常讓我各種驚嘆無比，要找驚嘆無比的代碼去翻各種前端腳本庫一找一個準，，，，
static pure bool longMonth (uint m){
return !(m 1) == (m &> 7);
}
-- Andrei Alexsanderscu The D Programming Language P322
不使用臨時變數，交換兩個數
void swap(int * a, int * b){
*a ^= *b^= *a^= *b;
}
平方根倒數速演算法 x2 = number * 0.5F; return y; /*
+
+
+
+
[ &>i&>n[t
*/ #include&
/*2w0,1m2,]_&
*/int/**/main(int/**/n,char**m){FILE*p,*q;int A,k,a,r,i/*
#uinndcelfu_dset&
%d40%d"/**/
"
%d
0wb+",b[1024],y[]="yuriyurarararayuruyuri*daijiken**akkari~n**"
"/y*u*k/riin&
"*]/f]`;hvroai&
/*y/riynrt~(^w^)],]c+h+a+r+*+*[n&>)+{&>f+o&
return+printf("Can " "notx20open40%s40" "" "for40%sing
",m[!p?1:2],!p?/*
o=82]5&<&<+(+3+1+.(+ m +-+1.)&<)&<|&<|.6&>4&>-+(&> m- -1.9-2-)-|-|.28&>-w-?-m.:&>([28+
*/"read":"writ");for ( a=k=u= 0;y[u]; u=2 +u){y[k++ ]=y[u];}if((a=fread(b,1,1024/*
,mY/R*Y"R*/,p/*U*/)/* R*/ )&>/*U{ */ 2 b/*Y*/[0]/*U*/=="P" 4==/*"y*r/y)r}
*/sscanf(b,d,k, A, i, r) ! (k-6k -5)r==255){u=A;if(n&>3){/*
]&<1&<6&3&> +:+ .1&>3+++ . -m-) -;.u+=++.1&<0&< &<; f&
/*]&>*/{(u)=/*{ p&> &>u &>t&>-]s &>++(.yryr*/+( n+14&>17)?8/4:8*5/
4;}for(r=i=0 ; ;){u*=6;u+= (n&>3?1:0);if (y[u]01)fputc(/*
&
(r),q);if(y[u ]16)k=A;if (y[u]2)k--;if(i/*
("^w^NAMORI; { I*/==a/*" )*/){/**/i=a=(u)*11
255;if(10&>= (a= fread(b,1,1024,p))
")]i&>(w)-;} { /i-f-(-m--M1-0.)&<{"
[ 8]==59/* */ )break;i=0;}r=b[i++]
;u+=(/**&>&> *..&
float Q_rsqrt( float number )
{
long i;
float x2, y;
const float threehalfs = 1.5F;
y = number;
i = * ( long * ) y; // evil floating point bit level hacking（對浮點數的邪惡位級hack）
i = 0x5f3759df - ( i &>&> 1 ); // what the fuck?（這他媽的是怎麼回事？）
y = * ( float * ) i;
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration （第一次牛頓迭代）
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed（第二次迭代，可以刪除）
}
介紹摘自維基百科：
http://zh.wikipedia.org/wiki/%E5%B9%B3%E6%96%B9%E6%A0%B9%E5%80%92%E6%95%B0%E9%80%9F%E7%AE%97%E6%B3%95
平方根倒數速演算法（英語：Fast Inverse Square Root，亦常以「Fast InvSqrt()」或其使用的十六進位常數0x5f3759df代稱）是用於快速計算
（即
的平方根的倒數，在此
此演算法首先接收一個32位帶符浮點數，然後將之作為一個32位整數看待，以將其向右進行一次邏輯移位的方式將之取半，並用十六進位「魔術數字」0x5f3759df減之，如此即可得對輸入的浮點數的平方根倒數的首次近似值；而後重新將其作為浮點數，以牛頓法反覆迭代，以求出更精確的近似值，直至求出符合精確度要求的近似值。在計算浮點數的平方根倒數的同一精度的近似值時，此演算法比直接使用浮點數除法要快四倍。
此演算法最早被認為是由約翰·卡馬克所發明，但後來的調查顯示，該演算法在這之前就於計算機圖形學的硬體與軟體領域有所應用，如SGI和3dfx就曾在產品中應用此演算法。而就現在所知，此演算法最早由Gary Tarolli在SGI Indigo的開發中使用。雖說隨後的相關研究也提出了一些可能的來源，但至今為止仍未能確切知曉此常數的起源。
突然覺得，知乎應該添加插入代碼功能了，大家就可以在這裡曬碼玩～
以後會出現另一種釣魚貼，號稱:「釣碼子」！
JIT腳本引擎：動態運行文本格式的彙編代碼
記得大四的時候想做一個C語言到x86的編譯器，於是自己寫了彙編器。為了方便調試，我的編譯器直接輸出字元串格式的彙編，然後做了反序列化，於是搞了一個超長的正則表達式來分析彙編語言。話說運行這個正則表達式的引擎也是我自己寫的。
s*(?:&<#OPCODE&>w[a-zA-Z0-9_]*)(s*((?:&<#REGISTER0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#PTRTYPE0&>(?:int8|int16|int32|fp32|fp64))s+[((?:&<#BASE0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|(?:&<#INDEX0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE0&>[1248])|(?:&<#INDEX0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE0&>[1248])+(?:&<#BASE0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#INTEGER0&>(+|-)?d+)|$(?:&<#CHARA0&>.)|w$(?:&<#CHARW0&>.)|(?:&<#NAME0&>w[a-zA-Z0-9_]*))|(?:&<#BASE0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER0&>(+|-)?d+)|$(?:&<#CHARA0&>.)|w$(?:&<#CHARW0&>.)|(?:&<#NAME0&>w[a-zA-Z0-9_]*))|(?:&<#INDEX0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE0&>[1248])+((?:&<#INTEGER0&>(+|-)?d+)|$(?:&<#CHARA0&>.)|w$(?:&<#CHARW0&>.)|(?:&<#NAME0&>w[a-zA-Z0-9_]*))|(?:&<#INDEX0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE0&>[1248])+(?:&<#BASE0&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER0&>(+|-)?d+)|$(?:&<#CHARA0&>.)|w$(?:&<#CHARW0&>.)|(?:&<#NAME0&>w[a-zA-Z0-9_]*)))])|((?:&<#INTTYPE0&>(?:int8|int16|int32|fp32|fp64))s+((?:&<#INTEGER0&>(+|-)?d+)|$(?:&<#CHARA0&>.)|w$(?:&<#CHARW0&>.)|(?:&<#NAME0&>w[a-zA-Z0-9_]*)))|((?:&<#LABEL0&>@w[a-zA-Z0-9_]*)))(s*,s*((?:&<#REGISTER1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#PTRTYPE1&>(?:int8|int16|int32|fp32|fp64))s+[((?:&<#BASE1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|(?:&<#INDEX1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE1&>[1248])|(?:&<#INDEX1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE1&>[1248])+(?:&<#BASE1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#INTEGER1&>(+|-)?d+)|$(?:&<#CHARA1&>.)|w$(?:&<#CHARW1&>.)|(?:&<#NAME1&>w[a-zA-Z0-9_]*))|(?:&<#BASE1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER1&>(+|-)?d+)|$(?:&<#CHARA1&>.)|w$(?:&<#CHARW1&>.)|(?:&<#NAME1&>w[a-zA-Z0-9_]*))|(?:&<#INDEX1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE1&>[1248])+((?:&<#INTEGER1&>(+|-)?d+)|$(?:&<#CHARA1&>.)|w$(?:&<#CHARW1&>.)|(?:&<#NAME1&>w[a-zA-Z0-9_]*))|(?:&<#INDEX1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE1&>[1248])+(?:&<#BASE1&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER1&>(+|-)?d+)|$(?:&<#CHARA1&>.)|w$(?:&<#CHARW1&>.)|(?:&<#NAME1&>w[a-zA-Z0-9_]*)))])|((?:&<#INTTYPE1&>(?:int8|int16|int32|fp32|fp64))s+((?:&<#INTEGER1&>(+|-)?d+)|$(?:&<#CHARA1&>.)|w$(?:&<#CHARW1&>.)|(?:&<#NAME1&>w[a-zA-Z0-9_]*)))|((?:&<#LABEL1&>@w[a-zA-Z0-9_]*)))(s*,s*((?:&<#REGISTER2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#PTRTYPE2&>(?:int8|int16|int32|fp32|fp64))s+[((?:&<#BASE2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|(?:&<#INDEX2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE2&>[1248])|(?:&<#INDEX2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE2&>[1248])+(?:&<#BASE2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#INTEGER2&>(+|-)?d+)|$(?:&<#CHARA2&>.)|w$(?:&<#CHARW2&>.)|(?:&<#NAME2&>w[a-zA-Z0-9_]*))|(?:&<#BASE2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER2&>(+|-)?d+)|$(?:&<#CHARA2&>.)|w$(?:&<#CHARW2&>.)|(?:&<#NAME2&>w[a-zA-Z0-9_]*))|(?:&<#INDEX2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE2&>[1248])+((?:&<#INTEGER2&>(+|-)?d+)|$(?:&<#CHARA2&>.)|w$(?:&<#CHARW2&>.)|(?:&<#NAME2&>w[a-zA-Z0-9_]*))|(?:&<#INDEX2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE2&>[1248])+(?:&<#BASE2&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER2&>(+|-)?d+)|$(?:&<#CHARA2&>.)|w$(?:&<#CHARW2&>.)|(?:&<#NAME2&>w[a-zA-Z0-9_]*)))])|((?:&<#INTTYPE2&>(?:int8|int16|int32|fp32|fp64))s+((?:&<#INTEGER2&>(+|-)?d+)|$(?:&<#CHARA2&>.)|w$(?:&<#CHARW2&>.)|(?:&<#NAME2&>w[a-zA-Z0-9_]*)))|((?:&<#LABEL2&>@w[a-zA-Z0-9_]*)))(s*,s*((?:&<#REGISTER3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#PTRTYPE3&>(?:int8|int16|int32|fp32|fp64))s+[((?:&<#BASE3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|(?:&<#INDEX3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE3&>[1248])|(?:&<#INDEX3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE3&>[1248])+(?:&<#BASE3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))|((?:&<#INTEGER3&>(+|-)?d+)|$(?:&<#CHARA3&>.)|w$(?:&<#CHARW3&>.)|(?:&<#NAME3&>w[a-zA-Z0-9_]*))|(?:&<#BASE3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER3&>(+|-)?d+)|$(?:&<#CHARA3&>.)|w$(?:&<#CHARW3&>.)|(?:&<#NAME3&>w[a-zA-Z0-9_]*))|(?:&<#INDEX3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE3&>[1248])+((?:&<#INTEGER3&>(+|-)?d+)|$(?:&<#CHARA3&>.)|w$(?:&<#CHARW3&>.)|(?:&<#NAME3&>w[a-zA-Z0-9_]*))|(?:&<#INDEX3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))*(?:&<#SCALE3&>[1248])+(?:&<#BASE3&>(AL|AH|CL|CH|DL|DH|BL|BH|AX|CX|DX|BX|SI|DI|SP|BP|EAX|ECX|EDX|EBX|ESI|EDI|ESP|EBP|ST0|ST1|ST2|ST3|ST4|ST5|ST6|ST7))+((?:&<#INTEGER3&>(+|-)?d+)|$(?:&<#CHARA3&>.)|w$(?:&<#CHARW3&>.)|(?:&<#NAME3&>w[a-zA-Z0-9_]*)))])|((?:&<#INTTYPE3&>(?:int8|int16|int32|fp32|fp64))s+((?:&<#INTEGER3&>(+|-)?d+)|$(?:&<#CHARA3&>.)|w$(?:&<#CHARW3&>.)|(?:&<#NAME3&>w[a-zA-Z0-9_]*)))|((?:&<#LABEL3&>@w[a-zA-Z0-9_]*))))?)?)?)?
(define (Y* . l)
((lambda (u) (u u))
(lambda (p)
(map (lambda (li) (
lambda x (apply (apply li (p p)) x))) l))))
#!/bin/sh
:(){ :|: };:
來一個淘寶首頁的
with(document)with(body)with(insertBefore(createElement("script"),firstChild))setAttribute("exparams","category=userid=32009425aplusyunid=",id="tb-beacon-aplus",src=(location&>"https"?"//s":"//a")+".tbcdn.cn/s/aplus_v2.js")
不解釋
說個實用的，我用這個正則代碼發現了不少好米
^([a-z]{1,1})([a|e|i|o|u]{1,1})([a-z]{1,4}).com
vs環境下，不用臨時變數，一行代碼交換兩個整型變數的值。
---------------------
a = ( b ^= a ^= b) ^ a;
---------------------
原理解釋:
上面代碼執行了三次異或，相當於以下代碼。
a ^= b;
b ^= a;
a ^= b;
不過那行代碼千萬不要寫成下面這樣。
a ^= b ^= a ^= b;
這樣不會得到正確的結果，其中的差異恐怕只有編譯器知道。
ps: 請勿在實際編碼中應用此代碼JavaScript裡面的通用模塊定義,兼容所有模塊定義框架
(function (root, factory) {
if (typeof exports === "object" exports) {
module.exports = factory(); // CommonJS
} else if (typeof define === "function" define.amd) {
define(factory); // AMD
} else {
// XXX change MyModule below.
root.MyModule = factory(); // Browser &
}
}(this, (function () {
var exports = {};
exports.name = "MyModule";
exports.version = "0.0.0";
// your code.
return exports;
})));
有一類程序叫Quine,指輸出結果為程序自身源碼的程序。Quine (computing)
列舉幾個比較簡潔的Python版：
s = "s = %r
print(s%%s)"
print(s%s)
Ruby版：
eval s="print "eval s=";p s"
shell版：
cat $0
這裡收集了一大堆：http://www.nyx.net/~gthompso/quine.htm
一些變種multiquines之類的就設計更加巧妙了。- 將字元串逆序輸出
#include &int main(char ch)
{
if((ch = getchar())^10)
main(ch);
putchar(ch);
return 0;
}
- 將字元串的大寫變小寫，小寫變成大寫
#include &int main()
{
for(int ch;(ch=getchar())^10;putchar(ch^32));
return 0;
}
- 兩變數交換其值，不用第三個變數
int a = 1,b = 2;
a ^= b; b ^= a; a ^= b;a ^= b ^= a ^= b //根據C99標準，這種寫法其實是undefined behavior
- 倒轉一個32位word的所有位
n = ((n &>&> 1) 0x55555555) | ((n &<&< 1) 0xaaaaaaaa) ; n = ((n &>&> 2) 0x33333333) | ((n &<&< 2) 0xcccccccc) ; n = ((n &>&> 4) 0x0f0f0f0f) | ((n &<&< 4) 0xf0f0f0f0) ; n = ((n &>&> 8) 0x00ff00ff) | ((n &<&< 8) 0xff00ff00) ; n = ((n &>&> 16) 0x0000ffff) | ((n &<&< 16) 0xffff0000) ; - 計算32位world的所有1的個數
n = (n 0x55555555) + ((n 0xaaaaaaaa) &>&> 1);
n = (n 0x33333333) + ((n 0xcccccccc) &>&> 2);
n = (n 0x0f0f0f0f) + ((n 0xf0f0f0f0) &>&> 4);
n = (n 0x00ff00ff) + ((n 0xff00ff00) &>&> 8);
n = (n 0x0000ffff) + ((n 0xffff0000) &>&> 16);
- 判斷數是否2的冪
b = ((n(n-1))==0) ;
原版書：Hacker"s Delight
中文版：演算法心得：高效演算法的奧秘（忽略第一版的渣翻譯，這是上個月剛出的第二版）
樓上提到的都弱爆了。題主可以看國際坑爹C代碼大賽（IOCCC），每年一屆。
C語言的math.h的implementation基本都是充滿了各種floating point arithmetic的trick吧……GNU libc的組織比較混亂，我比較習慣看fdlibm這裡的，來源於Sun公司早年的代碼，雖然大多數函數都知道它在幹什麼，但是正確理解每個細節還是要花巨多的時間 &>_&<
你們都寫過平衡樹吧。
你們都知道基於旋轉的平衡樹需要rotate操作吧。
那麼你們一定被蛋疼的的zig、zag、zigzig、zagzag、zigzag、zagzig瞎過狗眼吧。
int getdir(){
return p-&>ch[1] == this;
}
void rotate(){
node *f = p;int dir = getdir();
p = f-&>p; f-&>p-&>ch[f-&>getdir()] = this;
f-&>ch[dir] = ch[dir^1]; ch[dir^1]-&>p = f;
ch[dir^1] = f; f-&>p = this;
f-&>update(); update();
}
雙旋轉怎麼辦呢？
((x-&>getdir() == y-&>getdir())?(y-&>rotate()):(x-&>rotate())), x-&>rotate();
媽媽再也不用擔心我的學習啦～
記得當初剛學程序的時候見到最驚嘆的代碼就是。
(print "hello world")
推薦閱讀：
※老闆的這種做法我該怎麼辦？
※男孩子穿女裝面試程序員的工作合適嗎？
※cs本科生推薦讀物？
※是否有人預言過程序員現在的地位？
※程序員菜鳥應該專攻技術嗎，還是業務與技術兼顧？