笔试题练习（九）

1,有一个数组a[1000]存放0--1000;要求每隔二个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。

#include  < iostream >
using   namespace  std;

struct  Node
{
     int  value;
     bool  isDeleted;
};
int  main()
{
    Node a[ 1001 ];
     int  i,n  =   12 ;
     for  (i  =   0 ; i  <  n;  ++ i)
    {
        a[i].value  =  i;
        a[i].isDeleted  =   false ;
        
    }
     int  cur  =   0 ,count,num  =  n;
     while  (num  !=   1 )
    {
        count  =   0 ;
         while  (count  !=   2 )
        {
            cur  =  (cur + 1 ) % n;
             if  (a[cur].isDeleted  ==   false )
            {
                count ++ ;
            }
        }
        a[cur].isDeleted  =   true ;
         while  (a[cur].isDeleted  !=   false )
        {
            cur  =  (cur + 1 ) % n;
        }
         -- num;
    }
    cout  <<  cur  <<  endl;
     return   0 ;
}

2,有一个整数数组，现要求实现这个整数数组的循环右移。如：1，2，3，4，5 则循环右移两位后结果是：4，5，1，2，3。

#include  < iostream >
using   namespace  std;

void  shiftRight( int  a[],  int  n, int  m)
{ // 循环右移m位
     int  pre  =   0 ,cur  =  (pre + m) % n,curNum  =  a[pre],tmp,count  =   0 ;
     if  (n % 2   ==   0 )
    { // 偶数
         // 移动偶数位
         while  (count  !=  n / 2 )
        {
            tmp  =  a[cur];
            a[cur]  =  curNum;
            curNum  =  tmp;
            pre  =  cur;
            cur  =  (cur + m) % n;
             ++ count;
        }
         // 移动奇数位
        count  =   0 ;
        pre  =   ++ pre;
        cur  =  (pre + m) % n;
        curNum  =  a[pre];
        
         while  (count  !=  n / 2 )
        {
            tmp  =  a[cur];
            a[cur]  =  curNum;
            curNum  =  tmp;
            pre  =  cur;
            cur  =  (cur + m) % n;
             ++ count;
        }
    }
     else
    { // 奇数
         while  (count  !=  n)
        {
            tmp  =  a[cur];
            a[cur]  =  curNum;
            curNum  =  tmp;
            pre  =  cur;
            cur  =  (cur + m) % n;
             ++ count;
        }
    }
}
int  main()
{
     int  a[]  =  { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 };
    shiftRight(a, 8 , 2 );
     return   0 ;
}

 3, 以单词为最小单位翻转字符串

#include  < iostream >
#include  < stack >
#include  < string >
using   namespace  std;

string  reverse_string_word_by_word( string  input)
{
    stack < string >  s;
     char  chSplit  =   '   ' ;
    size_t pos  =  input.find_first_of(chSplit);
    size_t lastPos  =  input.find_last_of(chSplit);
    size_t nBegin  =   0 ;
    size_t len  =   0 ;
     string  tmpStr;
    size_t nWhiteSpace  =   0 ;
     while  ( true )
    {
         ++ nWhiteSpace;
         if (pos  ==  input.npos)
        {
            len  =  input.length()  -  nBegin;
            tmpStr  =  input.substr(nBegin,len);
            s.push(tmpStr);
             break ;
        }
        len  =  pos - nBegin;
        tmpStr  =  input.substr(nBegin,len);
        s.push(tmpStr);
        nBegin  =  pos + 1 ;
        pos  =  input.find(chSplit,nBegin);
    }
     string  result  =   "" ;
     while  ( ! s.empty())
    {
         string  tmp  =  s.top();
        result.append(tmp.c_str());
         if  ( -- nWhiteSpace)
        {
            result.append( "   " );
        }
        s.pop();
    }
     return  result;
}
int  main()
{
     string  strData  =   " the house is blue " ;
     string  result  =  reverse_string_word_by_word(strData);
    cout  <<  result  <<  endl;
     return   0 ;
}

4，题目描述：

设有n个正整数，将它们联接成一排，组成一个最大的多位整数。

例如：

 

n=2时，2个整数32，321连接成的最大整数为：32321，

n=4时，4个整数55，31，312, 33 联接成的最小整数为：553332131312

#include  < iostream >
#include  < vector >
#include  < algorithm >
using   namespace  std;

class  MyCompator
{
public :
     bool   operator ()( char *  lhsStr, char *  rhsStr)
    {
         if  (lhsStr  ==  NULL) 
             return   false ; 
         if  (rhsStr  ==  NULL) 
             return   true ;
         const   char *  temps1  =  lhsStr;
         const   char *  temps2  =  rhsStr;
         while ( ! (( * temps1  ==   0 )  &&  ( * temps2  ==   0 )))
        {
             //  字符串相加的效果
             if ( * temps1  ==   0 )
            {
                temps1  =  rhsStr;
            }
             if ( * temps2  ==   0 )
            {
                temps2  =  lhsStr;
            }
             //  比较
             if ( * temps1  !=   * temps2)
            {
                 return   * temps1  >   * temps2;
            }
             else
            {
                temps1 ++ ;
                temps2 ++ ;
            }
        }
         //  两个相等
         return   true ;
    }
};
int  main() 
{ 
     char *  ps[]  =  {  " 55 " , " 31 " , " 312 " , " 33 " , " 321 " }; 
    vector < char *>  v(ps,ps + sizeof (ps) / sizeof ( * ps)); 
    sort(v.begin(), v.end(), MyCompator());  
    copy(v.begin(), v.end(), ostream_iterator < char *> (cout,  "" )); 
    cout  <<  endl; 
     return   0 ;
}

5、编程题

输入：N（整数）

输入：数据文件A.txt，不超过6条记录，字符串长度不超过15个字节

文件格式如下：

字符串"t数字"n

 

说明：

每行为1条记录；字符串中不含有"t。

数字描述的是该字符串的出现概率，小于等于100的整数。

多条记录的出现概率之和为100，如果A.txt不满足该条件，程序则退出；

如果文件格式错误，程序也退出。

 

要求：

编写一个程序，输入为N（正整数），读入文件A.txt，按照字符串出现概率随机地输出字符串，输出N条记录

 

例如：

输入文件A.txt

abc"t20

a"t30

de"t50

输入为：10

 

即 abc有20%的概率输出，a有30%的概率输出，de有50%的概率输出，输出10条记录

以下为一次输出的结果,多次输出的结果可能不相同。

abc

a

de

de

abc

de

a

de

a

de

import  java.io.BufferedReader;
import  java.io.FileInputStream;
import  java.io.InputStreamReader;
import  java.util.Random;
import  java.util.Scanner;
import  java.util.Vector;

// 记录类
class  Record
{
     private  String name  =   null ;
     private   int  num  =   0 ;
     public  Record(String name,  int  num)
    {
         this .name  =  name;
         this .num  =  num;
    }
     public  String getName() 
    {
         return  name;
    }
     public   void  setName(String name) 
    {
         this .name  =  name;
    }
     public   int  getNum() 
    {
         return  num;
    }
     public   void  setNum( int  num)
    {
         this .num  =  num;
    }
}
public   class  test 
{

     public   static   void  main(String[] args)  throws  Exception
    {
         int  N,i;
        Scanner scanner  =   new  java.util.Scanner(System.in);
        N  =  scanner.nextInt();
        FileInputStream input  =   null ;
        InputStreamReader bufferInput  =   null ;
        BufferedReader reader  =   null ;
        Vector < Record >  records  =   new  java.util.Vector < Record > ();
         try
        {
            input  =   new  FileInputStream( " D://data1.txt " );
            bufferInput  =   new  InputStreamReader(input);
            reader  =   new  BufferedReader(bufferInput);
            String line  =   "" ;
            String strError  =   " //t " ;
            String strSpliter  =   " /t " ; // 分隔符
             int  total  =   0 ;
             while  ((line  =  reader.readLine())  !=   null )
            {
                 if  (line.indexOf(strError)  !=   - 1 )
                { // 含有/t
                    System.exit( 1 );
                }
                String[] record  =  line.split(strSpliter);
                 if  (record.length  !=   2 )
                { // 记录格式错误
                    System.exit( 1 );
                }
                String name  =   "" ;
                 int  num  =   0 ;
                 try
                {
                    name  =  record[ 0 ];
                    num  =  Integer.parseInt(record[ 1 ]);
                     if  (num  >   100 )
                    { // 单个记录超过100
                        System.exit( 1 );
                    }
                    total  +=  num;
                }
                 catch (java.lang.Exception ex)
                { // 解析错误
                    System.exit( 1 );
                }
                Record node  =   new  Record(name,num * N / 100 );
                records.add(node);
            }
             if  (total  !=   100 )
            { // 概率和不为100
                System.exit( 1 );
            }
             int  size  =  records.size();
             int  pos  =   - 1 ,count  =   0 ;
                
             for  (i  =   0 ; count  !=  N;  ++ i)
            {
                Random random  =   new  java.util.Random();
                 // 在记录集合中随机取一条记录来检验
                pos  =  random.nextInt(size);
                Record temp  =  records.elementAt(pos);
                 if  (temp.getNum()  !=   0 )
                { // 若此记录可以被输出(次数还没减到0)
                     // 输出记录并将其次数减去1
                    System.out.println(temp.getName());
                    count ++ ;
                    temp.setNum(temp.getNum() - 1 );
                }
            
            }
            
        }
         catch (java.lang.Exception ex)
        {
            System.exit( 1 );
        }
         finally
        { // 关闭文件
            input.close();
            bufferInput.close();
            reader.close();
        }
    }

}