Skip to content

Commit

Permalink
Shorten words
Browse files Browse the repository at this point in the history
  • Loading branch information
@zhedahht
zhedahht committed May 24, 2014
1 parent 64c9da2 commit dc9adeb
Show file tree
Hide file tree
Showing 5 changed files with 129 additions and 84 deletions.
104 changes: 52 additions & 52 deletions MaxInSlidingWindow/MaxInSlidingWindow.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
/*
* Question Description:
* (Question 93 in <Coding Intervies>) Given an array of numbers and a sliding window size,
* (Question 93 in <Coding Intervies>) Given an array of numumbers and a sliding window size,
* how do you get the maximum numbers in all sliding windows?
*/

Expand All @@ -10,45 +10,45 @@

using namespace std;

vector<int> maxInWindows(const vector<int>& numbers, unsigned int windowSize)
vector<int> maxInWindows(const vector<int>& num, unsigned int size)
{
vector<int> maxInSlidingWindows;
if(numbers.size() >= windowSize && windowSize >= 1)
vector<int> maxInWindows;
if(num.size() >= size && size >= 1)
{
deque<int> indices;
deque<int> index;

for(unsigned int i = 0; i < windowSize; ++i)
for(unsigned int i = 0; i < size; ++i)
{
while(!indices.empty() && numbers[i] >= numbers[indices.back()])
indices.pop_back();
while(!index.empty() && num[i] >= num[index.back()])
index.pop_back();

indices.push_back(i);
index.push_back(i);
}

for(unsigned int i = windowSize; i < numbers.size(); ++i)
for(unsigned int i = size; i < num.size(); ++i)
{
maxInSlidingWindows.push_back(numbers[indices.front()]);
maxInWindows.push_back(num[index.front()]);

while(!indices.empty() && numbers[i] >= numbers[indices.back()])
indices.pop_back();
if(!indices.empty() && indices.front() <= (int)(i - windowSize))
indices.pop_front();
while(!index.empty() && num[i] >= num[index.back()])
index.pop_back();
if(!index.empty() && index.front() <= (int)(i - size))
index.pop_front();

indices.push_back(i);
index.push_back(i);
}
maxInSlidingWindows.push_back(numbers[indices.front()]);
maxInWindows.push_back(num[index.front()]);
}

return maxInSlidingWindows;
return maxInWindows;
}

// ==================== Test Code ====================
void Test(char* testName, const vector<int>& numbers, unsigned int windowSize, const vector<int>& expected)
void Test(char* testName, const vector<int>& num, unsigned int size, const vector<int>& expected)
{
if(testName != NULL)
printf("%s begins: ", testName);

vector<int> result = maxInWindows(numbers, windowSize);
vector<int> result = maxInWindows(num, size);

vector<int>::const_iterator iterResult = result.begin();
vector<int>::const_iterator iterExpected = expected.begin();
Expand All @@ -69,110 +69,110 @@ void Test(char* testName, const vector<int>& numbers, unsigned int windowSize, c

void Test1()
{
int numbers[] = {2, 3, 4, 2, 6, 2, 5, 1};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {2, 3, 4, 2, 6, 2, 5, 1};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

int expected[] = {4, 4, 6, 6, 6, 5};
vector<int> vecExpected(expected, expected + sizeof(expected) / sizeof(int));

unsigned int windowSize = 3;
unsigned int size = 3;

Test("Test1", vecNumbers, windowSize, vecExpected);
Test("Test1", vecNumbers, size, vecExpected);
}

void Test2()
{
int numbers[] = {1, 3, -1, -3, 5, 3, 6, 7};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {1, 3, -1, -3, 5, 3, 6, 7};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

int expected[] = {3, 3, 5, 5, 6, 7};
vector<int> vecExpected(expected, expected + sizeof(expected) / sizeof(int));

unsigned int windowSize = 3;
unsigned int size = 3;

Test("Test2", vecNumbers, windowSize, vecExpected);
Test("Test2", vecNumbers, size, vecExpected);
}

// increasingly sorted
void Test3()
{
int numbers[] = {1, 3, 5, 7, 9, 11, 13, 15};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {1, 3, 5, 7, 9, 11, 13, 15};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

int expected[] = {7, 9, 11, 13, 15};
vector<int> vecExpected(expected, expected + sizeof(expected) / sizeof(int));

unsigned int windowSize = 4;
unsigned int size = 4;

Test("Test3", vecNumbers, windowSize, vecExpected);
Test("Test3", vecNumbers, size, vecExpected);
}

// decreasingly sorted
void Test4()
{
int numbers[] = {16, 14, 12, 10, 8, 6, 4};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {16, 14, 12, 10, 8, 6, 4};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

int expected[] = {16, 14, 12};
vector<int> vecExpected(expected, expected + sizeof(expected) / sizeof(int));

unsigned int windowSize = 5;
unsigned int size = 5;

Test("Test4", vecNumbers, windowSize, vecExpected);
Test("Test4", vecNumbers, size, vecExpected);
}

// size of sliding windows is 1
void Test5()
{
int numbers[] = {10, 14, 12, 11};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {10, 14, 12, 11};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

int expected[] = {10, 14, 12, 11};
vector<int> vecExpected(expected, expected + sizeof(expected) / sizeof(int));

unsigned int windowSize = 1;
unsigned int size = 1;

Test("Test5", vecNumbers, windowSize, vecExpected);
Test("Test5", vecNumbers, size, vecExpected);
}

// size of sliding windows is same as the array length
void Test6()
{
int numbers[] = {10, 14, 12, 11};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {10, 14, 12, 11};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

int expected[] = {14};
vector<int> vecExpected(expected, expected + sizeof(expected) / sizeof(int));

unsigned int windowSize = 4;
unsigned int size = 4;

Test("Test6", vecNumbers, windowSize, vecExpected);
Test("Test6", vecNumbers, size, vecExpected);
}

// size of sliding windows is 0
void Test7()
{
int numbers[] = {10, 14, 12, 11};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {10, 14, 12, 11};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

vector<int> vecExpected;

unsigned int windowSize = 0;
unsigned int size = 0;

Test("Test7", vecNumbers, windowSize, vecExpected);
Test("Test7", vecNumbers, size, vecExpected);
}

// size of sliding windows is greater than the array length
void Test8()
{
int numbers[] = {10, 14, 12, 11};
vector<int> vecNumbers(numbers, numbers + sizeof(numbers) / sizeof(int));
int num[] = {10, 14, 12, 11};
vector<int> vecNumbers(num, num + sizeof(num) / sizeof(int));

vector<int> vecExpected;

unsigned int windowSize = 5;
unsigned int size = 5;

Test("Test8", vecNumbers, windowSize, vecExpected);
Test("Test8", vecNumbers, size, vecExpected);
}

int main(int argc, char* argv[])
Expand Down
15 changes: 10 additions & 5 deletions RobotMove/RobotMove.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,10 +36,14 @@ int movingCountCore(int threshold, int rows, int cols, int row, int col, bool* v
{
visited[row * cols + col] = true;

count = 1 + movingCountCore(threshold, rows, cols, row - 1, col, visited)
+ movingCountCore(threshold, rows, cols, row, col - 1, visited)
+ movingCountCore(threshold, rows, cols, row + 1, col, visited)
+ movingCountCore(threshold, rows, cols, row, col + 1, visited);
count = 1 + movingCountCore(threshold, rows, cols,
row - 1, col, visited)
+ movingCountCore(threshold, rows, cols,
row, col - 1, visited)
+ movingCountCore(threshold, rows, cols,
row + 1, col, visited)
+ movingCountCore(threshold, rows, cols,
row, col + 1, visited);
}

return count;
Expand All @@ -51,7 +55,8 @@ int movingCount(int threshold, int rows, int cols)
for(int i = 0; i < rows * cols; ++i)
visited[i] = false;

int count = movingCountCore(threshold, rows, cols, 0, 0, visited);
int count = movingCountCore(threshold, rows, cols,
0, 0, visited);

delete[] visited;

Expand Down
33 changes: 33 additions & 0 deletions SerializeBinaryTrees/SerializeBinaryTrees.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -199,13 +199,46 @@ void Test5()
Test("Test5", NULL);
}

// 5
// 5
// 5
// 5
// 5
// 5 5
// 5 5
void Test6()
{
BinaryTreeNode* pNode1 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode2 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode3 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode4 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode61 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode62 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode71 = CreateBinaryTreeNode(5);
BinaryTreeNode* pNode72 = CreateBinaryTreeNode(5);

ConnectTreeNodes(pNode1, NULL, pNode2);
ConnectTreeNodes(pNode2, NULL, pNode3);
ConnectTreeNodes(pNode3, pNode4, NULL);
ConnectTreeNodes(pNode4, pNode5, NULL);
ConnectTreeNodes(pNode5, pNode61, pNode62);
ConnectTreeNodes(pNode61, pNode71, NULL);
ConnectTreeNodes(pNode62, NULL, pNode72);

Test("Test6", pNode1);

DestroyTree(pNode1);
}

int main(int argc, char* argv[])
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();

return 0;
}
44 changes: 22 additions & 22 deletions StreamMedian/StreamMedian.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,58 +17,58 @@ template<typename T> class DynamicArray
public:
void Insert(T num)
{
if(((minHeap.size() + maxHeap.size()) & 1) == 0)
if(((min.size() + max.size()) & 1) == 0)
{
if(maxHeap.size() > 0 && num < maxHeap[0])
if(max.size() > 0 && num < max[0])
{
maxHeap.push_back(num);
push_heap(maxHeap.begin(), maxHeap.end(), less<T>());
max.push_back(num);
push_heap(max.begin(), max.end(), less<T>());

num = maxHeap[0];
num = max[0];

pop_heap(maxHeap.begin(), maxHeap.end(), less<T>());
maxHeap.pop_back();
pop_heap(max.begin(), max.end(), less<T>());
max.pop_back();
}

minHeap.push_back(num);
push_heap(minHeap.begin(), minHeap.end(), greater<T>());
min.push_back(num);
push_heap(min.begin(), min.end(), greater<T>());
}
else
{
if(minHeap.size() > 0 && minHeap[0] < num)
if(min.size() > 0 && min[0] < num)
{
minHeap.push_back(num);
push_heap(minHeap.begin(), minHeap.end(), greater<T>());
min.push_back(num);
push_heap(min.begin(), min.end(), greater<T>());

num = minHeap[0];
num = min[0];

pop_heap(minHeap.begin(), minHeap.end(), greater<T>());
minHeap.pop_back();
pop_heap(min.begin(), min.end(), greater<T>());
min.pop_back();
}

maxHeap.push_back(num);
push_heap(maxHeap.begin(), maxHeap.end(), less<T>());
max.push_back(num);
push_heap(max.begin(), max.end(), less<T>());
}
}

T GetMedian()
{
int size = minHeap.size() + maxHeap.size();
int size = min.size() + max.size();
if(size == 0)
throw exception("No numbers are available");

T median = 0;
if((size & 1) == 1)
median = minHeap[0];
median = min[0];
else
median = (minHeap[0] + maxHeap[0]) / 2;
median = (min[0] + max[0]) / 2;

return median;
}

private:
vector<T> minHeap;
vector<T> maxHeap;
vector<T> min;
vector<T> max;
};

// ==================== Test Code ====================
Expand Down
Loading

0 comments on commit dc9adeb

Please sign in to comment.