编程之美 on Coinidea的博客

[JavaScript]求n以内只能被自身和1整除的数（素数或质数）

Sun, 26 Jul 2015 02:01:42 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


<script type="text/javascript">
var arr = new Array();
var flag = new Array(1001);
for (var i = 1; i <= 1000; i++) {
 flag[i] = 0;
}
for (var i = 2; i <= 1000; i++) {
 if (flag[i] == 0) {
 flag[i] = 1;
 arr.push(i);
 for (var j = 1; j * i <= 1000; j++) {
 flag[j*i] = 1;
 }
 }
}
var ans = "2";
for (var i = 1; i < arr.length; i++) {
 ans = ans + "," + arr[i].toString();
}
alert(ans);
</script>

用的筛法，性能挺高的，Chrome下测试通过，希望能帮助您。

这是我在百度知道上的回答。

[编程之美_2.9]斐波那契数列

Sat, 23 May 2015 05:20:58 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


int Fibonacci(int n)
{
 if (1 == n)
 {
 return 1;
 }
 if (2 == n)
 {
 return 2;
 }
 return Fibonacci(n-1) + Fibonacci(n-2);
}

int FibonacciIteration (int n)
{
 int a = 1;
 int b = 2;
 if (n == 1)
 return a;
 if (n == 2)
 return b;
 for (int i = 3; i <= n; i++)
 {
 int now = a + b;
 a = b;
 b = now;
 }
 return b;
}

书中提到了一种方法： fi = fi-1 + fi-2 =>转换成矩阵的形式

[编程之美_2.9]斐波那契数列
时间复杂度为：O(log2n)。

[编程之美_2.8]找符合条件的整数

Sat, 23 May 2015 05:19:47 +0000

题意很简单，给定一个n, 求一个最小的m，使得n_m中的10进制表示只有0,1
方法1：Brute Force [大整数的情况需要考虑，何时终止，时间复杂度如何？]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


bool CheckNumber(int number)
{
 while(number)
 {
 if (number%10 != 0 && number%10 != 1)
 return false;
 number /= 10;
 }
 return true;
}

int CalcMBruteForce(int n)
{
 int m = 1;
 while (!CheckNumber(m * n))
 {
 m++;
 }
 return m;
}

方法2：BFS [大整数的情况需要考虑，何时终止，去重复计算问题]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


int CalcM(int number)
{
 int i = 1;
 vector<int> vList;
 vList.clear();
 vList.push_back(0);
 vList.push_back(1);
 vector<int> vListC;
 int k = 1;
 // TODO:
 // BigInt
 // Delete duplicate
 while (true)
 {
 vListC.clear();
 for (vector<int>::size_type i = 0; i < vList.size(); i++)
 {
 if (vList[i] && vList[i] % number == 0)
 {
 return vList[i];
 }
 vListC.push_back(vList[i] + 0);
 vListC.push_back(vList[i] + (int)pow(10.0, k));
 }
 vList.clear();
 vList = vListC;
 k++;
 }
}

[编程之美_2.7]最大公约数的问题

Sat, 23 May 2015 05:18:46 +0000

GCD: 最大公约数，能被m,n整数整除的最大的整数。
貌似很早的就有了欧几里得的辗转相除法法
GCD(x, y) = GCD(x, x%y)
x = k*y + ｂ若d是x, y的最大公约数，那么d一定能被b整除，且d是x和b的最大公约数，b为x%y
代码如下：

1
2
3
4
5


// GCD
int GCD(int x, int y)
{
 return y == 0 ? x : GCD(y, x % y);
}

在《编程之美》书中有对时间上的优化：

取模运算含有除法，比较耗时
大整数下该如何优化

[编程之美_2.6]精确表达浮点数

Sat, 23 May 2015 05:17:49 +0000

以下代码将问题简化为求无限循环小数的分数，至于有限的直接改成分数即可，不过涉及到另一个重要知识，就是求最大公约数，比较经典的是辗转相除法。
代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// GCD
int GCD(int x, int y)
{
 return y == 0 ? x : GCD(y, x % y);
}

// Simplified conditions
// x: 无限循环小数
// n: 循环节的整数表示
// m: 循环节长度
// 10^m * x = n + x
// x = n / (10^m - 1)
void FloatNumber(string number)
{
 int start = number.find_first_of('(') + 1;
 int end = number.find_first_of(')');
 string repetend = number.substr(start, end - start);
 int n = atoi(repetend.c_str());
 int m = end - start;
 int d = GCD(n, ((int)pow(10.0, m) - 1));
 cout << n / d << '/' << ((int)pow(10.0, m) - 1) / d << endl;
}

[编程之美_2-5]寻找最大的k个数

Sat, 23 May 2015 05:16:43 +0000

这个问题与寻找第k大/小数等价。
方法1: 直接排序输出[编程之美书上说：不同的排序方法时间复杂度不一样，诚然，因为不需要n个数有序，只需要最大的k个数即可]
选用快速排序：

1
2
3
4
5
6


vector<int> FindMostKSort(vector<int>& vNumbers, int k)
{
 sort(vNumbers.begin(),vNumbers.end());
 vector<int> vKNumbers(vNumbers.rbegin(), vNumbers.rbegin() + k);
 return vKNumbers;
}

方法2: 实际上并不需要全部数有序，其实可以模拟快速排序的划分过程，求某个数排序之后在第k个位置即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


void swap(int &a, int &b)
{
 int tmp = a;
 a = b;
 b = tmp;
}
void FindMostKPartition(vector<int>& vNumber, int k, int left, int right)
{
 int index = left;
 int tmp = vNumber[index];
 int i = left;
 int j = right;
 while (i < j)
 {
 while(i < j && vNumber[j] >= vNumber[index]) j--;
 swap(vNumber[j], vNumber[index]);
 index = j;
 while(i < j && vNumber[i] <= vNumber[index]) i++;
 swap(vNumber[i], vNumber[index]);
 index = i;
 }
 if (index - left + 1 == k)
 {
 cout << vNumber[index] << endl;
 }
 else if (index - left + 1 < k)
 {
 FindMostKPartition(vNumber, k - (index - left + 1), index + 1, right);
 }
 else
 {
 FindMostKPartition(vNumber, k, left, index - 1);
 }
}

方法3: 堆排序[维护一个k数量的最小堆即可，STL代码如此短啊，不过可以自己用数组实现堆]

PS: 排序均用STL实现，具体的排序自己实现，将在近期尝试编写。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


void FindMostKHeap(vector<int>& vNumbers, int k)
{
 vector<int> vKNumbers(vNumbers.begin(), vNumbers.begin() + k);
 make_heap(vKNumbers.begin(), vKNumbers.end(), greater<int>());
 for (vector<int>::size_type i = k; i < vNumbers.size(); i++)
 {
 if (vNumbers[i] > vKNumbers[0])
 {
 vKNumbers[0] = vNumbers[i];
 make_heap(vKNumbers.begin(), vKNumbers.end(), greater<int>());
 }
 }
 cout << vKNumbers[0] << endl;
}

[编程之美_2.4]1的数目

Sat, 23 May 2015 05:15:31 +0000

题意很简单，给定一个正整数n，求1-n中，1出现在各个数中的位数的次数之和。
比如针对特定的数12312，global count += 2;因为出现了两个1，输入n，要统计1-n的情况。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


int VerifyCountOneNumberAns(int n)
{
 int ans = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while(tmp)
 {
 if (1 == tmp%10) ans++;
 tmp /= 10;
 }
 }
 return ans;
}
int CountOneNumber(int n)
{
 if (n == 0)
 return 0;
 if (n < 10)
 return 1;
 vector<int> vNumber;
 vNumber.clear();
 int tmp = n;
 while(tmp)
 {
 vNumber.push_back(tmp%10);
 tmp /= 10;
 }
 int count = 0;
 int vSize = vNumber.size();
 count = (vSize - 1) * vNumber[vSize - 1] * (int)pow(10.0, (int)(vSize - 2));
 if (vNumber[vSize - 1] > 1)
 {
 count += (int)pow(10.0, (int)(vSize - 1));
 }
 else
 {
 count += n - vNumber[vSize - 1] * (int)pow(10.0, vSize - 1) + 1;
 }
 count += CountOneNumber(n - vNumber[vSize - 1] * (int)pow(10.0, vSize - 1));
 return count;
}
int main()
{
 vector<int> ids;
 for (int i = 1; i <= 10000; i++)
 {
 int count = CountOneNumber(i);
 int ans = VerifyCountOneNumberAns(i);
 if (ans != count)
 cout << i << '\t' << ans << '\t' << count << endl;
 }
 return 0;
}

代码中有验证程序，验证程序的正确性是不用怀疑的，然后题目给出了一种递归的方法，时间上还可以接受，应该和数的位数成正比。
PS：自己果然不擅长数学，做起来挺吃力的。不过逻辑还挺好使的。。

[编程之美_2.3]寻找发帖“水王”

Sat, 23 May 2015 05:14:27 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


int FindMostIds(vector<int> &ids)
{
 map<int,int> hashIds;
 map<int,int>::iterator it;
 hashIds.clear();
 for (int i = 0; i < ids.size(); i++)
 {
 it = hashIds.find(ids[i]);
 if (hashIds.end() == it)
 {
 hashIds.insert(map<int,int>::value_type(ids[i],1));
 }
 else
 {
 it->second++;
 }
 }
 int id = 0, count = -1;
 for (it = hashIds.begin(); it != hashIds.end(); it++)
 {
 if (it->second > count)
 {
 id = it->first;
 count = it->second;
 }
 }
 return id;
}

这个题1：可以继续优化；2：如果是出现3个发帖水王，每个人超过四分之一的帖子，该题如何解？今天晚了，先回宿舍，明日再解，其实我已经想到方法了。
问题1：
编程之美的书上说，可以在空间复杂度上优化到O(1)
看书之后得到提示：
用一个id来存当前id
count来存id的计数，然后比较是否相等，动态维护，最终的id一定是水王。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


int FindMostIds(vector<int> &ids)
{
 if (ids.size() <= 0)
 return -1;
 int id = ids[0];
 int count = 1;
 for (vector<int>::size_type i = 1; i < ids.size(); i++)
 {
 if (0 == count)
 {
 id = ids[i];
 count = 1;
 continue;
 }
 if (id == ids[i])
 {
 count++;
 }
 else
 {
 count--;
 }
 }
 return id;
}

问题2：可以用问题1解法2的推广：[自己想的，没有经过严格测试，目测思想正确]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


void FindMostIds(vector<int> &ids)
{
 if (ids.size() <= 0)
 return ;
 int id[3] = {-1, -1, -1};
 int count[3] = {0, 0, 0};
 for (vector<int>::size_type i = 1; i < ids.size(); i++)
 {
 bool flag = false;
 for (int j = 0; j < 3; j++)
 {
 if (id[j] == ids[i])
 {
 count[j]++;
 flag = true;
 break;
 }
 }
 if (flag) continue;

 flag = false;
 for (int j = 0; j < 3; j++)
 {
 if (count[j] == 0)
 {
 id[j] = ids[i];
 count[j]++;
 flag = true;
 break;
 }
 }
 if (flag) continue;
 for (int j = 0; j < 3; j++)
 {
 count[j]--;
 }
 }
 for (int i = 0; i < 3; i++)
 {
 cout << id[i] << '\t';
 }
 cout << endl;
}

[编程之美_2.2]不要被阶乘吓到

Sat, 23 May 2015 05:11:00 +0000

题意要求计算n!的value值后面有0的个数，实际上可以理解为n!的计算中有多少个5的倍数被乘入。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


int CountZero(int n)
{
 int cnt = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while (0 == i % 5)
 {
 cnt++;
 tmp /= 5;
 }
 }
 return cnt;
}

题意求N!中二进制表示最低位1的位置，可以发现奇数的乘入对1的位置没有影响。一旦乘以2，整个数值为左移1位，故最后结果和分解因数后2的个数有关

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


int CountBinaryOne(int n)
{
 int cnt = 0;
 for (int i = 1; i <= n; i++)
 {
 int tmp = i;
 while (0 == tmp % 2)
 {
 cnt++;
 tmp /= 2;
 }
 }
 return cnt;
}

[编程之美_2.1]求二进制中1的个数

Sat, 23 May 2015 05:09:14 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int CountOne(int val)
{
 int cnt = 0;
 while (val)
 {
 val &= val - 1;
 cnt++;
 }
 return cnt;
}

[编程之美_1]CPU绘制曲线

Sat, 23 May 2015 05:06:15 +0000

其实这个题满跑很简单，那就是写个死循环就行了。操作系统分给的时间片就会越来越多。但是现在的程序都是多核的，比如我的电脑是4核的，会发现，CPU大概永远在25~27%左右，并没有达到100%。

如果想达到百分之百，只需要使用多线程，就可以了。

今天看到最挑衅的一句话是：

有种你让CPU画个圆，当时整个人都不好了。。。

下面来看50%的情况，编程之美上说，“sleep一个时间片，work一个时间片”不停切换应该就可以到50%。后来我发现效果不好。就算使用GetTickCount，效果也不好，因为毕竟电脑还有别的程序要运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


void Work(DWORD time)
{
 DWORD now = GetTickCount();
 for(;GetTickCount() <<- endstream>> now + time;)
 {
 }
}
DWORD WINAPI DrawThread(LPVOID lParam)
{
 double deta = 0.1f;
 while (true)
 {
 double time = 500 + 500 * sin(deta);
 Work(time);
 Sleep(1000-time);
 deta += 0.1f;
 }
 return 0;
}
int main()
{
 HANDLE hThread[4];
 DWORD idThread[4];
 hThread[0] = CreateThread(0,0,DrawThread,NULL,0,& idThread[0]);
 hThread[1] = CreateThread(0,0,DrawThread,NULL,0,& idThread[1]);
 hThread[2] = CreateThread(0,0,DrawThread,NULL,0,& idThread[2]);
 hThread[3] = CreateThread(0,0,DrawThread,NULL,0,& idThread[3]);
 SetThreadAffinityMask(hThread[0], 0x00000001);
 SetThreadAffinityMask(hThread[1], 0x00000010);
 SetThreadAffinityMask(hThread[2], 0x00000100);
 SetThreadAffinityMask(hThread[3], 0x00001000);

 WaitForSingleObject(hThread[0], INFINITE);
 WaitForSingleObject(hThread[1], INFINITE);
 WaitForSingleObject(hThread[2], INFINITE);
 WaitForSingleObject(hThread[3], INFINITE);

 return 0;
}