Beauty of Programming on Coinidea's Blog

[JavaScript] Finding Prime Numbers Up to N

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>

This uses the Sieve of Eratosthenes, which has good performance. Tested and working in Chrome. Hope it helps!

This was my answer on Baidu Zhidao (a Q&A platform).

[Beauty of Programming 2.9] Fibonacci Sequence

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;
}

The book mentions a method: fi = fi-1 + fi-2 => converted into matrix form

[Beauty of Programming 2.9] Fibonacci Sequence
Time complexity: O(log2n).

[Beauty of Programming 2.8] Finding Integers That Meet the Criteria

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

The problem is simple: given an integer n, find the smallest m such that n*m contains only the digits 0 and 1 in its decimal representation.

Method 1: Brute Force [Need to consider large integers, termination conditions, and time complexity]

 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;
}

Method 2: BFS [Need to consider large integers, termination conditions, and duplicate elimination]

 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++;
 }
}

[Beauty of Programming 2.7] The Greatest Common Divisor Problem

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

GCD: Greatest Common Divisor – the largest integer that divides both m and n evenly.
Euclid’s algorithm (the Euclidean algorithm) has existed since ancient times:
GCD(x, y) = GCD(x, x%y)
x = k*y + b. If d is the GCD of x and y, then d must also divide b, and d is the GCD of x and b, where b = x%y.
Code:

1
2
3
4
5


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

The book “Beauty of Programming” discusses time optimizations:

The modulo operation involves division, which is relatively expensive.
How to optimize for big integers.

[Beauty of Programming 2.6] Exact Representation of Floating Point Numbers

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

The code below simplifies the problem to converting a repeating decimal into a fraction. For terminating decimals, you can convert them directly to fractions, but this involves another important concept: finding the greatest common divisor (GCD). The classic method is the Euclidean algorithm.
Code:

 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: repeating decimal
// n: integer representation of the repeating block
// m: length of the repeating block
// 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;
}

[Beauty of Programming 2.5] Finding the K Largest Numbers

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

This problem is equivalent to finding the k-th largest/smallest number.
Method 1: Sort and output directly. [The book “Beauty of Programming” notes that different sorting methods have different time complexities. Indeed, since we don’t need all n numbers sorted – we only need the k largest.]
Using quicksort:

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;
}

Method 2: We don’t actually need all numbers sorted. We can simulate the partition step of quicksort to find the element at the k-th position after sorting.

 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);
 }
}

Method 3: Heap sort [maintain a min-heap of size k. The STL code is remarkably short, though you could implement the heap with arrays yourself.]

PS: All sorting uses STL implementations. Implementing sorting from scratch will be attempted in the near future.

 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;
}

[Beauty of Programming 2.4] Count of Digit 1

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

The problem is straightforward: given a positive integer n, count the total number of times the digit 1 appears in all numbers from 1 to n.
For example, for the number 12312, global count += 2 because 1 appears twice. Given input n, we need to compute this for all numbers from 1 to 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;
}

The code includes a verification function whose correctness is beyond doubt. The problem also provides a recursive approach, which has acceptable time complexity – it should be proportional to the number of digits.
PS: I’m clearly not great at math; this was quite a struggle. But my logic still works well…

[Beauty of Programming 2.3] Finding the Forum "Spammer"

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;
}

This problem can be further optimized in two ways: 1) Optimize the solution itself; 2) If there are 3 “spammers,” each posting more than a quarter of all posts, how do we solve it? It’s late today, heading back to the dorm. I’ll solve it tomorrow – though I already have an idea.
Problem 1:
The book “Beauty of Programming” mentions that space complexity can be optimized to O(1).
After reading the book, here’s the hint:
Use one variable id to store the current ID and count to store the count of that ID, then compare for equality and maintain dynamically. The final id must be the spammer.

 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;
}

Problem 2: This can be generalized from the approach in Problem 1, Solution 2: [my own idea, not rigorously tested, but the logic should be correct]

 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;
}

[Beauty of Programming 2.2] Don't Be Scared by Factorials

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

The problem asks to count the number of trailing zeros in n!. This is essentially counting how many multiples of 5 are multiplied in during the computation of n!.

 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;
}

The problem asks for the position of the lowest bit 1 in the binary representation of N!. We can observe that multiplying by odd numbers doesn’t affect the position of 1. Each time we multiply by 2, the entire value shifts left by 1 bit. Therefore, the result depends on the number of times 2 appears as a factor.

 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;
}

[Beauty of Programming 2.1] Count the Number of 1s in Binary

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;
}

[Beauty of Programming 1] Drawing Curves with CPU Usage

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

Getting the CPU to run at full load is actually quite simple – just write an infinite loop and the OS will allocate more and more time slices to it. However, modern processors are multi-core. For example, my computer has 4 cores, so you’ll find the CPU stays around 25-27% and never reaches 100%.

To reach 100%, you just need to use multithreading.

The most provocative statement I saw today was:

“I dare you to make the CPU draw a circle.” I was completely stunned at that moment…

Now let’s look at the 50% case. The book “Beauty of Programming” says that alternating between “sleep for one time slice, work for one time slice” should achieve 50%. But I found the results were not great. Even using GetTickCount, the effect was poor because the computer has other programs running as well.

 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;
}