现在的开发工作要求我们能够快速掌握一门语言。一般来说应对这种挑战有两种态度：其一，粗粗看看语法，就撸起袖子开干，边查Google边学习；其 二是花很多时间完整地把整个语言学习一遍，做到胸有成竹，然后再开始做实际工作。然而这两种方法都有弊病。第二种方法的问题当然很明显，不仅浪费了时间， 偏离了目标，而且学习效率不高。因为没有实际问题驱动的语言学习通常是不牢固不深入的。有的人学着学着成了语言专家，反而忘了自己原本是要解决问题来的。 第一种路子也有问题，在对于这种语言的脾气秉性还没有了解的情况下大刀阔斧地拼凑代码，写出来的东西肯定不入流。说穿新鞋走老路，新瓶装旧酒，那都是小问 题，真正严重的是这样的程序员可以在短时间内堆积大量充满缺陷的垃圾代码。由于通常开发阶段的测试完备程度有限，这些垃圾代码往往能通过这个阶段，从而潜 伏下来，在后期成为整个项目的毒瘤，反反复复让后来的维护者陷入西西弗斯困境。

实际上语言学习有一定规律可循，对于已经掌握一门语言的 开发者来说，对于一般的语言，完全可以以最快的速度，在几天至一周之内掌握其最常用的50%，而且保证路子基本正宗，没有出偏的弊病。其实真正写程序不怕 完全不会，最怕一知半解的去攒解决方案。因为你完全不会，就自然会去认真查书学习，如果学习能力好的话，写出来的代码质量不会差。而一知半解，自己动手土 法炼钢，那搞出来的基本上都是废铜烂铁。比如错误处理和序列化，很多人不去了解“正路子”，而是凭借自己的一知半解去攒野路子，这是最危险的。因此，即使 时间再紧张，这些内容也是必须首先完整了解一遍的。掌握这些内容之后进入实际开发，即使有问题，也基本不会伤及项目大体。而开发者本人则可以安步当车，慢 慢在实践中提高自己。

以下列出一个学习提纲，主要针对的是有经验的人，初学者不合适。这个提纲只能用于一般的庸俗编程语言学习，目前在 流行编程语言排行榜上排前20的基本上都是庸俗语言。如果你要学的是LISP之类非庸俗语言，或是某个软件中的二次开发语言，这里的建议未必合适。还是那 句话，仅供参考。

1. 首先了解该语言的基本数据类型，基本语法和主要语言构造，主要数学运算符和print函数的使用，达到能够写谭浩强程序设计书课后数学习题的程度；

2. 其次掌握数组和其他集合类的使用，有基础的话可以理解一下泛型，如果理解不了也问题不大，后面可以补；

3. 简单字符串处理。所谓简单，就是Regex和Parser以下的内容，什么查找替换，截断去字串之类的。不过这个阶段有一个难点，就是字符编码问题。如果理解不了，可以先跳过，否则的话最好在这时候把这个问题搞定，免留后患；

4. 基本面向对象或者函数式编程的特征，无非是什么继承、多态、Lambda函数之类的，如果有经验的话很快就明白了；

5. 异常、错误处理、断言、日志和调试支持，对单元测试的支持。你不一定要用TDD，但是在这个时候应该掌握在这个语言里做TDD的基本技能；

6. 程序代码和可执行代码的组织机制，运行时模块加载、符号查找机制，这是初学时的一个难点，因为大部分书都不太注意介绍这个极为重要的内容；

7. 基本输入输出和文件处理，输入输出流类的组织，这通常是比较繁琐的一部分，可以提纲挈领学一下，搞清楚概念，用到的时候查就是了。到这个阶段可以写大部分控制台应用了；

8. 该语言如何进行callback方法调用，如何支持事件驱动编程模型。在 现代编程环境下，这个问题是涉及开发思想的一个核心问题，几乎每种语言在这里都会用足功夫，.NET的delegate，Java的anonymous inner class，Java 7的closure，C++OX的 tr1::function/bind，五花八门。如果能彻底理解这个问题，不但程序就不至于写得太走样，而且对该语言的设计思路也能有比较好的认识；

9. 如果有必要，可在这时研究regex和XML处理问题，如无必要可跳过；

10. 序列化和反序列化，掌握一下缺省的机制就可以了；

11. 如果必要，可了解一下线程、并发和异步调用机制，主要是为了读懂别人的代码，如果自己要写这类代码，必须专门花时间严肃认真系统地学习，严禁半桶水上阵；

12. 动态编程，反射和元数据编程，数据和程序之间的相互转化机制，运行时编译和执行的机制，有抱负的开发者在这块可以多下些功夫，能够使你对语言的认识高出一个层面；

13. 如果有必要，可研究一下该语言对于泛型的支持，不必花太多时间，只要能使用现成的泛型集合和泛型函数就可以了，可在以后闲暇时抽时间系统学习。需要注意的是，泛型技术跟多线程技术一样，用不好就成为万恶之源，必须系统学习，谨慎使用，否则不如不学不用；

14. 如果还有时间，最好咨询一下有经验的人，看看这个语言较常用的特色features是什么，如果之前没学过，应当补一下。比如Ruby的block interator, Java的dynamic proxy，C# 3的LINQ和extension method。没时间的话，我认为也可以边做边学，没有大问题。

15. 有必要的话，在工作的闲暇时间，可以着重考察两个问题，第一，这个语言有哪些惯用法和模式，第二，这个语言的编译/解释执行机制。

至 此语言的基本部分就可以说掌握了，之后是做数据库、网络还是做图形，可以根据具体需求去搞，找相应的成熟框架或库，边做边学，加深理解。对于一个庸俗语 言，我自己把上面的内容走一遍大概要花2-3周时间，不能算很快，但也耽误不了太多事情，毕竟不是每个月都学新语言。掌握了以上的内容，就给练武术打好了 基本功，虽然不见得有多优秀，但是肯定是根正苗红，将来不必绕大弯子。就算是临时使用的语言，把上面这个提纲精简一下，只看蓝色重体字的部分，大致能在几 天到一周内搞定，不算是太耗时，而且写出来的代码不会太不靠谱。

以上提纲未设及内存模型。对于C/C++，这个问题很重要，要放在显著位置来考虑，但对于其他语言，这个问题被透明化了，除非你要做hardcore项目，否则不必太关注。

pie(X):-X is pi+e.
:- arithmetic_function(pie/0).

装入这个文件后，就可以在表达式中使用使用这个常量pie了。
arithmetic_function的功能就是自定义运算符，在定义是需指明自定义函数的个数；在定义谓词时，最后一个个体变元必须是输出参数，用于保存结果。所以在arithmetic_function谓词中指明的参数个数应该比实际的变元个数少1。

 1 #include <algorithm>
 2 #include <vector>
 3 #include <iterator>
 4 #include <iostream>
 5 using namespace std;
 6 /**
 7  * 分析：组合无序，所以不妨设降序排列
 8  * 第一个解是[n,n-1,...,n-r+1]
 9  * 解的条件是位置i上的元素A[i]应该满足
10  * i+A[i]>=r
11  * 回溯法：对最后一个元素减一
12  * 如果满足条件则得到一个新解
13  * 如果不满足，一直向前回溯到该位满足为止
14  * 然后把满足的那位后面的依次等于前面减一
15  * 从而得到一组新解,然后继续
16  * 如果已经回溯到第一位仍不满足
17  * 则所有解都已经找到，终止
18  */
19 vector <vector <int> > comb(int n,int r){
20     vector <vector <int> > vv;
21     vector <int> tmp(r);
22     int i;
23     bool f=false;
24     for(i=0;i<r;i++)tmp[i]=n-i;
25     vv.push_back(tmp);
26     while(true){
27         tmp[r-1]--;
28         for(i=r-1;i>=0;i--){
29             if(tmp[i]+i>=r)
30                 break;
31             else{
32                 if(i==0){
33                     f=true;
34                     break;
35                 }
36                 tmp[i-1]--;
37                 if(tmp[i-1]+i-1>=r){
38                     for (int j=i; j < r; j++) {
39                         tmp[j]=tmp[j-1]-1;
40                     }
41                 }
42             }
43         }
44         if(f)break;
45         vv.push_back(tmp);
46     }
47     return vv;
48 }
49 

 1 #include <stdio.h>
 2 #include <vector>
 3 #include <algorithm>
 4 #include <iostream>
 5 
 6 using namespace std;
 7 bool ok(int a,int b);
 8 bool guoqu(int a,int b,vector < int > c);
 9 bool guolai(int a,int b,vector < int > c);
10 const int ren=5;
11 const int sheep=3;
12 
13 int main(int argc, char **argv)
14 {
15    vector < int > v;
16    v.push_back(ren*110+1);
17    guoqu(ren,ren,v);
18    system("pause");
19    return 0;
20 }
21 bool guoqu(int a,int b,vector < int > c){
22    //if(a==0&&b==0)
23    //   return true;
24    for(int i=0;i<=a;i++)
25       for(int j=0;j<=b;j++)
26          if(i+j>0&&i+j<=sheep){
27             int a1,b1,a2,b2,d;
28             a1=a-i;
29             b1=b-j;
30             a2=ren-a1;
31             b2=ren-b1;
32             d=a1*100+b1*10+0;
33             if(find(c.begin(),c.end(),d)==c.end()&&ok(a1,b1)){
34                c.push_back(d);
35                if(guolai(a2,b2,c)){
36                   cout<<"运"<<i<<"牧师和"<<j<<"野人过去,"
37                      <<"这边"<<a1<<b1<<",那边"<<a2<<b2<<endl;
38                   return true;
39                }
40             }
41          }
42    return false;
43 }
44 bool guolai(int a,int b,vector < int > c){
45    if(a==ren&&b==ren)
46       return true;
47    for(int i=0;i<=a;i++)
48       for(int j=0;j<=b;j++)
49          if(i+j>0&&i+j<=sheep){
50             int a1,b1,a2,b2,a3,b3,d;
51             a1=a-i;
52             b1=b-j;
53             a2=ren-a1;
54             b2=ren-b1;
55             d=a2*100+b2*10+1;
56             if(find(c.begin(),c.end(),d)==c.end()&&ok(a2,b2)){
57                c.push_back(d);
58                if(guoqu(a2,b2,c)){
59                   cout<<"运"<<i<<"牧师和"<<j<<"野人过来,"
60                      <<"这边"<<a2<<b2<<",那边"<<a1<<b1<<endl;
61                   return true;
62                }
63             }
64          }
65    return false;
66 }
67 
68 bool ok(int a,int b){
69    return a==ren||a==0||a==b;
70 }

 1 guohe([],_,_):-!.
 2 error(A):-
 3         not(member(r,A)),
 4         member(l,A),
 5         member(y,A),
 6         !.
 7 error(A):-
 8         not(member(r,A)),
 9         member(y,A),
10         member(c,A),
11         !.
12 ok(A):-not(error(A)).
13 % 过去2
14 guohe(A,C,J):-
15         select(r,A,X),
16         select(D,X,Y),
17         ok(Y),
18         sort(Y,S),
19         not(member(S,J)),
20         B=[r,D],
21         append(B,C,C1),
22         length(J,L),
23         write(L),
24         write(‘从此岸运’-r-D-‘到彼岸.’),
25         write(‘此岸’-S-‘彼岸’-C1),
26         nl,
27         J1=[S|J],
28         guohe(S,C1,J1).
29 % 人过去
30 guohe(A,C,J):-
31         select(r,A,X),
32         ok(X),
33         sort(X,S),
34         not(member(S,J)),
35         append([r],C,C1),
36         length(J,L),
37         write(L),
38         write(‘从此岸运’-r-‘到彼岸.’),
39         write(‘此岸’-S-‘彼岸’-C1),
40         nl,
41         J1=[S|J],
42         guohe(S,C1,J1).
43 % 过来2
44 guohe(A,C,J):-
45         select(r,C,X),
46         select(D,X,Y),
47         ok(Y),
48         B=[r,D],
49         append(B,A,A1),
50         sort(A1,S),
51         not(member(S,J)),
52         length(J,L),
53         write(L),
54         write(‘从彼岸运’-r-D-‘到此岸.’),
55         write(‘此岸’-S-‘彼岸’-Y),
56         nl,
57         J1=[S|J],
58         guohe(S,Y,J1).
59 % 人过来
60 guohe(A,C,J):-
61         select(r,C,X),
62         ok(X),
63         append([r],A,A1),
64         sort(A1,S),
65         not(member(S,J)),
66         length(J,L),
67         write(L),
68         write(‘从彼岸运’-r-‘到此岸.’),
69         write(‘此岸’-S-‘彼岸’-X),
70         nl,
71         J1=[S|J],
72         guohe(S,X,J1).
73 :-guohe([c,l,r,y],[],[[c,l,r,y]]).

如题：在123456789之间加入任意个加减号使算式结果为100。如：
1+2+3-4+5+6+78+9 =100
1+2+34-5+67-8+9 =100
更多答案和程序：
1+23-4+5+6+78-9 =100
1+23-4+56+7+8+9 =100
12+3+4+5-6-7+89 =100
12+3-4+5+67+8+9 =100
12-3-4+5-6+7+89 =100
123+4-5+67-89 =100
123+45-67+8-9 =100
123-4-5-6-7+8-9 =100
123-45-67+89 =100

程序：1~9之间共有8个位置，可以放”+”,”-”,空格三者之一，对这8个位置穷举即可
#!/usr/bin/env/python
ysf=['+','-','']
　for i in ysf:
　　for j in ysf:
　　　for k in ysf:
　　　　for l in ysf:
　　　　　for m in ysf:
　　　　　　for n in ysf:
　　　　　　　for o in ysf:
　　　　　　　　for p in ysf:
　　　　　　　　　bds=”1%s2%s3%s4%s5%s6%s7%s8%s9″ % (i,j,k,l,m,n,o,p)
　　　　　　　　　if (eval(bds) == 100):
　　　　　　　　　　print bds,”=100″