全副牌共有6类42种图案，144张。
幺鸡：一条。
老头牌：一万、九万、一条、九条、一饼、九饼。
幺九牌：老头牌和字牌合称幺九牌。
三元牌：中、发、白。
轮：行牌一周为一轮。
盘：每次从起牌到和牌或荒牌为一盘。
圈：四人各坐一次庄为一圈。
局：每打完四圈或达到规定的时间为一局。
圈风：每局竞赛圈数的标志。第一圈为东风圈，第二圈为南风圈，第三圈为西风圈，第四圈为北风圈。
门风：选手每盘座位的标志。庄家为东风，下家为南风，对家为西风，上家为北风。
定位：选手按赛会规程抽签或编排所确定的桌号及方位。
庄家、旁家：门风东者为庄家，其余均为旁家。无论是否和牌，庄家不连庄。
手牌：最多14张。
将牌：按规定牌型和牌时必须具备的单独组合的对子。
顺子: 三张同花色序数相连的牌，如三四五万、六七八筒等。
刻子（坎子）：三张相同的牌。碰出的为明刻，未碰出的为暗刻。
对子：两张相同的牌。
扑子：顺子和刻子。
吃牌：
解释一：上家打出牌后，报吃牌者把自己的两张牌取出，加在一起组成一副顺子摆亮在立牌前。
解释二：上家打出牌，与下家的牌正好组成一副顺子，下家就可以吃。吃牌之后就轮到吃牌的玩家操作，吃牌之后不可以再摸牌，要再打出一张牌。
碰牌：
解释一：他家打出牌后，报碰牌者把自己的对子取出，加在一起组成一副刻字摆亮在立牌前。
解释一：其他人打出一张牌，自己手中有两张相同的牌正好组成一副刻子，自己就可以碰。碰牌之后就轮到碰牌的玩家操作，碰牌之后不可以再摸牌，要再打出一张牌。
杠牌：四张相同的牌。
补花：拿到花牌后，摆亮在立牌前，并从牌墙末端补牌（先上后下）。
听牌：只差所需要的牌张即能和牌的状态。
和牌：符合规定的牌型条件，达到起和分8分的标准。
自摸和：拿牌后成和牌。
点和：和他家打出的牌。
报牌：行牌者宣布吃牌、碰牌、杠牌、补花或和牌。
番种：具有一定分值的各种牌张组合的形式或和牌方式的说法。
罚张：被判定受处罚的牌张。
单放：自摸成“和”的那一张牌，不可随意放入立牌中，应单独摆放，以便核查。
多张、少张：手牌数多于或少于规定的牌数。
荒牌：每盘拿完第144张牌后，打出的牌仍无人和牌。
错和、诈和：不符合和牌规定而宣布的和牌。
牌墙、牌城：四人各自在门前码成18墩牌，即称牌墙。四道牌墙左右相连接称牌城。
牌池：即四道牌墙围起的区域。
胡（胡牌）（和牌）：当手牌符合 （一对将牌+多个扑子） 时，即可胡牌。
所以胡牌时的手牌数量为：14张，11张，8张，5张，2张。
14 = 2 + 3 + 3 + 3 + 3
11 = 2 + 3 + 3 + 3
8 = 2 + 3 + 3
5 = 2 + 3
2 = 2
每执行一次吃、碰、杠操作，玩家的手牌数量就会下降一个等级。
和牌优先于 “吃、碰、明杠”。
和牌的要求：和牌者的牌型必须符合下列牌型之一：
1、和牌的基本牌型：
（1）11、123、123、123、123。
（2）11、123、123、123、111（或1111）。
（3）11、123、123、111、111（或1111）。
（4）11、123、111、111、111（或1111）。
（5）11、111、111、111、111（或1111）。
2、和牌的特殊牌型：
（1）11、11、11、11、11、11、11（七对）。
（2）1、1、1、1、1、1、1、1、1、1、1、1、11（十三幺）。
（3）1、1、1、1、1、1、1、1、1、1、1、1、1、1（全不靠）。
（注：1=单张，11=将牌、对子，111=刻字，1111=杠牌，123=顺子。）
3、和牌的方式：
（1）自摸和：拿牌后成和牌。
（2）点和：和他人打出的牌（包括抢杠和）。
4、和牌者：如有一人以上同时表示和牌时，从点和者按逆时针方向，顺序在前者为和牌者。
本规则认定的番种共有81种，分为9各系列，即：字牌系列、序数牌系列、刻系列、七对系列、花色组合系列、全带系列、不靠系列、和牌方式系列和特殊系列。分值分为12级，依次为：88、64、48、32、24、16、12、8、6、4、2、1分。
大四喜[88番]：和牌中，有东、南、西、北四副刻子（杠）。
大三元[88番]：和牌中，有中、发、白三副刻子（杠）。
绿一色[88番]：由“23468条” 及 “发” 字中的任何牌组成的和牌。
九莲宝灯[88番]：由一种花色序数牌按 “1112345678999” 组成的特定牌型，见同花色任何一张序数牌即成和牌（自摸加计不求人分）。
四杠[88番]：和牌中，有四副杠牌（暗杠加计）。
连七对[88番]：由一种花色序数相连的七个对子组成的和牌（自摸加计不求人分）。
十三幺（十三幺九）（国士无双）(Thirteen Orphans) [88番]：由一万、九万、一条、九条、一饼、九饼、东南西北、中发白这十三中牌组成。胡牌时，这十三种牌某一种有两枚，而另十二种各一枚，共计14枚，即构成十三幺。
清幺九[64番]：由序数牌一、九刻字（杠）、将牌组成的和牌。
小四喜[64番]：和牌中，有风牌的三副刻字（杠）、另一种风牌作将牌。
小三元[64番]：和牌中，有箭牌的两副刻字（杠）、另一种箭牌作将牌。
就是(中中、发发发、白白白)、(中中中、发发、白白白)、(中中中、发发发、白白)。
字一色[64番]：由字牌的刻子（杠）、将牌组成的和牌。
四暗刻[64番]：和牌中，有四副暗刻。
一色双龙会[64番]：一种花色的两个老少副、5作将牌。
一色四同顺[48番]：一种花色四副序数相同的顺子。
一色四节高[48番]：一种花色四副依次递增一个序数的刻字（杠）。
一色四步高（Four step sequences）[32番]：一种花色四副依次递增一个或两个序数的顺子。
如123,345,567,789或123,234,345,456。
三杠[32番]：和牌中，有三副杠牌（暗杠加计）。
混幺九[32番]：由字牌和序数牌一、九的刻字（杠）、将牌组成的和牌。
七对[24番]：由七个对子组成的和牌（自摸加计不求人分）。
七星不靠[24番]：必须有七个单张的东、南、西、北、中、发、白，加上三种花色数位按147、258、369中的七张序数牌组成的没有将牌的和牌（自摸加计不求人分）。
全双刻[24番]：由2、4、6、8序数牌的刻字（杠）、将牌组成的和牌。
清一色[24番]：由一种花色序数牌组成的和牌。
一色三同顺[24番]：和牌中，有一种花色三副序数相同的顺子。
一色三节高[24番]：和牌中，有一种花色三副依次递增一个序数的刻子（杠）。
全大[24番]：有序数牌7、8、9组成的和牌。
全中[24番]：有序数牌4、5、6组成的和牌。
全小[24番]：有序数牌1、2、3组成的和牌。
清龙[16番]：和牌中，有同花色123、456、789相连的序数牌。
三色双龙会[16番]：两种花色两个老少副、另一种花色5作将牌的和牌。
一色三步高（素三步步高）[16番]：和牌中，有一种花色三副依次递增一个或二个序数的顺子。
全带五[16番]：每副牌及将牌中必须有5的序数牌。
三同刻[16番]：和牌中，有三副序数相同的刻子（杠）。
三暗刻[16番]：和牌中，有三副暗刻（暗杠）。
全不靠[12番]：由三种花色147、258、369不能错位的序数牌及东、南、西、北、中、发、白中任何14张单张牌组成的和牌（自摸加计不求人分）。
组合龙[12番]：和牌中，有三种花色的147、258、369不能错位的序数牌（特殊顺子）。
大于五[12番]：由序数牌6、7、8、9组成的和牌。
小于五[12番]：由序数牌1、2、3、4组成的和牌。
三风刻[12番]：和牌中，有三副风刻（杠）。
花龙[8番]：和牌中，有三种花色的三副顺子连接成123、456、789。
例如：1万、2万、3万、4饼、5饼、6饼、7条、8条、9条。
推不倒[8番]：有些牌正着放，还是倒着放都是一样的：2条、4条、5条、6条、8条、9条、1234589饼、白板。胡牌时，手牌中全是这些牌，即为推不倒。
三色三同顺（大姊妹）（桂林山水）[8番]：和牌中，有三种花色三副序数相同的顺子。
例如：1万、2万、3万、1条、2条、3条、1饼、2饼、3饼。
三色三节高[8番]：和牌中，有三种花色三副依次递增一个序数的刻子（杠）。
无番和[8番]：和牌后，数不出任何番种分（花牌不计算在内）。
妙手回春[8番]：自拿牌墙上最后一张牌和牌（不计自摸分）。
海底捞月[8番]：和打出的最后一张牌。
杠上开花（杠上摸）[8番]：杠牌时，从牌墙补上一张牌成和牌。杠牌加计，不计自摸；杠来花牌再补花成和，不计杠上开花，可计自摸分。
抢杠和[8番]：和他人自拿开明杠的牌（不计和绝张）。
双暗杠[8番]：和牌中，有两副暗杠。
碰碰胡[6番]：由四副刻子（杠）、将牌组成的和牌。
混一色[6番]：由一种花色的序数牌及字牌组成的和牌。
三色三步高[6番]：和牌中，由三种花色三副依次递增一个序数的顺子。
例如123万234饼345条就算三色三步高（注意定义中的“依次递增一位序数”），所以123万345饼567条、123万456饼789条等就不算了。
五门齐（五门全）（五彩缤纷）（五雀共和）（五子登科）[6番]：由三种花色序数牌、风牌、箭牌组成的和牌。即万、条、饼、风、箭齐全。
全求人[6番]：四副牌组全是吃、碰（明杠），和他家打出的牌。
双箭刻[6番]：和牌中，有两副箭刻（杠）。
全带幺[4番]：每副牌及将牌中都有幺九牌。
不求人[4番]：没有吃牌、碰牌、明杠，自摸和牌。
双明杠[4番]：和牌中，有两副明杠。
胡绝张（和绝张）[4番]：胡牌时，桌面上已经有3张该牌，自己胡第4张。
箭刻[2番]：由箭牌组成的刻子（杠）。
圈风刻[2番]：与圈风相同的风刻（杠）。
在东风圈时，碰了东风就是圈风刻。
在南风圈时，碰了南风就是圈风刻。
在西风圈时，碰了西风就是圈风刻。
在北风圈时，碰了北风就是圈风刻。
门风刻[2番]：与本门风相同的风刻（杠）。
在东风位，碰了东风就是门风刻。
在南风位，碰了南风就是门风刻。
在西风位，碰了西风就是门风刻。
在北风位，碰了北风就是门风刻。
门清（门前清）[2番]：没有吃牌、碰牌、明杠，和他家打出的牌。
平和[2番]：由四副顺子及序数牌作将组成的和牌。
四归一[2番]：胡牌时，手中有4张相同的牌，但是这4张牌不是作为杠牌。
例子1：比如手牌有一坎（三张）伍万，同时有一个四五六万的顺子，这就是四归一。
例子2：有两个四五六万的顺子，将眼是五万，那也是四归一。
双同刻[2番]：和牌中，有两副序数相同的刻子（杠）。
例子：3个3条，3个3饼。
双暗刻[2番]：胡牌时，有两副暗刻（暗杠）。
断幺[2番]：和牌中，没有一、九及字牌。
一般高[1番]：由一种花色的序数相同的顺子组成。
喜相逢[1番]：由两种花色的序数相同的顺子组成。
连六[1番]：由一种花色六张序数相连的顺子组成。
老少副[1番]：由一种花色的123、789的顺子组成。
幺九刻[1番]：由三张相同的一、九序数牌，子牌组成的刻子（杠）。
明杠[1番]：他家打出一张与暗刻相同的牌开杠；或拿进一张与明刻相同的牌开杠。
缺一门[1番]：和牌中缺少一种花色序数牌。
无字[1番]：和牌中没有字牌。
边张[1番]：只能听和123的3或789的7。
坎张[1番]：只能听和顺子中间的牌。
单钓将[1番]：麻将的一般牌型是四副扑子、一个对子。这个对子称为“将”。如果已经凑好四副扑子，而将只有一张，碰到这一张就胡牌的听牌方式，叫做“单钓将”。 例子：5666和5这种情况，虽然是听457三张牌，但只能钓5，和4或7就不是钓，因此5666和5仍算作单钓将。
自摸[1番]：拿牌后成和牌。
轮到自己回合，自己摸了一张牌，胡牌了，叫自摸。
花牌[1番]：每张花牌计1分，不计在起和分内，和牌后才能计分。补花成和牌计自摸，不计杠上开花分；未补的花牌允许打出。
风刻：由风牌组成的刻子。
暗刻：手中有一副刻子叫暗刻，手中有2副刻子叫双暗刻，手中有3副刻子叫3暗刻。
明刻：通过碰牌形成的刻子，应该就叫明刻吧。
暗杠：手中有三张相同的牌，又抓到一张相同的牌，即可杠牌，称为暗杠。
续杠(加杠)(明杠)：如果自己已经有碰过的牌，同时又摸到了一张相同的牌，即可杠牌，称为续杠。
抢杠：玩家A续杠时，杠牌恰好为玩家B胡的牌，玩家B胡牌即为抢杠，也称抢杠胡。
杠：放杠、暗杠、续杠，每一种杠牌，在杠了之后，都要再摸一张牌（也叫补牌），然后再打出一张牌。
补牌：杠牌成功之后，需要再摸一张牌，然后由杠牌玩家出牌。
听（报听）（听章）：轮到自己回合，摸了一张牌之后，可以检查自己能不能暗杠、续杠、听牌。 听牌就是说：打出自己手牌中的任意一张牌之后，只要再加入一张牌就可以胡牌，此时就可以报听。 报听之后，手牌就无法改变了，不能吃，不能碰，可以杠，但是杠的牌不能影响到听的牌。
悄悄胡：不需要听牌就可以直接胡牌。
放炮：玩家A打出一张牌，恰好是玩家B胡的牌，玩家B胡牌了，玩家A叫放炮了。
截胡：玩家打出了一张多个玩家都可以胡的牌时，靠近点炮玩家近的人可以优先胡牌。
荒牌（荒庄）（流局）：所有牌都打完了，还没有玩家胡牌。
天和（天胡）：是麻将中的一种和牌形式，指的是庄家利用最初摸到的14张牌和牌的情况。只有庄家能够达成。
地和（地胡）：是麻将中的一种和牌形式，指的是闲家在第一圈摸牌胡牌，称之为地和。
杠上炮：玩家A开杠补牌后，打出一张牌，玩家B胡此牌，此胡牌为杠上炮。
1、和牌的前提：
（1）必须符合规则规定的牌型。
（2）番种分值之和至少为8分。
（3）符合规定的和牌方式。
2、和牌分数的组成结构：
由底分、基本分及罚分组成。
（1）底分：指和牌后，未和牌方必须向和牌方所付的比赛分，分值为8分。
（2）基本分：指和牌后，各个番种分数的总和。
（3）罚分：
3、分数的计算
（1）自摸：(底分 + 基本分) * 3方(未和牌方)。
（2）点和：底分 * 3方(未和牌方) + 基本分 * 1方(点和方)。
4、计分原则：
和牌后，首先确定主体番种，并对无必然联系的各个番种进行组合，累加计分。其原则如下：
（1）不重复原则：当某个番种，由于组牌条件所决定，在其成立的同时，必然并存着其他番种，则其他番种不重复计分。
（2）不拆移原则：确定一个番种后，不能将自身再拆开互相组成其他番种计分。
（3）不得相同原则：凡已组合过某一番种的牌，不能再同其他一副牌组成相同的番种计分。
（4）就高不就低原则：有两副以上的牌，有可能组成两个以上的番种，而只能选其中一种计分时，可选择分值高的番种计分。
（5）套算一次原则：如有尚未组合过的一副牌，只可同已组合过的相应的一副牌套算一次。
-b a ：表示不论是否为空行，也同样列出行号(类似 cat -n)；
-b t ：如果有空行，空的那一行不要列出行号(默认值)；
-n ln ：行号在萤幕的最左方显示；
-n rn ：行号在自己栏位的最右方显示，且不加 0 ；
-n rz ：行号在自己栏位的最右方显示，且加 0 ；
-w ：行号栏位的占用的位数。
root@jian-VirtualBox:# nl aa
1 fdsaf
2 f
root@jian-VirtualBox:# nl -b a aa
1 fdsaf
2
3 f
root@jian-VirtualBox:# nl -n ln aa
1 fdsaf
2 f
root@jian-VirtualBox:# nl -n rn aa
1 fdsaf
2 f
root@jian-VirtualBox:# nl -n rz aa
000001 fdsaf
000002 f
root@jian-VirtualBox:# nl -w 3 -n rz aa
001 fdsaf
002 f
管道：将前面的标准输出当做后面的标准输入。
xargs：将标准输入作为命令的参数。
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "*.h" | xargs grep -rn "test"
./src/astyle.h:807: void testForTimeToSplitFormattedLine();
./src/astyle_main.h:369: // virtual functions are mocked in testing
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "*.h" | grep -rn "test"
file/clang-chromium.yaml:59:IncludeIsMainRegex: '([-_](test|unittest))?$'
file/clang-google.yaml:59:IncludeIsMainRegex: '([-_](test|unittest))?$'
file/clang-llvm.yaml:55: - Regex: '^(<|"(gtest|isl|json)/)'
file/clang-mozilla.yaml:55: - Regex: '^(<|"(gtest|isl|json)/)'
file/clang-visualstudio.yaml:59:IncludeIsMainRegex: '([-_](test|unittest))?$'
file/clang-webkit.yaml:55: - Regex: '^(<|"(gtest|isl|json)/)'
.....
在上面这个例子里，加了xargs的似乎是正常执行了。直接用管道的输出了超级多的 东西，这里用省略号代替了，好像跑到了所有文件里面去查找了。
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# echo fly | cat
fly
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# echo fly | xargs cat
cat: fly: 没有那个文件或目录
在这里例子2这里，管道似乎就直接将fly作为一个字符串输出了。而xargs会在 当前目录下去找fly这个文件，因为找不到所以出错了。
那我们接下来就手动建立一个加fly的文件。
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# touch fly
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# echo "test" > fly
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# cat fly
test
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# echo fly | xargs cat
test
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "fly"
./fly
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "fly" | rm -f
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "fly"
./fly
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "fly" | xargs rm -f
root@mdgsf-ThinkPad-X260:/home/mdgsf/svn/AStyle# find . -name "fly"
在例子4这里，直接使用管道，并没有能够成功删除fly这个文件，应该是管道只是将fly作为一个简单的字符串了。 而xargs才会到系统的当前目录下去找fly这个目录。
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ ls
build doc file LICENSE.txt README.txt src
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ wc LICENSE.txt
21 173 1100 LICENSE.txt
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ wc -l LICENSE.txt
21 LICENSE.txt
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ wc -w LICENSE.txt
173 LICENSE.txt
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ wc -c LICENSE.txt
1100 LICENSE.txt
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ wc -m LICENSE.txt
1100 LICENSE.txt
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ wc LICENSE.txt README.txt
21 173 1100 LICENSE.txt
9 45 347 README.txt
30 218 1447 总用量
root@mdgsf-ThinkPad-X260:~# wc --help
用法：wc [选项]... [文件]...
或：wc [选项]... --files0-from=F
Print newline, word, and byte counts for each FILE, and a total line if
more than one FILE is specified. A word is a non-zero-length sequence of
characters delimited by white space.
如果没有指定文件，或者文件为"-"，则从标准输入读取。
The options below may be used to select which counts are printed, always in
the following order: newline, word, character, byte, maximum line length.
-c, --bytes print the byte counts
-m, --chars print the character counts
-l, --lines print the newline counts
--files0-from=F read input from the files specified by
NUL-terminated names in file F;
If F is - then read names from standard input
-L, --max-line-length print the maximum display width
-w, --words print the word counts
--help 显示此帮助信息并退出
--version 显示版本信息并退出
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h"
./src/astyle.h
./src/ASLocalizer.h
./src/astyle_main.h
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h" | wc -l
3
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h" | xargs cat | wc -l
1642
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h" | xargs cat | wc
1642 5511 59833
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h" | xargs cat | wc | awk '{print $1}'
1642
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h" | xargs cat | wc | awk '{print $2}'
5511
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ find . -name "*.h" | xargs cat | wc | awk '{print $3}'
59833
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ ls
build doc file LICENSE.txt README.txt src
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ ls -l | wc -l
7
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$ ls -l
总用量 24
drwxr-xr-x 24 root root 4096 2月 12 14:13 build
drwxr-xr-x 2 root root 4096 2月 12 14:13 doc
drwxr-xr-x 2 root root 4096 2月 12 14:13 file
-rw-r--r-- 1 root root 1100 2月 12 14:13 LICENSE.txt
-rw-r--r-- 1 root root 347 2月 12 14:13 README.txt
drwxr-xr-x 2 root root 4096 2月 12 14:13 src
mdgsf@mdgsf-ThinkPad-X260:~/svn/AStyle$
find . -name "*.go" -print0 | wc -l --files0-from=-
find . -type f -print0 | wc -l --files0-from=-
find . -type f -exec cat {} + | wc -l
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct ss
{
int a;
int b;
};
bool ss_comp(const ss & sa, const ss & sb)
{
return sa.a < sb.a;
}
bool comp(const int & a, const int & b)
{
return a > b;
}
int main(int argc, char *argv[])
{
cout << "Hello World!" << endl;
vector<int> v;
v.push_back(13);
v.push_back(23);
v.push_back(03);
v.push_back(233);
v.push_back(113);
printf("after sort: little-->big\n");
sort(v.begin(), v.end());
for (int i = 0; i < 5; i++)
{
cout << v[i] << " ";
}
cout << endl;
printf("after sort: big-->little\n");
sort(v.begin(), v.end(), comp);
for (int i = 0; i < 5; i++)
{
cout << v[i] << " ";
}
cout << endl;
vector<ss> sv;
ss s1 = {4, 23};
ss s2 = {1, 213};
ss s3 = {2, 231};
ss s4 = {5, 123};
ss s5 = {3, 223};
sv.push_back(s1);
sv.push_back(s2);
sv.push_back(s3);
sv.push_back(s4);
sv.push_back(s5);
printf("sort vector struct\n");
sort(sv.begin(), sv.end(), ss_comp);
for (int i = 0; i < 5; i++)
{
cout << sv[i].a << " " << sv[i].b << endl;
}
cout << endl;
return 0;
}
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <stack>
using namespace std;
#define N 8
int aiBoard[N][N] = {0};
int iCount = 0;
void vShowBoard()
{
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
printf("%d ", aiBoard[i][j]);
}
printf("\n");
}
printf("\n");
}
bool bIsValid(int iRow, int iCol)
{
for (int i = 0; i < iRow; i++)
{
if( (aiBoard[i][iCol] == 1) ||
( ( iCol - (iRow - i) >= 0) && (aiBoard[i][ iCol - (iRow - i) ] == 1) ) ||
( ( iCol + (iRow - i) < N ) && (aiBoard[i][ iCol + (iRow - i) ] == 1) )
)
{
return false;
}
}
return true;
}
void vFunc(int iRow)
{
if(iRow >= N)
{
vShowBoard();
iCount++;
}
else
{
for (int iCol = 0; iCol < N; iCol++)
{
if(bIsValid(iRow, iCol))
{
aiBoard[iRow][iCol] = 1;
vFunc(iRow+1);
aiBoard[iRow][iCol] = 0;
}
}
}
}
int main()
{
vFunc(0);
printf("iCount = %d\n", iCount);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 8
//key: iRow, value: iCol
int aiBoard[N] = {0};
int iCount = 0;
void vShowBoard()
{
for (int i = 0; i < N; i++)
{
int j;
for (j = 0; j < aiBoard[i]; j++) {
printf("X ");
}
printf("Q ");
for (j = aiBoard[i]+1; j < N; j++) {
printf("X ");
}
printf("\n");
}
printf("\n");
}
bool bIsValid(int iRow, int iCol)
{
for (int i = 0; i < iRow; i++)
{
if( (aiBoard[i] == iCol) || (abs(iRow - i) == abs(iCol - aiBoard[i])) )
{
return false;
}
}
return true;
}
void vFunc(int iRow)
{
if(iRow >= N)
{
vShowBoard();
iCount++;
}
else
{
for (int iCol = 0; iCol < N; iCol++)
{
if(bIsValid(iRow, iCol))
{
aiBoard[iRow] = iCol;
vFunc(iRow+1);
}
}
}
}
int main()
{
vFunc(0);
printf("iCount = %d\n", iCount);
return 0;
}