IT博客-这里的黄昏静悄悄-随笔分类-C/C++

模256的6个数转换成模900的5个数。

这里的黄昏静悄悄 — Fri, 14 Oct 2005 12:06:00 GMT

问题：如何把模256的6个数转换成模900的5个数，比如(1 2 3 4 5 6)256 = 1×256^5 + 2 ×256 ^4+3 ×256^3+4×256^2 +5 ×256 +6 ＝ 1×900^4 + 620 × 900^3 + 89 ×900^2+74×900+846 = (1 620 89 74 846)900.
问题求解：首先把256进制的数转换成1024进制的数，转换很简单（因为256进制是8位二进制，1024进制是10位二进制），然后在设法把1024进制的数转换成900进制的。
比如χ1 × 1024 ^ 4 + χ2 × 1024^3 = χ1 ×（900+124）^4 + χ2 ×（900+124）^3，展开后可得系数。最后再作个调整即可。

代码如下：（程序不完善，比如可能存在溢出）

#include <iostream>

using namespace std;
void _256_2_1024(int* _256, int* _1024)
{
    int digit = 2, n = 6, j = 4,temp = 0;
    for(int i = 5; i >= 0; i--)
    {
        if(digit == 10){ digit = 2; continue; }
        if(i > 0)
        {
            temp = _256[i - 1] << (10 - digit);
            _256[i - 1] >>= digit;
        }
        else
            temp = 0;
        _1024[j] = _256[i] | (temp &1023);
        digit += 2;
        j--;
    }
}
void _1024_2_900(int* _1024, int* _900)
{
    int temp[][5] = {{1, 4*124, 6*124*124, 4*124*124*124, 124*124*124*124},
                     {0, 1,     3*124,     3*124*124,     124*124*124},
                     {0,  0,    1,         2*124,         124*124},
                     {0,  0,    0,         1,             124},
                     {0,  0,     0,        0,              1}};
    int add = 0;
    for(int i = 5; i >= 0; i--)
    for(int j = 0; j < 5; j++)
    {
        _900[i] += (temp[j][i]*_1024[j]);
    }
    for(int k = 4; k >=0; k--)
    {
        if(_900[k] / 900 > 0) _900[k - 1] += (_900[k] /900);
        _900[k] %= 900;
    }
}
int main()
{
    int __256[6] = {1,2,3,4,5,6}, i = 0;
    int _256[] = {1,2,3,4,5,6};
    int _1024[5] = {0};
    int _900[5] = {0};
    _256_2_1024(__256, _1024);
    _1024_2_900(_1024, _900);
    cout << '(';
    for(i = 0; i < 6; i++)
        cout << '_' << _256[i];
    cout <<")256 = (";
    for(i = 0; i < 5; i++)
        cout << '_' << _1024[i];
    cout << ")1024 = (";
    for(i = 0; i < 5; i++)
        cout << '_' << _900[i];
    cout << ")900" <<endl;
    return 0;
}

这里的黄昏静悄悄 2005-10-14 20:06 发表评论

把数字转换成人民币大写形式【C/C++】

这里的黄昏静悄悄 — Fri, 14 Oct 2005 07:09:00 GMT

摘要: 把阿拉伯数字钱币转换汉字大写形式是经常要用到的，这里就用C/C++来实现之。首先我们把数字分成两部分：整数部分+小数部分；分离很简单，就是用m - (int)m就可以了。（m为金额）。因为对于人民币来说，小数只留两位即可，所以小数部分很容易实... 阅读全文

这里的黄昏静悄悄 2005-10-14 15:09 发表评论

大小写转换的方法【C/C++】

这里的黄昏静悄悄 — Mon, 10 Oct 2005 03:52:00 GMT

ASCII码表大家都很熟悉了吧，利用码的排列规律，我们可以很容易的实现一些操作，比如判断是否是数字、大小写转换等。

这里写大小写转换的函数:

char toUpper(const char& ch)
{
return ch & 0x5F;
}
char toLower(const char& ch)
{
return ch | 0x20;
}

函数原理：大小写字母的差是32，比如大写的A是65，小写的A是97，所以我们把右边数第6位置0或者1就能实现大小写转换。转换成大写时，把第6位置0，用ch & 0x5F实现。转换成小写时置1，用ch | 0x20实现。怎么样，相当的简单吧，由此，我们可以写string类的toUpper和toLower函数了。^_^，更多技巧尽在探索中。

这里的黄昏静悄悄 2005-10-10 11:52 发表评论

判断素数的几种方法思考

这里的黄昏静悄悄 — Sun, 25 Sep 2005 07:22:00 GMT

摘要: 判断素数的几种方法思考【】判断素数是经常遇到的问题，下面就总结几种方法1、最简单的从2～sqrt(N)的方法（N>=2，下同）2、筛选法3、素数判断法概念说明：素数，又叫质数，指除了1和它本身外，没有其他因数。（如果你不知道什么叫因数，建议你去从小学2年级开始学习-_-!）；合数：自然就是除了1和它本身外有其他因数。需指出一点，1既不是质数也不是合数。因此，判断N是素数的简单而笨的方法就... 阅读全文

这里的黄昏静悄悄 2005-09-25 15:22 发表评论

一道数学题

这里的黄昏静悄悄 — Tue, 13 Sep 2005 04:43:00 GMT

今天在CSDN上看到一道题目：
[ ][ ][ ][1][ ][4][ ][ ][ ]
[ ][ ][ ][ ][ ][ ][4][2][ ]
[ ][4][9][ ][7][ ][ ][ ][3]
[ ][ ][ ][ ][ ][8][9][ ][ ]
[6][3][ ][ ][ ][5][ ][ ][1]
[7][9][ ][2][ ][ ][ ][8][ ]
[ ][ ][ ][ ][ ][1][3][ ][ ]
[9][ ][3][ ][6][ ][5][ ][ ]
[8][ ][5][9][ ][ ][ ][6][ ]

以上是一个 9 * 9 的表格，请在空白处填上数字（0 - 9），使每一行、每一列都是1、2、3、4、5、6、7、8、9。
等有时间再写程序。

这里的黄昏静悄悄 2005-09-13 12:43 发表评论

控制台程序液晶法显示数字【C语言实现】

这里的黄昏静悄悄 — Sun, 28 Aug 2005 09:02:00 GMT

效果图如下，代码附后
要求，输入第一个数字n，0

  1 /*--------------------------------------------------------------------
  2  *     filename : digitdisplay.c
  3  *     Discribe : display a number
  4  *     Author   : JackRain
  5  *     Date     : 08--28--2005
  6  *     E_mail   : jack.fandlr@gmail.com
  7  *     Test with C-Free 3.5
  8  *-------------------------------------------------------------------*/
  9
10 #include <stdio.h>
11
12
13 int main()
14 {
15     static int digittab[10][2]={{5,0xF},//0
16                                 {0,0x5},//1
17                                 {7,0x6},//2
18                                 {7,0x5},//3
19                                 {2,0xD},//4
20                                 {7,0x9},//5
21                                 {7,0xB},//6
22                                 {4,0x5},//7
23                                 {7,0xF},//8
24                                 {7,0xD}};//9
25     int i,n,j=0,strline;
26     char *p,code1= ' ',code2= ' ',code3 = ' ',a1 = ' ',a2= ' ',a3= ' ',a4= ' ';
27     char cA[15];
28     printf("Please input two numbers:");
29     scanf("%d %s",&n,cA);
30     p = cA;
31     // output the first line
32     while(*(p+j) != '\0')
33     {
34         printf(" ");
35         if(digittab[*(p+j)-'0'][0]&4)
36             code1 = '-';
37         else
38             code1 = ' ';
39         for(strline = 0; strline < n; strline++)
40             printf("%c",code1);
41         printf("  ");
42         j++;
43     }
44     printf("\n");
45     // out put 2~ n+1 lines
46     for(i = 0; i < n; i++)
47     {
48         j = 0;
49     while(*(p+j)!='\0')
50      {
51          a1 = ' ';
52          a2 = ' ';
53          switch(digittab[*(p+j)-'0'][1]&0xC)
54          {
55             case 0xC:a2='|';
56             case 0x8: a1 = '|';break;
57             case 0x4: a2 = '|';break;
58          }
59          printf("%c",a1);
60          for(strline = 0; strline < n; strline++)
61             printf(" ");
62          printf("%c ",a2);
63          j++;
64      }
65      printf("\n");
66     }
67     // output the middle line
68     j = 0;
69     while(*(p+j) != '\0')
70     {
71         printf(" ");
72         if(digittab[*(p+j)-'0'][0]&2)
73             code2 = '-';
74         else
75             code2 = ' ';
76          for(strline = 0; strline < n;strline++)
77             printf("%c",code2);
78          printf("  ");
79          j++;
80
81     }
82     printf("\n");
83     // output n+4~ 2n+2 lines
84     for(i = 0; i< n;i++)
85     {
86         j=0;
87         while(*(p+j)!='\0')
88         {
89             a3 = ' ';
90             a4 = ' ';
91             switch(digittab[*(p+j)-'0'][1]&3)
92             {
93                 case 3: a3 = '|';
94                 case 1: a4= '|';break;
95                 case 2: a3= '|';break;
96             }
97             printf("%c",a3);
98             for(strline = 0; strline<n;strline++)
99              printf(" ");
100             printf("%c",a4);
101             printf(" ");
102             j++;
103         }
104         printf("\n");
105     }
106     // output the last line
107     j=0;
108     while(*(p+j) != '\0')
109     {
110         if(digittab[*(p+j)-'0'][0]&1)
111         {
112             code3='-';
113         }
114         else
115             code3 = ' ';
116         printf(" ");
117         for(strline = 0 ; strline < n; strline++)
118             printf("%c",code3);
119         printf("  ");
120         j++;
121     }
122     printf("\n");
123     return 0;
124 }

这里的黄昏静悄悄 2005-08-28 17:02 发表评论

关于把C/C++代码转换成Html的思考

这里的黄昏静悄悄 — Wed, 10 Aug 2005 03:02:00 GMT

摘要: 很多时候都要把C/C++代码发到网页中来，但是直接拷贝、粘贴后的效果并不好，许多符号因为是html的特殊字符而造成显示的混乱（最常见的就是'<'和'>'符号），所以就想把C/C++文件简单处理成html代码，当然早就有人做过了，不过觉得自己想想如何实现还是挺不错的！ ... 阅读全文

这里的黄昏静悄悄 2005-08-10 11:02 发表评论

C++中的const限定符【ZT+修改】

这里的黄昏静悄悄 — Sun, 07 Aug 2005 01:44:00 GMT

         常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。因此，定义或说明常类型时必须进行初始化，初始化的时候右值必须是编译时就能确定值的表达式。

　　一般常量和对象常量

　　1. 一般常量

　　一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。如：

　　int const x=2;

　　或

　　const int x=2;

        const int x = a; // a is a variable . Error不能把变量的值赋给const

       const int x = sizeof(int); //OK ,因为sizeof的值在编译期可以确定

　　定义或说明一个常数组可采用如下格式：

　　<类型说明符> const <数组名>[<大小>]…

　　或者

　　const <类型说明符> <数组名>[<大小>]…

　　例如：

　　int const a[5]={1, 2, 3, 4, 5};

　　2. 常对象

　　常对象是指对象常量，定义格式如下：

　　<类名> const <对象名>

　　或者

　　const <类名> <对象名>

　　定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。

　　常指针和常引用

　　1. 常指针

　　使用const修饰指针时，由于const的位置不同，而含意不同。下面举两个例子，说明它们的区别。

　　下面定义的一个指向字符串的常量指针：

　　char * const prt1 = stringprt1;

　　其中，ptr1是一个常量指针。因此，下面赋值是非法的。

　　ptr1 = stringprt2;

　　而下面的赋值是合法的：

　　*ptr1 = "m";

　　因为指针ptr1所指向的变量是可以更新的，不可更新的是常量指针ptr1所指的方向(别的字符串)，也就是指向的地址不可改变。

　　下面定义了一个指向字符串常量的指针：

　　const * ptr2 = stringprt1;

　　其中，ptr2是一个指向字符串常量的指针。ptr2所指向的字符串不能更新的，而ptr2是可以更新的。因此，

　　*ptr2 = "x";

　　是非法的，而：

　　ptr2 = stringptr2;

　　是合法的。

　　所以，在使用const修饰指针时，应该注意const的位置。定义一个指向字符串的指针常量和定义一个指向字符串常量的指针时，const修饰符的位置不同，前者const放在*和指针名之间，后者const放在类型说明符前。

　　2. 常引用

　　使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：

　　const <类型说明符> & <引用名>

　　例如：

　　const double & v;

　　在实际应用中，常指针和常引用往往用来作函数的形参，这样的参数称为常参数。

　　在C++面向对象的程序设计中，指针和引用使用得较多，其中使用const修饰的常指针和常引用用得更多。使用常参数则表明该函数不会更新某个参数所指向或所引用的对象，这样，在参数传递过程中就不需要执行拷贝初始化构造函数，这将会改善程序的运行效率。

　　下面举一例子说明常指针作函数参数的作法。

#include
const int N = 6;
void print(const int *p, int n);
using namespace std;
int main()
{
      int array[N];
      for (int i = 0; i < N; i++)
            cin>>array[i];
      print(array, N);
      return 0;
}

void print(const int *p, int n)
{
      cout<<"{"<<*p;
      for (int i=1; i < n; i++)
             cout<<","<<*(p+i);
      cout<<"}"< }

　　常成员函数

　　使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字说明的成员函数不能用来操作常对象。常成员函数说明格式如下：

　　<类型说明符> <函数名> (<参数表>) const；

其中，const是加在函数说明后面的类型修饰符，它是函数类型的一个组成部分，因此，在函数实现部分也要带const关键字。下面举一例子说明常成员函数的特征。

#include
class R
{
public:
R(int r1, int r2) { R1=r1; R2=r2; }
void print();
void print() const;
private:
int R1, R2;
};

void R::print()
{
cout<}

void R::print() const
{
cout< }

void main()
{
R a(5, 4);
a.print();
const R b(20, 52);
b.print();
}

　　该例子的输出结果为：

　　5,4
　　20;52

　　该程序的类声明了两个成员函数，其类型是不同的(其实就是重载成员函数)。有带const修饰符的成员函数处理const常量，这也体现出函数重载的特点。

　　常数据成员

　　类型修饰符const不仅可以说明成员函数，也可以说明数据成员。

　　由于const类型对象必须被初始化，并且不能更新，因此，在类中说明了const数据成员时，只能通过成员初始化列表的方式来生成构造函数对数据成员初始化。

　　下面通过一个例子讲述使用成员初始化列表来生成构造函数。

#include
using namespace std;
class A
{
public:
A(int i);
void print();
const int &r;
private:
const int a;
static const int b;
};

const int A::b=10;
A::A(int i):a(i), r(a)
{
}

void A::print()
{
cout<
}
int main()
{
       A a1(100), a2(0);
      a1.print();
      a2.print();
      return 0;
}

　　该程序的运行结果为：

　　100:10:100
　　　0:10:0

　　在该程序中，说明了如下三个常类型数据成员：

　　const int & r;

　　const int a;

　　static const int b;

　　其中，r是常int型引用，a是常int型变量，b是静态常int型变量。

　　程序中对静态数据成员b进行初始化。

　　值得注意的是构造函数的格式如下所示：

　　A(int i):a(i),r(a)
　　{
　　}

　　其中，冒号后边是一个数据成员初始化列表，它包含两个初始化项，用逗号进行了分隔，因为数据成员a和r都是常类型的，需要采用初始化格式。

这里的黄昏静悄悄 2005-08-07 09:44 发表评论

古城之谜

这里的黄昏静悄悄 — Sun, 31 Jul 2005 00:54:00 GMT

古城之谜(LostCity)
著名的考古学家石教授在云梦高原上发现了一处古代城市遗址。让教授欣喜的是在这个他称为冰峰城(Ice-Peak City)的城市中有12块巨大石碑，上面刻着用某种文字书写的资料，他称这种文字为冰峰文。然而当教授试图再次找到冰峰城时，却屡屡无功而返。
幸好当时教授把石碑上的文字都拍摄了下来，为了解开冰峰城的秘密，教授和他的助手牛博士开始研究冰峰文，发现冰峰文只有陈述句这一种句型和名词(n)、动词(v)、辅词(a)这三类单词，且其文法很简单：
<文章>        ::= <句子> { <句子> }
<句子>        ::= <陈述句>
<陈述句>    ::=    <名词短语> { <动词短语> <名词短语> } [ <动词短语> ]
<名词短语>    ::=    <名词> | [ <辅词> ] <名词短语>
<动词短语>    ::=    <动词> | [ <辅词> ] <动词短语>
<单词>        ::=    <名词> | <动词> | <辅词>
注：其中<名词>、<动词>和<辅词>由词典给出，“::=”表示定义为，“|”表示或，{}内的项可以重复任意多次或不出现，[]内的项可以出现一次或不出现。
在研究了大量资料后，他们总结了一部冰峰文词典，由于冰峰文恰好有26个字母，为了研究方便，用字母a到z表示它们。
冰峰文在句子和句子之间以及单词和单词之间没有任何分隔符，因此划分单词和句子令石教授和牛博士感到非常麻烦，于是他们想到了使用计算机来帮助解决这个问题。假设你接受了这份工作，你的第一个任务是写一个程序，将一篇冰峰文文章划分为最少的句子，在这个前提下，将文章划分为最少的单词。

[输入文件]
l    输入文件第1行为词典中的单词数n（n<=1000）。
l    输入文件第2行至第(n+1)行每行表示一个单词，形为“α.mot”， α表示词性，可能是n(名词),v（动词）,a（辅词）中的一个，mot为单词，单词的长度不超过20。拼写相同而词性不同的单词视为不同的单词，如输入示例中的n.kick与v.kick是两个不同的单词。
l    输入文件第(n+2)行为需要划分的文章，以“.”结束。
l    输入文件中的文章确保为冰峰文。文章是由有限个句子组成的，每个句子只包含有限个单词。文章长度不超过5KB。

[输出文件]
l    输出文件为两行，每行一个整数。
l    输出文件第1行为划分出来的句子数。
l    输出文件第2行为划分出来的单词数。

[输入输出文件样例]
Input.txt
11
n.table
n.baleine
a.silly
n.snoopy
n.sillysnoopy
v.is
v.isnot
n.kick
v.kick
a.big
v.cry
sillysnoopyisnotbigtablebaleinekicksnoopysillycry.
Output.txt
2
9

[样例说明]
（为了阅读方便，划分的单词用空格分隔，在单词的右上角标出它的词性，每行写一个句子，用句号表示句子结束。）
输出对应的划分：
sillysnoopyn isnotv biga tablen.
baleinen kickv snoopyn sillya cryv.

如果用下面的划分：
sillya snoopyn isnotv biga tablen.
baleinen kickv snoopyn sillya cryv.
则划分的句子数仍为2个，但单词数却多了1个，为10个，显然应该按前者而不是后者划分。

这里的黄昏静悄悄 2005-07-31 08:54 发表评论