#include <stdio.h>
 
int rolltreppe(int t[5], int personen, int iteration){
    printf("%d %d %d %d %d - # %d &ndash;第 %d 个台阶: ", 
        t[0], t[1], t[2], t[3], t[4], personen, iteration);
    int input; //下一个台阶上将上来的人数
    scanf("%d", &input);
    return input;
}
 
int main(){
    int personen, t[5], iter=0;
    do{
        personen = rolltreppe(t,t[0]+t[1]+t[2]+t[3]+t[4], iter);
        iter=iter+1; //记录滚动了多少次
        t[4] = t[3]; 
        t[3] = t[2]; 
        t[2] = t[1]; 
        t[1] = t[0]; 
        t[0] = personen; 
    } while(personen >= 0);  
}

#include <stdio.h>
#define N 5
 
int rolltreppe(int t[N], int personen, int iteration){
    int i;
    for(i=0;i<N;i++)
        printf("%d ", t[i]);
    printf("- # %d &ndash;第 %d 个台阶: ", personen, iteration);
    int input;
    scanf("%d", &input);
    return input;
}
 
int main(){
    int personen, t[N]={0}, iter=0;
    int i,total;
    do{
        total = 0;
        for( i=0; i<N; i++ ) total += t[i];
        personen = rolltreppe(t,total, iter);
        iter=iter+1; 
        for( i=N-1;i>=0;i-- ) t[i] = t[i-1];
        t[0] = personen;
    } while(personen >= 0);  
    system("pause");
}

#include<stdio.h>
 
void fakultaet(int *n){  //计算指针n指向的地址中的值的阶乘，并将结果存储到n所指向的地址中 
    int num = *n;  // 从地址中把值取出来
    int fac = 1; // 存储计算的值
    int i; //循环变量
    for( i=1; i<=num; i++ ) {
        fac *= i;    
    }
    *n = fac;  //再把计算得到的值存回指针所指的地址中 
}
 
int bino(int n,int k){ //按公式计算二项式系数 
    int nk = n-k;
    fakultaet(&n); //分别计算几个数的阶乘并存到传递的指针所指的地址中 
    fakultaet(&k);
    fakultaet(&nk); 
    // 这时候n,k,nk已经分别存储了他们的阶乘值 
    return n / ( nk*k ); 
} 
 
int main(){
    int n,k;
 
    do{    
        printf("请输入n:");
        scanf("%d", &n);
        printf("请输入k:");
        scanf("%d", &k);
        if(k>n){
            printf("错误的输入。\n");    
        }
    }while(k>n); //保证输入的k不比n大 
 
    printf("二项式系数为:%d\n", bino(n,k));
    system("pause");
}

#include<stdio.h>
 
int eingabe(){  //返回输入的值 
    int input;
    scanf("%d", &input);
    return input;
}
 
int main(){
    printf("请给出物品的价格:");
    int totalPrice = eingabe(); // 总价格 
    int leftPrice = totalPrice; // 记录支付后剩余的价格
    int coin; // 记录投入的硬币 
    do{
        printf("您还有 %d 从 %d Cent 中支付. 请您投一个硬币:", leftPrice, totalPrice);
        coin = eingabe();
        if( coin==5 || coin==20 || coin==100 ){ //如果不是错误的硬币 
            leftPrice -= coin;
        } else {
            printf("错误的硬币.您还有 %d 从 %d Cent 中支付. 请您投一个硬币:", leftPrice, totalPrice);    
        }
    }while(leftPrice > 0); 
    //如果价格已经付清了=0, 并可能 有结余<0, 就结束循环 
    printf("物品金额已付清");
    if(leftPrice < 0) { //如果多付了钱, 剩余的钱就变成了负数 
        printf(" - 谢谢您 %d Cent 找零的捐赠！",-leftPrice);
    }
    printf("\n");
    system("pause");    
}

#ifndef _ARRAY_H_
#define _ARRAY_H_
#include <map>
#include <vector>
#include <cmath>
#define ARRAY_TEMP template <class T1, class T2>
#define ARRAY_T1S vector<T1>
#define ARRAY_T2S vector<T2>
#define ARRAY_MIT typename map<T1,T2>::const_iterator
#define ARRAY_vint typename ARRAY_T2S::size_type
#define ARRAY_for for(ARRAY_vint i=0; i<ks.size(); i++)
using namespace std;
 
enum SORTOPT {SORT_ASC, SORT_DESC};
 
ARRAY_TEMP class Array{
private:
    map<T1,T2> m;
    ARRAY_T1S ks;                                  //mark the order of keys of array
    int get_index(const int &);                    //get_index, parameter can be negtive number
                                                //range: [-size(),size()), -1=size()-1 
public:
    Array();                                    //constructor
    Array(const ARRAY_T2S &);                    //constructor, T1 must be int, keys will be 0,1,2,...
    Array(const map<T1,T2> &);                    //use map to construct an Array
    Array(const ARRAY_T1S &, const ARRAY_T2S &);//keys and values
    Array(const Array<T1,T2> &);                //use Array to construct an Array
    Array(const int &, const T2 &);                //T1 must be int, fill Array with n values
    void print_r();                                // print the array
    ARRAY_T1S keys();                            // get the keys
    ARRAY_T2S values();                            // get the values
    pair<T1,T2> front();                        // get the first key-value pair
    pair<T1,T2> back();                            // get the last
    unsigned size();                            // get the length of the Array
    bool empty();                                // tell if this Array is empty
    void clear();                                // clear this Array
    void push_back(const pair<T1,T2> &);        // add a new element with pair at the end of the Array
    void push_back(const T1 &, const T2 &);     // add a new element with a single key and value at the end of the Array
    void push_front(const pair<T1,T2> &);        // add a new element with pair at the front of the Array 
    void push_front(const T1 &, const T2 &);     // add a new element with a key and value at the front of the Array
    pair<T1,T2> pop_back();                        // erase the last pair, and return it
    pair<T1,T2> pop_front();                    // erase the first pair, and return it
    void insert(const int &, const pair<T1,T2> &);        // insert a pair at a subscript
    void insert(const int &, const T1 &, const T2 &);    // insert an element with key and value at a subscript
    void insert(const int &, map<T1,T2> &);        // insert a map at a subscript
    void insert(const int &, Array<T1,T2> &);    // insert an Array at a subscript
    T2 &operator[](const T1 &);                    // write or read a value by key
    T2 &at(const int &);                        // read a value at subscript(cannot write)
    pair<T1,T2> pair_at(const int &);            // read a pair at subscript
    T1 key_at(const int &);                        // get key at subscript
    T2 value_at(const int &);                    // get value at subscript
    bool key_exists(const T1 &);                // tell if a key exists
    bool value_exists(const T2 &);                // tell if a value exists
    bool pair_exists(const pair<T1,T2> &);        // tell if a pair exists
    bool operator==(Array<T1,T2> &);            // tell if this Array is equal to another
    bool operator!=(Array<T1,T2> &);            // tell if this Array is not equal to another
    ARRAY_T1S keys_of(const T2 &);                // get the keys of a value
    int index_of_key(const T1 &);                // get the subscript of a key
    int index_of_pair(const pair<T1,T2> &);        // get the subscript of a pair
    vector<int> indices_of_value(const T2 &);    // get the indices of a value
    void erase_at(const int &, const unsigned &len = 1); // erase elements from subscript to subscript+len
    void erase_by_key(const T1 &);                // erase element by key
    void erase_by_value(const T2 &);            // erase ELEMENTS by value
    void erase_by_pair(const pair<T1,T2> &);    // erase element by pair
    void erase(const pair<T1,T2> &);            // reload erase_by_pair
    void erase(const int &, const unsigned &len = 1); // reload erase_at
    Array<T1,T2> operator+(Array<T1,T2> &);        // return an Array = *this + another Array
    Array<T1,T2> operator+(map<T1,T2> &);        // return an Array = *this + a map
    Array<T1,T2> operator+(const pair<T1,T2> &);// return an Array = *this + a pair
    Array<T1,T2> &operator+=(Array<T1,T2> &);    // add another Array to *this
    Array<T1,T2> &operator+=(map<T1,T2> &);        // add a map to *this
    Array<T1,T2> &operator+=(const pair<T1,T2> &); // add a pair to *this
    Array< int,Array<T1,T2> > chunk(const unsigned &); // split this Array to Arrays by a given length
    Array<T1,T2> sub(const int &);                // return a part of this Array from subscript to end
    Array<T1,T2> sub(const int &, const unsigned &); // return a part of this Array from subscript to subscript+length
    Array<T1,T2> slice(const int &);            // reload sub
    Array<T1,T2> slice(const int &, const unsigned &); // reload sub
    Array<T1,T2> combine(Array<T1,T2> &);        // the same as operator+
    Array<T1,T2> merge(Array<T1,T2> &);            // combine
    Array<T2,int> count_values();                // count the values
    Array<T2,T1> flip();                        // change keys to values and values to keys
    Array<T1,T2> unique();                        // delete duplicated values
    Array<T1,T2> mapfun(T2 (*)(T2));            // map a function to each value
    Array<T1,T2> mapfun(pair<T1,T2> (*)(pair<T1,T2>)); // map a function to each pair
    Array<T1,T2> sort_by_keys(const SORTOPT &opt = SORT_ASC); // sort the elements by keys
    Array<T1,T2> sort_by_values(const SORTOPT &opt = SORT_ASC);    // sort the elements by values
    Array<T1,T2> reverse();                        // reverse the Array
    pair<T1,T2> random();                        // get a random pair of the Array
    Array<T1,T2> shuffle();                        // randomly sort the Array
    Array<T1,T2> splice(const int &, const unsigned &, const map<T1,T2> &); // replace a part of elements with a map
    Array<T1,T2> splice(const int &, const unsigned &, const Array<T1,T2> &); // replace a part of elements with an Array
};
 
ARRAY_TEMP Array<T1,T2>::Array(){ }
 
ARRAY_TEMP Array<T1,T2>::Array(const ARRAY_T2S &v2){
    unsigned n = v2.size();
    for(ARRAY_vint i=0; i<n; i++){
        ks.push_back(i);
        m[(T1)i] = v2[i];
    }
}
 
ARRAY_TEMP Array<T1,T2>::Array(const map<T1,T2> &mp){
    for(ARRAY_MIT it = mp.begin(); it!=mp.end(); it++){ks.push_back(it->first);}
    m = mp;
}
 
ARRAY_TEMP Array<T1,T2>::Array(const vector<T1> &v1, const vector<T2> &v2){
    unsigned n = v1.size()>v2.size()?v2.size():v1.size();
    ks = v1;
    for(ARRAY_vint i=0; i<n; i++){m[ks[i]] = v2[i];}
}
 
ARRAY_TEMP Array<T1,T2>::Array(const Array<T1,T2> &a){ks = a.ks; m = a.m;}
 
ARRAY_TEMP Array<T1,T2>::Array(const int &len, const T2 &value){
    for(int i=0; i<len; i++){ ks.push_back((T1)i); m[(T1)i] = value; }
}
 
ARRAY_TEMP int Array<T1,T2>::get_index(const int &index){
    if( index<-(int)ks.size()||index>=(int)ks.size() ){ 
        cerr << "Array<T1,T2>: index:" << index << " out of range:" << ks.size() << endl;
        exit(1); 
    }
    return index>=0?index:ks.size()+index;
}
 
//!!!!!!be cautious!!!!!
//use it when T1,T2 can be cout ed!
ARRAY_TEMP void Array<T1,T2>::print_r(){
    cout << "ARRAY {" << endl;
    ARRAY_for{
        cout << "t[" << i << "] " << ks[i] << " => " 
             << m[ks[i]] << " ," << endl;
    }
    cout << "}" << endl;
}
 
ARRAY_TEMP ARRAY_T1S Array<T1,T2>::keys(){return ks;}
 
ARRAY_TEMP ARRAY_T2S Array<T1,T2>::values(){
    ARRAY_T2S vs;
    ARRAY_for{vs.push_back(m[ks[i]]);}
    return vs;
}
 
ARRAY_TEMP pair<T1,T2> Array<T1,T2>::front(){return pair<T1,T2>(ks[0],m[ks[0]]);}
 
ARRAY_TEMP pair<T1,T2> Array<T1,T2>::back(){return make_pair(ks[ks.size()-1],m[ks[ks.size()-1]]);}
 
ARRAY_TEMP unsigned Array<T1,T2>::size(){return ks.size();}
 
ARRAY_TEMP bool Array<T1,T2>::empty(){return ks.size()==0;}
 
ARRAY_TEMP void Array<T1,T2>::clear(){ks.clear();m.erase(m.begin(),m.end());}
 
ARRAY_TEMP void Array<T1,T2>::push_back(const pair<T1,T2> &p){    
    m[p.first] = p.second; 
    if(!key_exists(p.first)) ks.push_back(p.first);
}
 
ARRAY_TEMP void Array<T1,T2>::push_back(const T1 &key, const T2 &value){
    m[key] = value; 
    if(!key_exists(key)) ks.push_back(key);
}
 
ARRAY_TEMP void Array<T1,T2>::push_front(const pair<T1,T2> &p){
    m[p.first] = p.second; 
    if(!key_exists(p.first)) ks.push_front(p.first);
}
 
ARRAY_TEMP void Array<T1,T2>::push_front(const T1 &key, const T2 &value){
    m[key] = value; 
    if(!key_exists(key)) ks.push_front(key);
}
 
ARRAY_TEMP pair<T1,T2> Array<T1,T2>::pop_back(){
    pair<T1,T2> p = back();
    ks.pop_back();
    m.erase(p.first);
    return p;
}
 
ARRAY_TEMP pair<T1,T2> Array<T1,T2>::pop_front(){
    pair<T1,T2> p = front();
    for(ARRAY_vint i=0; i<ks.size()-1; i++){ks[i] = ks[i+1];}
    ks.pop_back();
    m.erase(p.first);
    return p;
}
 
ARRAY_TEMP void Array<T1,T2>::insert(const int &at, const pair<T1,T2> &p){
    m[p.first] = p.second;
    if(key_exists(p.first)) return;
    int i = get_index(at);
    typename ARRAY_T1S::iterator it = find(ks.begin(),ks.end(),ks[i]);
    ks.insert(it,p.first);    
}
 
ARRAY_TEMP void Array<T1,T2>::insert(const int &at, const T1 &k, const T2 &v){
    m[k] = v;
    if(key_exists(k)) return;
    int i = get_index(at);
    typename ARRAY_T1S::iterator it = find(ks.begin(),ks.end(),ks[i]);
    ks.insert(it,k);
}
 
ARRAY_TEMP void Array<T1,T2>::insert(const int &at, map<T1,T2> &mp){
    typename ARRAY_T1S::iterator itks = (at==(int)ks.size())?ks.end():find(ks.begin(),ks.end(),ks[get_index(at)]);
    ARRAY_T1S ksmp;
    for(ARRAY_MIT it=mp.begin(); it!=mp.end(); it++) ksmp.push_back(it->first);
    ARRAY_vint s = ksmp.size();    
    for(ARRAY_vint i=0; i<s; i++){
        typename ARRAY_T1S::iterator vit =  find(ks.begin(),ks.end(),ksmp[i]);
        if(vit!=ks.end()) ksmp.erase(vit); 
        m[ksmp[i]] = mp[ksmp[i]];
    }
    ks.insert(itks,ksmp.begin(),ksmp.end());
}
 
ARRAY_TEMP void Array<T1,T2>::insert(const int &at, Array<T1,T2> &a){insert(at,a.m);}    
 
ARRAY_TEMP T2 &Array<T1,T2>::operator[](const T1 &key){
    if(!key_exists(key)) ks.push_back(key);
    return m[key];
}
 
ARRAY_TEMP T2 &Array<T1,T2>::at(const int &index){
    int p = get_index(index);
    return m[ks[p]];
}
 
ARRAY_TEMP pair<T1,T2> Array<T1,T2>::pair_at(const int &index){
    int p = get_index(index);
    return make_pair(ks[p],m[ks[p]]);
}
 
ARRAY_TEMP T1 Array<T1,T2>::key_at(const int &index){return ks[get_index(index)];}
 
ARRAY_TEMP T2 Array<T1,T2>::value_at(const int &index){return at(get_index(index));}
 
ARRAY_TEMP bool Array<T1,T2>::key_exists(const T1 &k){return find(ks.begin(),ks.end(),k)!=ks.end();}
 
ARRAY_TEMP bool Array<T1,T2>::value_exists(const T2 &k){
    ARRAY_T2S vs = values();
    typename ARRAY_T2S::iterator it = find(vs.begin(),vs.end(),k);
    return it!=vs.end();
}
 
ARRAY_TEMP bool Array<T1,T2>::pair_exists(const pair<T1,T2> &p){
    if(!key_exists(p.first)) return false;
    if( m[p.first]!=p.second ) return false;
    return true;
}
 
ARRAY_TEMP bool Array<T1,T2>::operator==(Array<T1,T2> &a){
    if( a.ks.size()!= ks.size()) return false;
    ARRAY_for{ if( ks[i]!=a.ks[i] || at(i)!=a.at(i) ){ cout << "i:"<<i <<endl;return false; }}
    return true;
}
 
ARRAY_TEMP bool Array<T1,T2>::operator!=(Array<T1,T2> &a){return !(*this==a);}
 
ARRAY_TEMP ARRAY_T1S Array<T1,T2>::keys_of(const T2 &value){
    ARRAY_T1S aks;
    ARRAY_for{ if( m[ks[i]]==value ) aks.push_back(ks[i]); }
    return aks;
}
 
ARRAY_TEMP int Array<T1,T2>::index_of_key(const T1 &key){
    if(!key_exists(key)) return -1;
    ARRAY_for{ if( ks[i]==key ) return i; }
}
 
ARRAY_TEMP int Array<T1,T2>::index_of_pair(const pair<T1,T2> &p){
    if(!pair_exists(p)) return -1;
    return index_of_key(p.first);
}
 
ARRAY_TEMP vector<int> Array<T1,T2>::indices_of_value(const T2 &value){
    vector<int> a;
    ARRAY_for{ if( m[ks[i]]==value ) a.push_back(i); }
    return a;
}
 
ARRAY_TEMP void Array<T1,T2>::erase_at(const int &index, const unsigned &len){
    print_r();
    int p = get_index(index), s = p+len>=(int)ks.size()?(int)ks.size():(p+len);
    for(int i=p; i<s; i++){
        m.erase(ks[p]);
        ks.erase(find(ks.begin(),ks.end(),ks[p]));
    }
}
 
ARRAY_TEMP void Array<T1,T2>::erase_by_key(const T1 &key){
    m.erase(key);
    ks.erase(find(ks.begin(),ks.end(),key));
}
 
ARRAY_TEMP void Array<T1,T2>::erase_by_value(const T2 &value){
    ARRAY_T1S ekeys = keys_of(value);
    for(ARRAY_vint i=0; i<ekeys.size(); i++){
        m.erase(ekeys[i]);
        ks.erase(find(ks.begin(),ks.end(),ekeys[i]));
    }
}
 
ARRAY_TEMP void Array<T1,T2>::erase_by_pair(const pair<T1,T2> &p){
    if(!pair_exists(p)) return;
    erase_by_key(p.first);
}
 
ARRAY_TEMP void Array<T1,T2>::erase(const pair<T1,T2> &p){erase_by_pair(p);}
 
ARRAY_TEMP void Array<T1,T2>::erase(const int &index, const unsigned &len){erase_at(index,len);}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::operator+(Array<T1,T2> &a){return *this + a.m;}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::operator+(map<T1,T2> &mp){
    Array<T1,T2> b = *this;
    b.insert(ks.size(),mp);
    return b;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::operator+(const pair<T1,T2> &p){
    Array<T1,T2> b = *this;
    b.push_back(p);
    return b;
}
 
ARRAY_TEMP Array<T1,T2> &Array<T1,T2>::operator+=(Array<T1,T2> &a){*this = *this + a; return *this;}
 
ARRAY_TEMP Array<T1,T2> &Array<T1,T2>::operator+=(map<T1,T2> &mp){*this = *this + mp; return *this;}
 
ARRAY_TEMP Array<T1,T2> &Array<T1,T2>::operator+=(const pair<T1,T2> &p){*this = *this + p; return *this;}
 
ARRAY_TEMP Array< int,Array<T1,T2> > Array<T1,T2>::chunk(const unsigned &len){
    Array< int,Array<T1,T2> > aa;
    Array<T1,T2> a;
    ARRAY_for{
        a += pair_at(i);
        if( (i+1)%len==0 || i==ks.size()-1 ){ aa += make_pair(aa.size(),a); a.clear(); }
    }
    return aa;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::sub(const int &i, const unsigned &l){
    Array<T1,T2> a;
    int p = get_index(i);
    for(ARRAY_vint x=i; x<i+l; x++){a += pair_at(x);}
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::sub(const int &i){return sub(i,ks.size()-i);}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::slice(const int &i, const unsigned &l){return sub(i,l);}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::slice(const int &i){return sub(i);}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::combine(Array<T1,T2> &a){return *this + a;}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::merge(Array<T1,T2> &a){return *this + a;}
 
ARRAY_TEMP Array<T2,int> Array<T1,T2>::count_values(){
    Array<T2,int> result;
    ARRAY_for{
        if(result.key_exists(m[ks[i]])) result[m[ks[i]]] = result[m[ks[i]]] + 1;
        else result[m[ks[i]]] = 1;
    }
    return result;
}
 
ARRAY_TEMP Array<T2,T1> Array<T1,T2>::flip(){
    Array<T2,T1> a;
    ARRAY_for{a.push_back(m[ks[i]],ks[i]);}
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::unique(){
    Array<T1,T2> a;
    ARRAY_for{ if(!a.value_exists(at(i))) a+=pair_at(i); }
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::mapfun(T2 (*f)(T2)){
    Array<T1,T2> a;
    ARRAY_for{    a[ks[i]] = (*f)(m[ks[i]]);}
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::mapfun(pair<T1,T2> (*f)(pair<T1,T2>)){
    Array<T1,T2> a;
    ARRAY_for{    a += (*f)(pair_at(i));}
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::sort_by_keys(const SORTOPT &opt){
    Array<T1,T2> a = *this;
    if( opt==SORT_ASC )    sort(a.ks.begin(), a.ks.end());
    else sort(a.ks.begin(), a.ks.end(), greater<T1>());
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::sort_by_values(const SORTOPT &opt){
    Array<T1,T2> a = *this;
    ARRAY_T2S vs = values();
    if( opt==SORT_ASC )    sort(vs.begin(), vs.end());
    else sort(vs.begin(), vs.end(), greater<T1>());
    a.ks.clear();
    for(ARRAY_vint i=0; i<vs.size(); i++){
        ARRAY_T1S ksof = keys_of(vs[i]);
        for(ARRAY_vint j=0; j<ksof.size(); j++){
            a.ks.push_back(ksof[j]);
        }
    }
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::reverse(){    
    Array<T1,T2> a;
    for(int i=ks.size()-1; i>=0; i--){ a += pair_at(i); }
    return a;
}
 
ARRAY_TEMP pair<T1,T2> Array<T1,T2>::random(){
    srand(time(NULL));
    return pair_at( rand()%ks.size() );
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::shuffle(){
    Array<T1,T2> a, b = *this;
    while(!b.empty()){
        pair<T1,T2> p = b.random();
        a += p;
        b.erase(p);
    }
    return a;    
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::splice(const int &at, const unsigned &len, const map<T1,T2> &mp){
    Array<T1,T2> a = *this;
    int p = get_index(at);
    a.erase(p,len);
    a.insert(at,mp);
    return a;
}
 
ARRAY_TEMP Array<T1,T2> Array<T1,T2>::splice(const int &at, const unsigned &len, const Array<T1,T2> &a){
    return splice(at,len,a.m);
}
 
#endif

/*******************************************************
#
# Panwen Wang, April 29th, 2009
# pwwang AT pwwang.com
# get eigenvalue and eigenvector of
# a real symmetric matrix like
#  1  -1  0 
# -1   1  2
#  0   2  1
#
# Algorthm:
# 1. get a nonzero and non-diagonal element a[i,j] of matrix A, usually
#    the maximun absolute value of non-diagonal elements of A (max(A));  
# 2. give sin(phi) and cos(phi) by 
#    ( a[j,j]-a[i,i] )*sin(2*phi) + 2*a[i,j]*cos(2*phi) = 0 ;
#    => tan(2*phi) = 2*a[i,j]/(a[i,i]-a[j,j]) 
#    => phi = arctan(2*a[i,j]/(a[i,i]-a[j,j]))/2 
# 3. get elements of a new matrix A1(a1[i,j]) by
#    a1[i,i] = a[i,i]*cos^2(phi) + a[j,j]*sin^2(phi) + 2*a[i,j]*cos(phi)*sin(phi)
#    a1[j,j] = a[i,i]*sin^2(phi) + a[j,j]*cos^2(phi) - 2*a[i,j]*cos(phi)*sin(phi)
#    a1[i,l] = a1[l,i] = a[i,l]*cos(phi) + a[j,l]*sin(phi)       ( l!=i,j )
#    a1[j,l] = a1[l,j] = -a[i,l]*sin(phi) + a[j,l]*cos(phi)      ( l!=i,j )
#    a1[l,m] = a1[m,l] = a[m,l]                                  ( m,l != i,j )
#    a1[i,j] = a1[j,i] = { (a[j,j]-a[i,i])*sin(2*phi) }/2 + a[i,j]*(cos^2(phi) - sin^2(phi))
# 4. let A1 be the substitution of A, repeat step 1,2,3 and get A2, and A3,A4,...,An can be 
#    obtained by the same way. Calculation ceases if max(An) is less than the given threshold.
#
# Usage:
#        JACOBI_ARRAY ja(3), value;
#        JACOBI_MATRIX jm, vector;
#        ja[0] = 1; ja[1] = -1; ja[2] = 0;
#        jm.push_back(ja);
#        ja[0] = -1; ja[1] = 1; ja[2] = 2;
#        jm.push_back(ja);
#        ja[0] = 0; ja[1] = 2; ja[0] = 1;
#        jm.push_back(ja);
#        Jacobi j;
#        j.setMatrix(jm);
#         value = j.getEigenvalues();
#        vector = j.getEigenvectors();
#
********************************************************/
#ifndef _JACOBI_H_
#define _JACOBI_H_
#include <vector>
#include <cmath>
#define JACOBI_ARRAY vector<double>
#define JACOBI_MATRIX vector< vector<double> >
#define JACOBI_vint vector<double>::size_type
using namespace std;
 
class Jacobi{
private:
    JACOBI_MATRIX matrix;
    JACOBI_ARRAY  eigenvalues;
    JACOBI_MATRIX eigenvectors;
    double e;   //precision
    int dimen;
    bool debug;
 
    double max(const JACOBI_MATRIX &, int &, int &);
    JACOBI_MATRIX newMatrix(const JACOBI_MATRIX &, const int &, const int &, const double &);
    void jacobi();
 
public:
    Jacobi();
    void setMatrix(const JACOBI_MATRIX &);
    void setE(const double &);
    void setDebug(const bool &d = true);
    JACOBI_ARRAY getEigenvalues();
    JACOBI_MATRIX getEigenvectors();
    void printEigen();
    void printMatrix();
    void printMatrix(const JACOBI_MATRIX &);
    void demo();
};
 
Jacobi::Jacobi():e(1e-5),debug(false){}
 
void Jacobi::setE(const double &ee){ e = ee; }
 
void Jacobi::setDebug(const bool &d){ debug = d; }
 
void Jacobi::setMatrix(const JACOBI_MATRIX & jm){
    dimen = jm.size();
    matrix = jm;
    eigenvalues.resize(dimen);
    eigenvectors.resize(dimen);
    //matrix.resize(dimen);
    //for(JACOBI_vint i=0; i<dimen; i++){ matrix[i] = jm[i];}
    jacobi();
}
 
JACOBI_ARRAY Jacobi::getEigenvalues(){return eigenvalues;}
 
JACOBI_MATRIX Jacobi::getEigenvectors(){return eigenvectors;}
 
double Jacobi::max(const JACOBI_MATRIX &jm, int &maxi, int &maxj){
    double m = jm[0][1];
    maxi=0, maxj=1;
    for(JACOBI_vint i=0; i<dimen; i++)
        for(JACOBI_vint j=0; j<dimen; j++)
            if(i!=j)
                if(fabs(jm[i][j])>m){
                    m = fabs(jm[i][j]);
                    maxi = i; maxj = j;
                }
    return m;
}
 
JACOBI_MATRIX Jacobi::newMatrix(const JACOBI_MATRIX &jm, const int &i, const int &j, const double &phi){
    JACOBI_MATRIX jm1(dimen);
    double sp = sin(phi), cp = cos(phi);
    for(int ii=0; ii<dimen; ii++){
        jm1[ii].resize(dimen);
        for(int jj=0; jj<dimen; jj++){
            if( ii==i ){     // row i
                if( jj==i ) jm1[ii][jj] = jm[i][i]*cp*cp + jm[j][j]*sp*sp + 2*jm[i][j]*cp*sp; 
                else if( jj==j ) jm1[ii][jj] = (jm[j][j]-jm[i][i])*sp*cp + jm[i][j]*(cp*cp-sp*sp); 
                else jm1[ii][jj] = jm[i][jj]*cp + jm[j][jj]*sp;
            } else if ( ii==j ) {// row j
                if( jj==i ) jm1[ii][jj] = (jm[j][j]-jm[i][i])*sp*cp + jm[i][j]*(cp*cp-sp*sp);
                else if( jj==j ) jm1[ii][jj] = jm[i][i]*sp*sp + jm[j][j]*cp*cp - 2*jm[i][j]*cp*sp;
                else jm1[ii][jj] = jm[j][jj]*cp - jm[i][jj]*sp;
            } else {            // row l ( l!=i,j )
                if( jj==i ) jm1[ii][jj] = jm[i][ii]*cp + jm[j][ii]*sp;
                else if( jj==j ) jm1[ii][jj] = jm[j][ii]*cp - jm[i][ii]*sp;
                else jm1[ii][jj] = jm[ii][jj];
            }
        }
    }    
    return jm1;
}
 
void Jacobi::jacobi(){
    JACOBI_MATRIX jm = matrix;  // initial matrix
    double phi, m;
    int i,j;
    JACOBI_MATRIX tempVectors(dimen), vectors(dimen), cmat(dimen);
    for(JACOBI_vint x=0; x<dimen; x++){
        tempVectors[x].resize(dimen);
        for(JACOBI_vint y=0; y<dimen; y++){
            if(x==y) { tempVectors[x][y] = 1.0; } 
            else { tempVectors[x][y] = 0.0; }
        }
    }
 
    for( ;; ){ // step 4
        m =  max(jm,i,j);  // step 1
        if(debug) printf("%-3d, %-3d, %.9f\n",i,j,m);
        if( m < e ) break; 
        // if the maximum value of the matrix LE(Less than or Equal to) the limit, break
        phi = atan2(2*jm[i][j], jm[i][i] - jm[j][j]) / 2;  // step 2
        jm = newMatrix(jm,i,j,phi); // step 3
        for(JACOBI_vint x=0; x<dimen; x++){
            cmat[x].resize(dimen);
            vectors[x].resize(dimen);
            for(JACOBI_vint y=0; y<dimen; y++){
                if(x==y) { cmat[x][y] = 1.0; }
                else { cmat[x][y] = 0.0; }
                vectors[x][y] = 0.0;
            }
        }    
        cmat[i][i] = cos(phi);
        cmat[j][j] = cos(phi);
        cmat[i][j] = -sin(phi);
        cmat[j][i] = sin(phi);    
        for(JACOBI_vint x=0; x<dimen; x++){ // for eigenvectors
            for(JACOBI_vint y=0; y<dimen; y++){
                for(JACOBI_vint z=0; z<dimen; z++){
                    vectors[x][y] = vectors[x][y] + tempVectors[x][z] * cmat[z][y];
                }
                //print vectors[x][y],"-",tempVectors[x][y]," ";
            }
        }
        tempVectors = vectors;
        //@tempVectors = @vectors;
    }
    // the digonal elements are the eigenvalues
    for(JACOBI_vint x=0; x<dimen; x++) eigenvalues[x] = jm[x][x] ;
 
    for(JACOBI_vint x=0; x<dimen; x++){
        eigenvectors[x].resize(dimen);
        for(JACOBI_vint y=0; y<dimen; y++){
            eigenvectors[x][y] = vectors[y][x];
        }
    }
    if(debug) printEigen() ;
}
 
void Jacobi::printEigen(){
    for(JACOBI_vint i=0; i<dimen; i++){
        cout << "Eigenvalue [" << i << "]: " << eigenvalues[i] << "\n";
        cout << "Eigenvector[" << i << "]: [ ";
        for(JACOBI_vint j=0; j<dimen; j++){
            printf("%9.6f, ",eigenvectors[i][j]);
        }
        cout << " ] \n";
    }
}
 
void Jacobi::printMatrix(){ printMatrix(matrix); }
 
void Jacobi::printMatrix(const JACOBI_MATRIX &jm){
    for(JACOBI_vint i=0; i<dimen; i++){
        for(JACOBI_vint j=0; j<dimen; j++){
            printf("%9.6f, ", jm[i][j]);
        }
        cout << "\n";
    }
}
 
void Jacobi::demo(){
    dimen = 3;
    eigenvalues.resize(dimen);
    eigenvectors.resize(dimen);
    matrix.resize(dimen);
    debug = false;
    e = 1e-5;    
    JACOBI_ARRAY ja(3);
    ja[0] = 2; ja[1] = -1; ja[2] = 0;
    matrix[0] = ja;
    ja[0] = -1; ja[1] = 2; ja[2] = -1;
    matrix[1] = ja;
    ja[0] = 0; ja[1] = -1; ja[2] = 2;
    matrix[2] = ja;
    printMatrix();
    jacobi();
    printEigen();    
    /*
     2.000000, -1.000000,  0.000000, 
    -1.000000,  2.000000, -1.000000, 
     0.000000, -1.000000,  2.000000, 
    Eigenvalue [0]: 3.41421
    Eigenvector[0]: [  0.500000, -0.707107,  0.500000,  ] 
    Eigenvalue [1]: 2
    Eigenvector[1]: [  0.707107,  0.000000, -0.707107,  ] 
    Eigenvalue [2]: 0.585786
    Eigenvector[2]: [  0.500000,  0.707107,  0.500000,  ]
    */    
}
 
#endif

#ifndef _STR_H_
#define _STR_H_
#include <string>
#include <cmath>
#include <cctype>
//#include <algorithm>
#include "Array.h"
#ifndef sint
#define sint string::size_type
#endif
#ifndef ints
#define ints Array<int,int>
#endif
#ifndef strings
#define strings Array<int,string>
#endif
using namespace std;
 
/*****************
 * string addslashes ( string str )
 *
 * 返回字符串，该字符串为了数据库查询语句等的需要在某些字符前加上了反斜线。
 * 这些字符是单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）。
 * /     
string addslashes(const string &str){
    string temp = "";
    for(sint i=0; i!=str.size(); i++){
        if(str[i]==chr(39) || str[i]==chr(34) || str[i]==chr(92) || str[i]==chr(0)){
            temp += '\\' ;
            temp += str[i];
        } else temp += str[i];
    }
    return temp;
}
*/
 
/*****************
 *    string rtrim ( string str [, string charlist] )
 *
 *  This function returns a string with whitespace stripped from the end of str.
 *  Without the second parameter, rtrim() will strip these characters:
 *  " " (ASCII 32 (0x20)), an ordinary space. 
 *  "\t" (ASCII 9 (0x09)), a tab.
 *  "\n" (ASCII 10 (0x0A)), a new line (line feed).
 *  "\r" (ASCII 13 (0x0D)), a carriage return.
 *  "\0" (ASCII 0 (0x00)), the NUL-byte. 
 */ 
string rtrim(const string &str, const string &charlist = " \t\n\r\0"){
    string s = str;
    for(sint i=0; i!=charlist.size(); i++){
        if( s.rfind(charlist[i])==s.size()-1 ){ 
            s=rtrim(s.substr(0,s.size()-1)); 
        }    
    }
    return s;
}
 
/***********
 * string chr ( int ascii )
 *  
 * 返回相对应于 ascii 所指定的单个字符。
 */ 
char chr(const int &asc){
    return (char)asc;
}
 
/***********
 * int ord ( string string )
 *  
 * Returns the ASCII value of the first character of string.
 */
int ord(const char &c){
    return (int)c;
} 
 
/***********
 * return the ascii of the first char of str
 */  
int ord(const string &str){
    return (int)str[0];
} 
 
/***********
 * int asc(string string)
 * This is an alias of ord 
 */ 
int asc(const char &c){
    return ord(c);
} 
int asc(const string &str){
    return ord(str);
}
 
/************
 * mixed count_chars ( string string  )
 * 
 * 统计 string 中每个字节值（0..255）出现的次数。
 */  
ints count_chars(const string &str){
    ints is(256,0);
    for(sint i=0; i!=str.size(); i++){
        is[ord(str[i])] ++ ;
    }
    return is;
}
 
/*************
 * array explode ( string separator, string string [, int limit] )
 *  
 * 此函数返回由字符串组成的数组，每个元素都是 string 的一个子串，
 *  它们被字符串 separator 作为边界点分割出来。
 */   
strings explode(const string &separator, const string &str){
    string s = str;
    strings ss;
    sint pos;
    do{
        pos = s.find(separator);
        ss += make_pair(ss.size(),string(s,0,s.find_first_of(separator)));
        s = s.substr(pos+separator.size());
    } while ( pos!=string::npos );
    return ss;
}
 
strings split(const string &separator, const string &str){
    return explode(separator, str);
}
 
strings str_split(const string &separator, const string &str){
    return explode(separator, str);
}
 
/**************
 * string implode ( string glue, array pieces )
 *  
 * Returns a string containing a string representation of all the array
 * elements in the same order, with the glue string between each element. *
 */    
string implode(const string &glue, strings &ss){
    string s = ss[0] ;
    for(sint i=1; i!=ss.size(); i++){
        s += glue + ss[i];
    }
    return s;
}
 
string join(const string &glue, strings &ss){
    return implode(glue,ss);
}
 
/*****************
 *    string ltrim ( string str [, string charlist] )
 *
 *  This function returns a string with whitespace stripped from the beginning of str.
 *  Without the second parameter, rtrim() will strip these characters:
 *  " " (ASCII 32 (0x20)), an ordinary space. 
 *  "\t" (ASCII 9 (0x09)), a tab.
 *  "\n" (ASCII 10 (0x0A)), a new line (line feed).
 *  "\r" (ASCII 13 (0x0D)), a carriage return.
 *  "\0" (ASCII 0 (0x00)), the NUL-byte.
 *  "\x0B" (ASCII 11 (0x0B)), a vertical tab.  
 */ 
string ltrim(const string &str, const string &charlist=" \t\n\r\0"){
    string s = str;
    for(sint i=0; i!=charlist.size(); i++){
        if(s.find(charlist[i])==0){s=ltrim(s.substr(1));}    
    }
    return s;
}
 
//trim a string
string trim(const string& str){
    string s=str;
    //trim left
    s = ltrim(str);
    //trim right
    s = rtrim(s);
    return s;
}
 
/**************
 * string str_replace(string search, string replace, string subject[ , int &count])
 *
 * This function returns a string with all occurrences of search 
 *  in subject replaced with the given replace value. 
 *  The amount of occurrences will be stored in count if given  
 */    
string str_replace(const string &search, const string &replace, const string &subject, int &count){
    strings ss = split(search, subject);
    count = ss.size() - 1;
    return join(replace, ss);
}
 
string str_replace(const string &search, const string &replace, const string &subject){
    strings ss = split(search, subject);
    return join(replace, ss);
}
 
/***************
 * string strtolower(string string)
 *  
 * Make a string lowercase
 */  
string strtolower(const string &str){
    string s = "";
    for(sint i=0; i!=str.size(); i++){
        s += tolower(str[i]);
    }
    return s;
}
 
/***************
 * string strtoupper(string string)
 *  
 * Make a string uppercase
 */  
string strtoupper(const string &str){
    string s = "";
    for(sint i=0; i!=str.size(); i++){
        s += toupper(str[i]);
    }
    return s;
}
 
/**************
 * string str_ireplace(string search, string replace, string subject[ , int &count])
 *
 * Case-insensitive str_replace
 */ 
string str_ireplace(const string &search, const string &replace, const string &subject, int &count){
    ints is(subject.size(),0);
    for(sint i=0; i!=subject.size(); i++){
        if(isupper(subject[i])) is[i] = 1;
    }
    string str = strtolower(subject);
    string srh = strtolower(search);
    strings ss = split(srh, str);
    count = ss.size() - 1;
    strings rs(ss.size(),string(""));
    sint pos = 0;
    for(sint i=0; i!=ss.size(); i++){
        for(sint j=0; j!=ss[i].size(); j++){
            if(is[pos]) rs[i] = strtoupper(ss[i]);
            else rs[i] = ss[i];
            pos++;
        }
        pos += search.size();
    }
    return join(replace, rs);
}
 
string str_ireplace(const string &search, const string &replace, const string &subject){
    ints is(subject.size(),0);
    for(int i=0; i!=subject.size(); i++){
        if(isupper(subject[i])) is[i] = 1;
    }
    string str = strtolower(subject);
    string srh = strtolower(search);
    strings ss = split(srh, str);
    strings rs(ss.size(),string(""));
    sint pos = 0;
    for(int i=0; i!=ss.size(); i++){
        for(sint j=0; j!=ss[i].size(); j++){
            if(is[pos]) rs[i] = strtoupper(ss[i]);
            else rs[i] = ss[i];
            pos++;
        }
        pos += search.size();
    }
    return join(replace, rs);
}
 
/***************
 * string str_repeat ( string input, int multiplier )
 * 
 * Returns input_str repeated multiplier times. 
 * multiplier has to be greater than or equal to 0. 
 * If the multiplier is set to 0, the function will return an empty string. 
 */   
string str_repeat(const string &input, const int &mult){
    string s = "";
    for(int i=0; i<mult; i++){
        s += input;
    }
    return s;
}
 
/***************
 * string str_shuffle ( string str )
 * 
 * str_shuffle() shuffles a string.
 */
string str_shuffle(const string &str){
    string s = "";
    ints subscripts;
    for(sint i=0; i!=str.size(); i++) subscripts[i] = i;
    while(!subscripts.empty()){
        srand(time(NULL));
        int r = rand() % subscripts.size();
        s += str[subscripts[r]];
        subscripts.erase(subscripts[r]);
    }
    return s;
} 
 
/***************
 * int str_word_count(string string)
 *
 * Counts the number of words inside string.
 */ 
int str_word_count(const string &str){
    strings ss = split(" ", str);
    int count = 0;
    for(sint i=0; i!=ss.size(); i++){
        if(!ss[i].empty()) count++;
    }
    return count;
}
 
/****************
 * string strstr ( string haystack, string needle )
 * 
 * Returns part of haystack string from the first occurrence of needle to the end of haystack. 
 */
string strstr(const string &haystack, const string &needle){
    return haystack.substr(haystack.find_first_of(needle));
}
 
string strchr(const string &haystack, const string &needle){
    return strstr(haystack, needle);
}
 
/*****************
 * int stripos ( string haystack, string needle)
 *
 * stripos --  Find position of first occurrence of a case-insensitive string 
 */    
sint stripos(const string &haystack, const string &needle){
    return strtolower(haystack).find_first_of(strtolower(needle));
}
 
/*****************
 * int strlen ( string string )\
 * 
 * Returns the length of the given string.
 */
sint strlen(const string &str){
    return str.size();
}  
 
/*****************
 * int strpos ( string haystack, string needle)
 *
 * strpos --  Find position of first occurrence of a string 
 */    
sint strpos(const string &haystack, const string &needle){
    return haystack.find_first_of(needle);
}
 
/*****************
 * int strrchr ( string haystack, string needle)
 *
 * strrchr --  Find position of last occurrence of a string 
 */    
sint strrchr(const string &haystack, const string &needle){
    return haystack.find_last_of(needle);
}
 
/*****************
 * string strrev ( string string )
 * 
 * Returns string, reversed. 
 */   
string strrev(const string &str){
    string s = "";
    for(int i=str.size()-1; i>=0; i--){
    // type of i here must be int, not sint(string::size_type), 
    // because the last i is -1
        s += str[i];
    }
    return s;
}
 
/*****************
 * int strripos ( string haystack, string needle)
 *
 * strripos --  Find position of last occurrence of a case-insensitive string 
 */    
sint strripos(const string &haystack, const string &needle){
    return strtolower(haystack).find_last_of(strtolower(needle));
}
 
/*****************
 * int strrpos ( string haystack, string needle)
 *
 * strrpos --  Find position of last occurrence of a string 
 */    
sint strrpos(const string &haystack, const string &needle){
    return haystack.find_last_of(needle);
}
 
//for int
string num2str(const int &num, const string &format = "%d"){
/*    int temp = num;
    string str = "";
    string flag; 
    if( temp==0 ) return "0";
    flag = temp<0 ? "-" : "";
    temp = abs(temp);
    while( temp!=0 ){
        str = char( int(temp % 10)+48 ) + str;
        temp = (int)temp/10;
    }
    return flag+str;
*/
    char s[32];
    sprintf(s, format.c_str(), num);
    return string(s);
}
 
// for float
string num2str(const double &num, const string &format = "%f"){
/*    int ipart = (int)num;
    double fpart = num - (double)ipart;
    cout << fpart << endl;
    if( ipart<0 ) fpart = -fpart;
    string s = num2str(ipart);
    s += ".";
    s += num2str((int)(fpart*pow(10,(double)fracdigital)));
    return s;
*/
    char s[32];
    sprintf(s, format.c_str(), num);
    return string(s);
}
 
/*************
 * string left(string str, int n)
 *
 * return a string containing left n chars of str
 */   
string left(const string &str, const int &n){
    return str.substr(0,n);
}
 
/*************
 * string right(string str, int n)
 *
 * return a string containing right n chars of str
 */   
string right(const string &str, const int &n){
    return str.substr(str.size()-n);
}
 
/*************
 * string substr(string str, int pos[, int n])
 *
 * return a string containing n chars from pos of str
 */  
string substr(const string &str, const int &pos, const unsigned &n){
    int p = pos, s = str.size();
    if( p<=-s || p>=s ){
        cerr << "Warning: substr: invalid parameter pos " 
             << p << ", str.size() = " 
             << s << endl;
        return "";
    }
    if( p<0 ) p += s;
    return str.substr(p,n);
}
 
string substr(const string &str, const int &pos){
    return substr(str,pos,str.size()-pos);
}
 
string mid(const string &str, const int &pos, const unsigned &n){
    return substr(str,pos,n);
}
 
/*************
 * double str2num(const string &str)
 *
 * convert a string to a double 
 */   
double str2num(const string &str){
    strings ss = split(".",str);
    bool flag = true;
    double s = 0.;
    if(ss.size()>2){
        cerr << "Warning: str2num: too many points in " << str << ", preserve the first one." << endl;
        for(sint i=2; i<ss.size(); i++)
            ss[1] += ss[i];
    }
    if( left(ss[0],1)=="-" ){
        flag = false;
        ss[0] = ss[0].substr(1);
    } else if( left(ss[0],1)=="+" ){ 
        ss[0] = ss[0].substr(1);
    }
    string ss0 = "";
    for(string::size_type i=0; i<ss[0].size(); i++){
        if(isdigit(ss[0][i])) ss0 += ss[0][i];
    }
    for(sint i=0; i<ss0.size(); i++){
        if(isdigit(ss0[i])) s += ((int)ss0[i]-48)*pow(10.,(double)(ss0.size()-i-1));
    }
    if(ss.size()>1){
        int n = 0;
        for(sint i=0; i<ss[1].size(); i++){
            if(isdigit(ss[1][i])) s += ((int)ss[1][i]-48)*pow(10.,(double)(-1-n));
            else n--;
            n++;
        }
    }
    return flag?s:-s;
}
 
#endif

bool parseCommandLine(int argc, char * argv[]) {
    int argct = 1;
    string temp;
    if (argc==1) {   // 没有给出参数的时候给出一些程序的说明
        cout << "n  -- XXX programs --n";               
        cout << "  给出你程序的信息和说明nn";
        cout << "  程序各参数的意义:n"
        cout << "  -i <file>      Input filen";  
        cout << "  -o <file>      Output filen";
        cout << "  -l <label>     Label for this runn"; 
        cout << "n";
        cout << "  程序的用法:n"
        cout << "  ./XXX -i inputn";
        cout << "  ./XXX -i input -o outputn";
        cout << "  ./XXX -i input -o output -l firstn";                       
        cout << "n";
        return false; 
    } else {       // 进行参数选项和参数的读取
        while (argct < argc) {
            temp = argv[argct]; // 存放参数选项(如-i,-o,-l)
            if (temp == "-i") {
        argct++;         //从参数选项指向参数
        ioparm.input = argv[argct]; //将读取的参数存入全局变量中
        // 可以对参数进行检测,如果不符合要求就直接return false.
            } else if (temp == "-o") {
        argct++; 
        ioparm.output = argv[argct];
            } else if (temp == "-l") {
        argct++; 
        ioparm.label = argv[argct];
            } else { 
        cout << " Warning: ignored argument " << argct << " : " << temp << endl;
        // 如果不是给定的参数选项,则忽略这一个参数,如:
        // ./XXX -i input -t a -o output  这里的 -t 和 a将被逐个忽略
        }
            argct++;            //指向下一个参数选项
        }
    }
    //读完了之后可以对必须的参数予以检测, 如:
    //或者在上面读取的时候就可以检测, 如果不符合要求就直接return false
    if (ioparm.input.empty()) {
    cout << " Error: argument "-i" is essential. " << endl;
    return false;
    }
    return true;
}

string s1;         //空串
string s2(s1);         //将s2初始化为s1的一个副本
string s3("value");    //s3初始化并赋值
string s4(n,"c");    //s4初始化,赋值为n个'c'
string s5(b,e);        //初始化s5为迭代器b,e范围内的副本
string s6(cp);        //用c风格的字符串初始化
string s7(cp,n);    //cp前n个元素的副本
string s8(s2,pos2);    //s8为s2从pos2开始到结尾的副本
string s9(s2,pos2,len2);//同上,不过的长度为len2(不超过s2的长度)
//其中有一种方法需要注意:
char no_null[] = {'H','i'};
string s10(no_null);    //错误,不是以null结尾的串
string s10(no_null,2);    //ok,可以自动添加null结尾

string s;
cin >> s;
cout << s << endl;
//注意,cin是会被空白符截断的
//要得到整行输入,采用while循环,或者:
getline(cin,s);

s.empty();    //判断s是否为空,相当于s.size()==0
s.size();    //s的长度
s[n];        //n位置的字符(左值返回)
s1+s2;        //返回s1和s2连接的串
s1=s2;        //把s1替换为s2的副本
s1==s2;        //判断s1,s2是否相等
!=,<,<=,>,>=    //按字典顺序比较
//==================
s.insert(p,t);    //在迭代器p指向的元素前插入t,返回指向t的迭代器
s.insert(p,n,t);//同上,插入n个t,返回void
s.insert(p,b,e);//插入迭代器b,e间的元素,返回void
s.insert(pos,n,c); //在pos前插入n个字符c,返回s的引用
s.insert(pos,s2);//在pos前插入s2,返回s的引用
s.insert(pos,s2,pos2,len); 
//在pos前插入s2中从pos2开始的len个字符,返回s的引用
s.insert(pos,cp,len);
//pos前插入cp数组(c风格字串)的前len个字符,返回s的引用
s.insert(pos,cp);//在pos前插入cp,返回s的引用
//==================
s.assign(b,e);    //用b,e间的元素替换s,返回s
s.assign(n,t);    //用n个t替换s,返回s
s.assign(s2);    //用s2的副本替换s,返回s的引用
s.assign(s2,pos2,len);
//用s2从pos2开始的len长的副本替换s,返回s的引用
s.assign(cp,len)//用cp的前len个字符副本替换s,返回s的引用
s.assign(cp)    //用cp的副本替换s,返回s的引用
//==================
s.erase(p);    //删除迭代器p指向的元素,返回指向后一个元素的迭代器
s.erase(b,e);    //删除b,e间的元素,返回值同上
s.erase(pos,len);//删除从pos开始的len个字符,返回s的引用
//==================
s.substr(pos,n);//返回s中从pos开始的n个字符组成的串
s.substr(pos);    //返回s中从pos开始到结尾的串
s.substr();    //返回s的副本
//==================
s.append(args);    //将args串接在s的后面,返回s的引用
//==================
s.replace(pos,len,args);
//删除s中从pos开始的len个字符,用args串替换,返回s的引用
//args不能为b2,e2
s.replace(b,e,args);
//删除迭代器b,e范围内的字符,用args替换,返回s的引用
//args不能为s2,pos2,len2
//==================append,replace的args的说明
s2        //string
s2,pos2,len2    //s2中下pos2开始的len2个字符
cp        //c风格的串
cp,len2        //cp指向以空结束的前len2个字符
n,c        //字符c的n个副本
b2,e2        //迭代器b2,e2范围内的所有字符

s.find(args);    //args的第一次出现
s.rfind(args);    //最后一次出现
s.find_first_of(args);//args中任意字符的第一次出现
s.find_last_of(args);//args中任意字符的最后一次出现
s.find_first_not_of(args);//查找第一个不属于args的字符
s.find_last_not_of(args);//查找最后一个不属于args的字符
//=================args
c,pos=0        //查找字符c,默认从s的0位置开始
s2,pos=0    //查找s2
cp,pos=0    //查找cp(c风格字串)
cp,pos,n    //从s的pos开始查找cp的前n个字符,没有默认值

s.compare(s2);    //比较s和s2
s.compare(pos1,n1,s2);//s从pos1开始的n1个字符与s2比较
s.compare(pos1,n1,s2,pos2,n2);
//s从pos1开始的n1个字符与s2从pos2开始的n2个字符比较
s.compare(cp); //比较s和cp
s.compare(pos1,n1,cp); //s从pos1开始的n1个字符与cp比较
s.compare(pos1,n1,cp,n2); //s从pos1开始的n1个字符与cp的前n2个字符比较
//compare的返回值: >0 s大; <0 s小; =0 二者相等

isalnum(c);    //true if c 是数字或字母
isalpha(c);    //true if c 是字母
iscntrl(c);    //true if c 是控制字符
isdigit(c);    //true if c 是数字
isgraph(c);    //true if c 不是空格但可打印
islower(c);    //true if c 是标点符号
isprint(c);    //true if c 是空白字符
ispunct(c);    //true if c 是大写字母
isspace(c);    //true if c 是空白字符
isupper(c);    //true if c 是大写字符
isxdigit(c);    //true if c 是十六进制数
tolower(c);    //将c转换为小写
toupper(c);    //将c转换为大写

#ifndef _PDB_H_  
#define _PDB_H_ 
 
#include<iostream> 
#include<fstream> 
#include<cstdio> 
#include<string>  
#include<vector>  
 
#define atoms vector<atom>  
#define chains vector<chain>  
#define aint vector<atom>::size_type  
#define cint vector<chain>::size_type   
 
using namespace std;   
 
class atom{   
private:   
    short atom_id;   
    string atom_nick;   
    string atom_res;   
    char atom_chain;   
    short atom_res_id;   
    float atom_x, atom_y, atom_z, atom_w, atom_bfactor;   
    char atom_name;   
 
public:   
    atom(short, string, string, char, short, float, float, float, float, float, char);   
    atom(string);   
    string line();   
};   
 
atom::atom( short a_id,   
            string a_nick,   
            string r,   
            char c,   
            short r_id,   
            float a_x,   
            float a_y,   
            float a_z,   
            float a_w,   
            float b,   
            char a_name){   
    atom_id = a_id;   
    atom_nick = a_nick;   
    atom_res = r;   
    atom_chain = c;   
    atom_res_id = r_id;   
    atom_x = a_x;   
    atom_y = a_y;   
    atom_z = a_z;   
    atom_w = a_w;   
    atom_bfactor = b;   
    atom_name = a_name;   
}   
 
atom::atom(string l){   
    atom_id = atoi(l.substr(6,5).c_str());   
    atom_nick = l.substr(13,3);   
    atom_res = l.substr(17,3);   
    atom_chain = l[21];   
    atom_res_id = atoi(l.substr(22,4).c_str());   
    atom_x = atof(l.substr(30,8).c_str());   
    atom_y = atof(l.substr(38,8).c_str());   
    atom_z = atof(l.substr(46,8).c_str());   
    atom_w = atof(l.substr(54,6).c_str());   
    atom_bfactor = atof(l.substr(60,6).c_str());   
    atom_name = l.size()>77 ? l[77] : ' ';   
}   
 
string atom::line(){   
    char line[255];   
    (void)sprintf(  line,   
                    "ATOM  %5u  %-3s %-3s %c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f           %c",   
                    atom_id,   
                    atom_nick.c_str(),   
                    atom_res.c_str(),   
                    atom_chain,   
                    atom_res_id,   
                    atom_x,   
                    atom_y,   
                    atom_z,   
                    atom_w,   
                    atom_bfactor,   
                    atom_name);   
    return string(line);   
}   
 
//===============================================   
class chain{   
private:   
    atoms chain_atms;   
    char chain_label;   
public:   
    chain(char);   
    void addAtom(atom);   
    void saveToFile(string);   
    aint size();   
    char label();   
    atom operator[](aint);   
};   
 
chain::chain(char l){ chain_label = l; }   
 
aint chain::size(){   
    return chain_atms.size();   
}   
 
atom chain::operator[](aint i){   
    if(i>=0 and i<chain_atms.size())   
        return chain_atms[i];   
}   
 
char chain::label(){   
    return chain_label;   
}   
 
void chain::addAtom(atom a){   
    chain_atms.push_back(a);   
    return;   
}   
 
void chain::saveToFile(string f){   
    ofstream in(f.c_str());   
    for(cint i=0; i<chain_atms.size(); i++){   
        in << chain_atms[i].line() << endl;   
    }   
    in << "TER" << endl;   
    in.close();   
    return;   
}   
 
//===============================================   
class pdb{   
private:   
    chains pdb_chns;   
 
public:   
    pdb(string);   
    cint size();   
    chain operator[](cint);   
};   
 
cint pdb::size(){   
    return pdb_chns.size();   
}   
 
chain pdb::operator[](cint i){   
    if(i>=0 and i<pdb_chns.size()) return pdb_chns[i];   
}   
 
pdb::pdb(string pdbfile){   
    string l;   
    char flag, chain_label;   
    ifstream out1(pdbfile.c_str());   
    while(getline(out1, l)){    //get the chain labels first   
        if(l.substr(0,4) == "ATOM"){   
            chain_label = l[21];   
            if(flag != chain_label){   
                chain chn(chain_label);   
                pdb_chns.push_back(chn);   
                flag = chain_label;   
            }   
        }   
    }   
    out1.close();   
    ifstream out2(pdbfile.c_str());   
    while(getline(out2, l)){   
        if(l.substr(0,4) == "ATOM"){   
            atom atm(l);   
            chain_label = l[21];   
            for(cint i=0; i<pdb_chns.size(); i++){   
                if(chain_label == pdb_chns[i].label())   
                    pdb_chns[i].addAtom(atm);   
            }   
        }   
    }   
    out2.close();   
}  
#endif