国产V综合V亚洲欧美久久,久久精品成人欧美大片,尹人香蕉久久99天天拍

Self Numbers

mahudu@cppblog — Fri, 16 Jun 2006 15:32:00 GMT

In 1949 the Indian mathematician D.R. Kaprekar discovered a class

of numbers called self-numbers. For any positive integer n, define

d(n) to be n plus the sum of the digits of n. (The d stands

for digitadition, a term coined by Kaprekar.) For example, d(75) = 75 + 7 + 5 = 87. Given any positive integer n as a starting

point, you can construct the infinite increasing sequence of integers

n, d(n), d(d(n)), d(d(d(n))), .... For example, if you start with

33, the next number is 33 + 3 + 3 = 39, the next is 39 + 3 + 9 = 51, the next

is 51 + 5 + 1 = 57, and so you generate the sequence

33, 39, 51, 57, 69, 84, 96, 111, 114, 120, 123, 129, 141, ...

The number n is called a generator of d(n). In the

sequence above, 33 is a generator of 39, 39 is a generator of 51, 51

is a generator of 57, and so on. Some numbers have more than one

generator: for example, 101 has two generators, 91 and 100. A number

with no generators is a self-number. There are thirteen

self-numbers less than 100: 1, 3, 5, 7, 9, 20, 31, 42, 53, 64, 75, 86,

and 97.

Write a program to output all positive self-numbers less than 10000

in increasing order, one per line.

Output
1
3
5
7
9
20
31
42
53
64
 |
 |       <-- a lot more numbers
 |
9903
9914
9925
9927
9938
9949
9960
9971
9982
9993

Solution

#include <iostream>
using namespace std;

const long N = 10000;     //最大自然数
char Arr[N + 9*4]={0};   //是否是被排除的数字？ +9*4是�ؓ了要再多�?位数

long DealNum(long n)
{
  long sum = n;
  while (n != 0)
  {
    sum += n%10;
    n /= 10;
  }
  return sum;
}

int main()
{
  int i;
  for(i = 1; i < N; i++)
  {
    Arr[DealNum(i)] = 1;
  }
  for(i = 1; i < N; i++)
  {
    if (!Arr[i])
        cout<<i<<endl;
  }
  return 0;
}

mahudu@cppblog 2006-06-16 23:32 发表评论

Booklet Printing

mahudu@cppblog — Fri, 16 Jun 2006 15:26:00 GMT

When printing out a document, normally the first page is printed first, then the second, then the third, and so on until the end. However, when creating a fold-over booklet, the order of printing must be altered. A fold-over booklet has four pages per sheet, with two on the front and two on the back. When you stack all the sheets in order, then fold the booklet in half, the pages appear in the correct order as in a regular book.

For example, a 4-page booklet would print on 1 sheet of paper: the front will contain page 4 then page 1, and the back will contain page 2 then page 3.

                       Front              Back
                       -------------      -------------
                       |     |     |      |     |     |
                       |  4  |  1  |      |  2  |  3  |
                       |     |     |      |     |     |
                       -------------      -------------

Your task is to write a program that takes as input the number of pages to be printed, then generates the printing order.

Input

The input file contains one or more test cases, followed by a line containing the number 0 that indicates the end of the file.

Each test case consists of a positive integer n on a line by itself, where n is the number of pages to be printed; n will not exceed 100.

Output

For each test case, output a report indicating which pages should be printed on each sheet, exactly as shown in the example. If the desired number of pages does not completely fill up a sheet, then print the word Blank in place of a number. If the front or back of a sheet is entirely blank, do not generate output for that side of the sheet.

Output must be in ascending order by sheet, front first, then back.

Sample Input

Sample Output

Printing order for 1 pages:
Sheet 1, front: Blank, 1
Printing order for 14 pages:
Sheet 1, front: Blank, 1
Sheet 1, back : 2, Blank
Sheet 2, front: 14, 3
Sheet 2, back : 4, 13
Sheet 3, front: 12, 5
Sheet 3, back : 6, 11
Sheet 4, front: 10, 7
Sheet 4, back : 8, 9
Printing order for 4 pages:
Sheet 1, front: 4, 1
Sheet 1, back : 2, 3

Solution

#include <iostream>
using namespace std;
#define PAGES 100

typedef struct side{    
    int left,right;
}side;

typedef struct sheet{
    side front;
    side back;    
}sheet;

int numSides;
sheet sheets[PAGES];

void PrintPages(int numSides){
    int numSidesNew;    
    int add,pages;
    add = numSides%4;
    if(add != 0){
        numSidesNew = numSides + 4 - add;    // 增加后的总面�?numSides为实际的总面�?/span>
    }
    else
        numSidesNew = numSides;
    pages = numSidesNew / 4;    // �ȝ��张数
    for(int i = 0; i < pages; i++){
        sheets[i].front.left = numSidesNew - 2*i;
        if(sheets[i].front.left > numSides){
            sheets[i].front.left = 0;    // 表明应�ؓblank
        }
        sheets[i].front.right = 2*i+1;
        if(sheets[i].front.right > numSides){
            sheets[i].front.right = 0;    // 表明应�ؓblank
        }
        sheets[i].back.left = 2*(i+1);
        if(sheets[i].back.left > numSides){
            sheets[i].back.left = 0;    // 表明应�ؓblank
        }
        sheets[i].back.right = numSidesNew - 2*i - 1;
        if(sheets[i].back.right > numSides){
            sheets[i].back.right = 0;
        }
    }

    cout << "Printing order for " << numSides << " pages:" << endl;
    for(int j = 0; j < pages; j++){
        if(sheets[j].front.left || sheets[j].front.right){
            cout << "Sheet " << j+1 <<", front: ";
            if(sheets[j].front.left)
                cout << sheets[j].front.left << ",";
            else
                cout << "Blank,";
            cout << " ";
            if(sheets[j].front.right)
                cout << sheets[j].front.right;
            else
                cout << "Blank,";
            cout << endl;
        }
        if(sheets[j].back.left || sheets[j].back.right){
            cout << "Sheet " << j+1 <<", back : ";
            if(sheets[j].back.left)
                cout << sheets[j].back.left << ",";
            else
                cout << "Blank,";
            cout << " ";
            if(sheets[j].back.right)
                cout << sheets[j].back.right;
            else
                cout << "Blank";
            cout << endl;
        }

    }
}


int main()
{
    int numSides;
    while(cin >> numSides){
        if(numSides == 0){
            break;
        }
        PrintPages(numSides);
    }
    return 0;
}

mahudu@cppblog 2006-06-16 23:26 发表评论

mahudu@cppblog — Fri, 16 Jun 2006 15:12:00 GMT

http://bbs.gameres.com/showthread.asp?threadid=46513

				
日前在书上看��C���D���用多��式��D��计算�q�x��根的代码�Q�至今都没搞明白作者是怎样�?br />���出那个公式的。但在尝试解决问题的�q�程中，学到了不���东西，于是便有了这���心
得，写出来和大家�׃�n。其中有错漏的地方，�q�请大家多多指教�?br />
的确�Q�正如许多�h所说的那样�Q�现在有有FPU�Q�有3DNow�Q�有SIMD�Q�讨����Y件算法好像不
合时宜。关于sqrt的话题其实早�?003�q�便已在 GameDev.net上得��C���q�泛的讨论（�?br />见我实在非常火星了，当然不排除还有其他尚在冥王星的�h�Q�嘿嘿）。而尝试探�I�该�?br />题则完全是出于本人的兴趣和好奇心�Q�换句话说就是无知）�?br />
我只是个beginner�Q�所以这�U�大是大非的问题我也说不清楚�Q�在GameDev.net上也有很�?br />�c�M��的争论）。但无论如何�Q�Carmack在DOOM3中还是��用了软�g���法�Q�而多知道一�Ҏ��
学知识对3D�~�程来说也只有好处没坏处�?D囑�Ş�~�程其实���是数学�Q�数学，�q�是数学�?br />
文章原本是用HTML�~�排的，所以只截取了部分有比较有趣的东西放在这里。原文在我的
个�h主页上，同时也提供了2���论文的下蝲�Q�http:
//greatsorcerer.go2.icpcn.com/info/fastsqrt.html

=========================================================

�?D囑�Ş�~�程中，�l�常要求�q�x���Ҏ���q�x��根的倒数�Q�例如：求向量的长度或将向量归一
化。C数学函数库中的sqrt��h��理想的精度，但对�?D游戏�E�式来说速度太慢。我们希�?br />能够在保证��够的�_�ֺ�的同�Ӟ���q�一步提高速度�?br />
Carmack在QUAKE3中��用了下面的算法，它第一�ơ在公众场合出现的时候，几乎震住了所
有的人。据说该���法其实�q�不是Carmack发明的，它真正的作者是Nvidia的Gary Tarolli
�Q�未�l�证实）�?br />�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />//
// 计算参数x的��^�Ҏ��的倒数
//
float InvSqrt (float x)
{
float xhalf = 0.5f*x;
int i = *(int*)&x;
i = 0x5f3759df - (i >> 1); // 计算�W�一个近似根
x = *(float*)&i;
x = x*(1.5f - xhalf*x*x); // 牛顿�q�代�?br />return x;
}
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
该算法的本质其实���是牛顿�q�代法（Newton-Raphson Method�Q�简�U�NR�Q�，而NR的基����?br />是泰勒��敎ͼ�Taylor Series�Q�。NR是一�U�求方程的近似根的方法。首先要估计一个与�?br />�E�的�Ҏ��较靠�q�的数��|��然后�Ҏ��公式推算下一个更加近似的数��|��不断重复直到可以
获得满意的精度。其公式如下�Q?br />�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />函数�Q�y=f(x)
其一阶导��Cؓ�Q�y'=f'(x)
则方�E�：f(x)=0 的第n+1个近似根�?br />x[n+1] = x[n] - f(x[n]) / f'(x[n])
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />NR最关键的地方在于估计第一个近似根。如果该�q�似根与真根���_��靠近的话�Q�那么只需
要少数几�ơ�P代，���可以得到满意的解�?br />
现在回过头来看看如何利用牛顿法来解决我们的问题。求�q�x��根的倒数�Q�实际就是求�?br />�E?/(x^2)-a=0的解。将该方�E�按牛顿�q�代法的公式展开为：
x[n+1]=1/2*x[n]*(3-a*x[n]*x[n])
��?/2攑ֈ�括号里面�Q�就得到了上面那个函数的倒数�W�二行�?br />
接着�Q�我们要设法估计�W�一个近似根。这也是上面的函数最���奇的地斏V��它通过某种�?br />法算��Z��一个与真根非常接近的近似根�Q�因此它只需要��用一�ơ�P代过�E�就获得了较�?br />意的解。它是怎样做到的呢�Q�所有的奥妙���在于这一行：
i = 0x5f3759df - (i >> 1); // 计算�W�一个近似根

�����莫名其妙的语句，不是吗？但仔�l�想一下的话，�q�是可以理解的。我们知道，IEEE
标准下，float�c�d��的数据在32位系�l�上是这栯����C�的�Q�大体来说就是这��P��但省略了�?br />多细节，有兴���可以GOOGLE�Q�：
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />bits�Q?1 30 ... 0
31�Q�符号位
30-23�Q�共8位，保存指数�Q�E�Q?br />22-0�Q�共23位，保存���数�Q�M�Q?br />�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />所以，32位的���点数用十进制实数表�C�就是：M*2^E。开根然后倒数���是�Q�M^(-1/2)*2^
(-E/2)。现在就十分清晰了。语句i> >1其工作就是将指数除以2�Q�实�?^(E/2)的部分�?br />而前面用一个常数减��d���Q�目的就是得到M^(1/2)同时反�{所有指数的�W�号�?br />
至于那个0x5f3759df�Q�呃�Q�我只能��_��的确是一个超�U�的Magic Number�?br />
那个Magic Number是可以推导出来的�Q�但我�ƈ不打���在�q�里讨论�Q�因为实在太�J�琐了�?br />���单来��_��其原理如下：因�ؓIEEE的��Q�Ҏ��中，���数M省略了最前面�?�Q�所以实际的��?br />数是1+M。如果你在大学上数学课没有打瞌睡的话�Q�那么当你看�?1+M)^(-1/2)�q�样的�Ş
式时�Q�应该会马上联想的到它的泰勒�U�数展开�Q�而该展开式的�W�一��就是常数。下面给
出简单的推导�q�程�Q?br />�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />对于实数R>0�Q�假讑օ�在IEEE的��Q点表�C�Z���Q?br />指数为E�Q�尾��CؓM�Q�则�Q?br />
R^(-1/2)
= (1+M)^(-1/2) * 2^(-E/2)

��?1+M)^(-1/2)按泰勒��数展开�Q�取�W�一��，得：

原式
= (1-M/2) * 2^(-E/2)
= 2^(-E/2) - (M/2) * 2^(-E/2)

如果不考虑指数的符��L��话，
(M/2)*2^(E/2)正是(R>>1)�Q?br />而在IEEE表示中，指数的符号只需���单地加上一个偏�U�d��可，
而式子的前半部分刚好是个常数�Q�所以原式可以�{化�ؓ�Q?br />
原式 = C - (M/2)*2^(E/2) = C - (R>>1)�Q�其中C为常�?br />
所以只需要解方程�Q?br />R^(-1/2)
= (1+M)^(-1/2) * 2^(-E/2)
= C - (R>>1)
求出令到相对误差最���的C值就可以�?br />�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />上面的推��D���E�只是我个�h的理解，�q�未得到证实。而Chris Lomont则在他的论文中详
�l�讨��Z��最后那个方�E�的解法�Q��ƈ���试在实际的机器上寻找最佳的常数C。有兴趣的朋�?br />可以在文末找��C��的论文的链接�?br />
所以，所谓的Magic Number�Q��ƈ不是从N元宇宙的某个星系�׃��时空扭曲而掉到地球上
的，而是几百�q�前���有的数学理论。只要熟悉NR和泰勒��敎ͼ�你我同样有能力作出类�?br />的优化�?br />
在GameDev.net 上有人做�q�测试，该函数的相对误差�U��ؓ0.177585%�Q�速度比C标准库的
sqrt提高���过20%。如果增加一�ơ�P代过�E�，相对误差可以降低到e- 004 的��敎ͼ�但�?br />度也会降到和sqrt差不多。据说在DOOM3中，Carmack通过查找表进一步优化了该算法，
�_�ֺ��q�乎完美�Q�而且速度也比原版提高了一截（正在努力弄源码，谁有发我一份）�?br />
值得注意的是�Q�在Chris Lomont的演���中�Q�理��Z��最优秀的常敎ͼ��_�ֺ�最高）�?br />0x5f37642f�Q��ƈ且在实际���试中，如果只��用一�ơ�P代的话，其效果也是最好的。但�?br />怪的是，�l�过两次NR后，在该常数下解的精度将降低得非常厉宻I��天知道是怎么�?br />事！�Q�。经�q�实际的���试�Q�Chris Lomont认�ؓ�Q�最优秀的常数是0x5f375a86。如果换�?br />64位的double版本的话�Q�算法还是一��L���Q�而最优常数则为�?x5fe6ec85e7de30da�Q�又一
个��o人冒汗的Magic Number - -b�Q��?br />
�q�个���法依赖于��Q�Ҏ��的内部表�C�和字节��序�Q�所以是不具�U�L��性的。如果放到Mac上跑
��׃��挂掉。如果想具备可移植性，�q�是乖乖用sqrt好了。但���法思想是通用的。大家可
以尝试推���一下相应的�q�x��根算法�?br />
下面�l�出Carmack在QUAKE3中��用的�q�x��根算法。Carmack已经���QUAKE3的所有源代码�?br />�l�开源了�Q�所以大家可以放心��用，不用担心会受到律师信�?br />�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />//
// Carmack在QUAKE3中��用的计算�q�x��根的函数
//
float CarmSqrt(float x){
union{
int intPart;
float floatPart;
} convertor;
union{
int intPart;
float floatPart;
} convertor2;
convertor.floatPart = x;
convertor2.floatPart = x;
convertor.intPart = 0x1FBCF800 + (convertor.intPart >> 1);
convertor2.intPart = 0x5f3759df - (convertor2.intPart >> 1);
return 0.5f*(convertor.floatPart + (x * convertor2.floatPart));
}

mahudu@cppblog 2006-06-16 23:12 发表评论

The Blocks Problem

mahudu@cppblog — Fri, 09 Jun 2006 17:16:00 GMT

摘要: Background Many areas of Computer Science use simple, abstract domains for both analytical and empirical studies. For example, an early AI study of planning and robotics (STRIPS) used a block worl... 阅读全文

mahudu@cppblog 2006-06-10 01:16 发表评论

Fibonacci Freeze

mahudu@cppblog — Fri, 09 Jun 2006 17:10:00 GMT

The Fibonacci numbers (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...) are defined by the recurrence:

Write a program to calculate the Fibonacci Numbers.

Input and Output

The input to your program would be a sequence of numbers smaller or equal than 5000, each on a separate line, specifying which Fibonacci number to calculate.

Your program should output the Fibonacci number for each input value, one per line.

Sample Input

5
7
11

Sample Output

The Fibonacci number for 5 is 5
The Fibonacci number for 7 is 13
The Fibonacci number for 11 is 89

Solution

#include

using namespace std;

int main()

{

int first,next,temp,n;

while(cin >> n) {

first = 0;

next = 1;

temp = 0;

if(n == 0 || n == 1) {

cout << "The Fibonacci number for" << " " << n << " " << "is" << " " << n << endl;

}

else {

for(inti = 2; i <= n; i++) {

temp = first + next;

first = next;

next = temp;

}

cout << "The Fibonacci number for" << " " << n << " " << "is" << " " << temp << endl;

}

return 0;

}

mahudu@cppblog 2006-06-10 01:10 发表评论

The 3n + 1 problem

mahudu@cppblog — Fri, 09 Jun 2006 16:41:00 GMT

Background

Problems in Computer Science are often classified as belonging to a certain class of problems (e.g., NP, Unsolvable, Recursive). In this problem you will be analyzing a property of an algorithm whose classification is not known for all possible inputs.

The Problem

Consider the following algorithm:

1.	input n

2. 	print n

3. 	if n = 1 then STOP

4. 	if n is odd then  tex2html_wrap_inline44

5. 	else  tex2html_wrap_inline46

6. 	GOTO 2

Given the input 22, the following sequence of numbers will be printed 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

It is conjectured that the algorithm above will terminate (when a 1 is printed) for any integral input value. Despite the simplicity of the algorithm, it is unknown whether this conjecture is true. It has been verified, however, for all integers n such that 0 < n < 1,000,000 (and, in fact, for many more numbers than this.)

Given an input n, it is possible to determine the number of numbers printed (including the 1). For a given n this is called the cycle-length of n. In the example above, the cycle length of 22 is 16.

For any two numbers i and j you are to determine the maximum cycle length over all numbers between i and j.

The Input

The input will consist of a series of pairs of integers i and j, one pair of integers per line. All integers will be less than 1,000,000 and greater than 0.

You should process all pairs of integers and for each pair determine the maximum cycle length over all integers between and including i and j.

You can assume that no opperation overflows a 32-bit integer.

The Output

For each pair of input integers i and j you should output i, j, and the maximum cycle length for integers between and including i and j. These three numbers should be separated by at least one space with all three numbers on one line and with one line of output for each line of input. The integers i and j must appear in the output in the same order in which they appeared in the input and should be followed by the maximum cycle length (on the same line).

Sample Input

Sample Output

1 10 20
100 200 125
201 210 89
900 1000 174

Solution

#include

using namespace std;

int cycle(intm)

{

int i = 1;

while (m != 1){

if(m%2)

m = m*3 + 1;

else

m /= 2;

i++;

}

return i;

}

int main()

{

int m,n,max,temp;

int mOriginal,nOriginal;

int i;

while (cin >> m >> n){

mOriginal = m;

nOriginal = n;

if (m > n){

temp = m;

m = n;

n = temp;

}

max = cycle(m);

for (i = m+1; i <= n; i++){

temp = cycle(i);

if (temp > max){

max = temp;

}

cout << mOriginal << " " << nOriginal << " " << max << endl;

}

return 0;

}

mahudu@cppblog 2006-06-10 00:41 发表评论