bool search(int A[], int n, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
int pivot = findPivot(A, 0, n - 1);
return bSearch(A, 0, pivot - 1, target) || bSearch(A, pivot, n - 1, target);
}
bool bSearch(int A[], int left, int right, int target)
{
if(left < 0 || right < 0)return false;
if(left > right)return false;
int mid = (left + right) >> 1;
if(A[mid] == target)return true;
if(A[mid] < target)return bSearch(A, mid + 1, right, target);
if(A[mid] > target)return bSearch(A, left, mid - 1, target);
}
int bSearch(int A[], int start, int end, int target) {
if (start > end)
return -1;
int mid = (start + end) / 2;
if (target == A[mid])
return mid;
else if (target < A[mid])
return bSearch(A, start, mid-1, target);
else
return bSearch(A, mid+1, end, target);
}
int bSearch(int* list, int value, int lowerIndex, int upperIndex) {
if (upperIndex < lowerIndex) return -1;
int middleIndex = (lowerIndex + upperIndex) / 2;
int difference = compare(value, list[middleIndex]);
if (difference > 0) {
return bSearch(list, value, middleIndex + 1, upperIndex);
} else if (difference < 0) {
return bSearch(list, value, lowerIndex, middleIndex - 1);
} else {
return middleIndex;
}
}
int bSearch(vector<int> &nums, int l, int r, int target) {
if (l == r) {
return (nums[l] == target) ? l : -1;
}
int m = (l + r) / 2;
if (nums[m] < nums[l]) {
if ((nums[m] < target) && (target <= nums[r]))
return bSearch(nums, m+1, r, target);
else return bSearch(nums, l, m, target);
}
else {
if ((nums[l] <= target) && (target <= nums[m]))
return bSearch(nums, l, m, target);
else return bSearch(nums, m+1, r, target);
}
}
int main(){
char dayOfWeek[7][10] = {"Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int yearst[8010], yr, y, m, d, dw, n;
yearst[0] = 0;
for(yr=1; yr<8010; yr++){
yearst[yr] = yearst[yr-1] + 365 + isLeap(yr+1999);
}
scanf("%d", &n);
while(n >= 0){
dw = n%7;
y = bSearch(yearst, 8010, n);
n -= yearst[y];
y += 2000;
for(m=0; ; m++){
if(m == 1 && n < month[m]+isLeap(y))
break;
if(n < month[m])
break;
if(m == 1)
n -= month[m] + isLeap(y);
else
n -= month[m];
}
d = n+1;
printf("%d-%02d-%02d %s\n", y, m+1, d, dayOfWeek[dw]);
scanf("%d", &n);
}
return 0;
}
bool searchMatrix(vector<vector<int> > &mat, int target)
{
int n = mat.size();
if (!n) return false;
int m = mat[0].size();
if (!m) return false;
vector<int> l;
for (int i = 0; i < n; i++)
l.push_back(mat[i][m - 1]);
int id = bSearch(l, target);
if (id >= n)
return false;
int ret = bSearch(mat[id], target);
if (ret >= m)
return false;
//printf ("[id=%d][ret=%d] = %d\n", id, ret, mat[id][ret]);
return mat[id][ret] == target;
}
int main(){
int primeMap[1001], count, *primeList, N, C, idx, st, ed, mid;
count = getPrimeMap(primeMap);
primeList = (int*)calloc(count, sizeof(int));
getPrimeList(primeMap, primeList);
while(scanf("%d %d", &N, &C) != EOF){
idx = bSearch(primeList, count, N);
if((idx+1)%2 == 1){
mid = idx>>1;
st = mid-C+1>=0?mid-C+1:0;
ed = mid+C-1<=idx?mid+C-1:idx;
}
else{
vector<int> searchRange(int A[], int n, int target) {
int idx = bSearch(A, 0, n, target);
vector<int> res;
if (idx == -1) {
res.push_back(-1);
res.push_back(-1);
return res;
}
int tmp1(idx), tmp2(idx);
tmp1 = getLeft(A, 0, idx, target);
tmp2 = getRight(A, idx, n-1, target);
res.push_back(tmp1);
res.push_back(tmp2);
return res;
}
int main(int argc, char **argv)
{
int A[] = {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 ,55 ,56 ,57 ,58 ,59 ,60 ,61 ,62 ,63 ,64 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 ,73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 ,83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,91 ,92 ,93 ,94 ,95 ,96 ,97 ,98 ,99 ,100};
int i;
/*
for (i = 13; i > 0; i--)
{
if (bSearch(i, A, 13) > -1)
fprintf(stdout, "Find >>%d<<\n", i);
else
fprintf(stdout, "Doesn't find the number >>%d<<\n", i);
}
*/
bSearch(2, A, 100);
return 0;
}
int fun(int *input, int *input_count, int len) {
int dp[101][101], accu_count[101];
int i, j, k, start, last;
memset(accu_count, 0, sizeof(int) * 101);
for(i = 0; i < 101; i++) {
memset(dp[i], 0, sizeof(int) * 101);
}
accu_count[1] = input_count[1];
for(i = 2; i <= len; i++)
accu_count[i] = accu_count[i - 1] + input_count[i];
for(k = 1; k <= K; k++) {
start = last = 1;
for(i = 1; i <= len; i++) {
last = start;
start = bSearch(input, start, i, input[i] - W);
dp[i][k] = max(dp[i - 1][k], dp[start - 1][k - 1] + accu_count[i] - accu_count[start - 1]);
}
}
return dp[len][K];
}
int search(vector<int>& nums, int target) {
if (nums.empty()) return -1;
return bSearch(nums, 0, nums.size()-1, target);
}
void test_3_bsearch_should__find_doulbe_value_from_elements(){
double key=2.0;
double elements[5]={1.0,2.0,3.0,6.0,8.0};
ASSERT(2.0==*(double*)(bSearch(&key,elements,5,sizeof(double),compareDouble)));
}
int main(int argc, char *argv[]) {
clock_t startTime, endTime;
startTime = clock();
int p, my_rank;
/* initialize MPI stuff */
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD,&p);
MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
int num_threads = atoi(argv[1]); //= argv - command line arg;
int row_num, nz, col_num, i;
int *partition = (int *)malloc(sizeof(int)*(p+1));
int *local_row_array;
int entries_per_proc;// = nz/p;
int np, lower_index, ySize;
float *Y, *X;
FILE *fp;
fp = fopen("crs48x48.txt", "r");
fscanf(fp, "%d", &nz);
while (fgetc(fp) != '\n');
fscanf(fp, "%d", &row_num);
while (fgetc(fp) != '\n');
fscanf(fp, "%d", &col_num);
while (fgetc(fp) != '\n');
//%d,\n%d,\n", &nz, &row_num, &col_num);
printf("%d => NZ = %d\n",my_rank, nz);
entries_per_proc = nz/p;
X = (float *)malloc(sizeof(float)*col_num);
if (my_rank == 0) {
int *row_arr;
row_arr = (int *)malloc(sizeof(int)*row_num);
for (i=0; i<row_num; i++) {
fscanf(fp, "%d", &row_arr[i]);
//printf("rownum[%d]: %d\n", i, row_arr[i]);
while (fgetc(fp) != '\n');
}
partition[0] =0;
#pragma omp parallel for num_threads(p-1) private(lower_index, i)
for (i=1; i<p; ++i) {
lower_index = entries_per_proc * i;
partition[i] = bSearch(row_arr, row_num, lower_index);
printf("searching for np: %d got %d\n", lower_index, partition[i]);
//nz_arr[i] = row_arr[indices[i]];
}
partition[p] = row_num;
printf("Partition array:\n");
for(i=0; i<=p; i++)
{
printf("%d\n", partition[i]);
}
// printf("sending in bcat, recv\n");
//READ INPUT VECTOR X
FILE *fp2;
fp2 = fopen("Xvector.txt", "r");
for (i=0; i<col_num; i++) {
fscanf(fp2, "%f,", &X[i]);
}
fclose(fp2);
}
MPI_Bcast(partition, p+1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(X, col_num, MPI_FLOAT, 0, MPI_COMM_WORLD);
//printf("success in bcat, recv\n");
int num_rows_local;
num_rows_local = partition[my_rank+1] - partition[my_rank];
if (num_rows_local == 0) {
//can't exit!!
//should send and exit?
exit(0);
}
int *col_arr;
float *val_arr;
int local_nz;
local_row_array = (int *)malloc(sizeof(int) * num_rows_local);
// SEEK TO THE CORRECT ROW POSITION
fseek(fp, row_block_size*(partition[my_rank]) + init_block_size*3, SEEK_SET);
//printf("fp for rank %d -- %d, jumped %d\n", my_rank, ftell(fp), row_block_size*(partition[my_rank]) + init_block_size*3);
//printf("fp for rank %d -- curpos %d\n", my_rank, ftell(fp));
for (i = 0; i < num_rows_local; i++) {
fscanf(fp, "%d", &local_row_array[i]);
//printf("local row arr[%d, %d]: %d curpos %d\n", my_rank, i, local_row_array[i], ftell(fp));
//printf("fp for rank %d -- %d, \n", my_rank, ftell(fp));
while (fgetc(fp) != '\n');
}
//printf("local: %d\n", local_row_array[0]);
/*for (i=0; i<num_rows_local; i++) {
printf("local row arr[%d, %d]: %d\n", my_rank, i, local_row_array[i]);
}*/
//local_nz = (nz_recv_arr[my_rank] - nz_recv_arr[my_rank-1]);
int t2;
if (my_rank != p-1) {
fscanf(fp, "%d", &t2);
//printf("rank %d read char %d\n",my_rank,t2);
while (fgetc(fp) != '\n');
}
else {
t2 = nz;
}
local_nz = t2 - local_row_array[0];
col_arr = (int *)malloc(sizeof(int) * local_nz);
val_arr = (float *)malloc(sizeof(float) * local_nz);
// SEEK TO CORRECT COLUMN AND VALUE
fseek(fp, row_block_size*(row_num+1) + init_block_size*3 + colVal_block_size*(local_row_array[0]), SEEK_SET);
//printf("col val array\n");
for (i = 0; i < local_nz; i++) {
fscanf(fp, "%d, %f", &col_arr[i], &val_arr[i]);
while (fgetc(fp) != '\n');
//printf("rank: %d, %d, %f,\n", my_rank,col_arr[i], val_arr[i]);
}
//printf("val check %d\n", val_arr[0]);
int nz_per_thread = (local_nz) / num_threads;
int *partition_threads = (int *)malloc(sizeof(int)*(num_threads+1));
printf("\n********\nRank: %d, local nz: %d\n*******\n", my_rank, local_nz);
partition_threads[0] = 0;
#pragma omp parallel for num_threads(num_threads)
for (i=1; i<num_threads; i++) {
lower_index = local_row_array[0] + i*nz_per_thread;
//printf("Thread searching for: %d\n", lower_index);
partition_threads[i] = bSearch(local_row_array, num_rows_local, lower_index);
//printf("part threads[%d] from proc:%d = %d\n", i, my_rank, partition_threads[i]);
}
partition_threads[num_threads] = num_rows_local;
#pragma omp single
{
printf("Partiton for rank %d \n",my_rank);
for (i=0; i<=num_threads; i++) {
printf("Thread[%d] = %d\n", i, partition_threads[i] + partition[my_rank]);
}
}
/*
Array partition_threads holds partition of indices over local_row_array
*/
//Allocate output array and initialise to zero => use calloc()
if(my_rank == 0){
ySize = row_num;
}
else {
ySize = num_rows_local;
}
Y = (float*)calloc(ySize, sizeof(float));
//printf("Rank %d, Calloc done\n", my_rank);
#pragma omp parallel num_threads(num_threads)
{
int id = omp_get_thread_num();
int local_start = partition_threads[id];
int local_end = partition_threads[id+1]-1;
int thread_nz;
if(local_start < local_end)
{
int local_index = local_start;
int col_num, val, cnt, n;
//printf("Rank %d, Thread %d, \n", my_rank, id);
while(local_index <= local_end)
{
if(id == num_threads-1 && local_index == local_end){
thread_nz = local_nz - local_row_array[local_index] + local_row_array[0];
}
else{
thread_nz = local_row_array[local_index+1] - local_row_array[local_index];
}
//*******************************ZIG - ZAG - ZOOM *******************************
if((local_index - local_start) % 2 == 0)
{
//ZIG
cnt = 0;
while( cnt < thread_nz)
{
//non-zeroes for this thread start from number of nonzeroes processed by all other threads uptil now.
n = local_row_array[local_index] - local_row_array[0]+cnt;
//printf("\n***CHECK %d\n", col_arr[n]);
//X[col_arr[n]] += 2;
Y[local_index] += val_arr[n] * X[col_arr[n]];
cnt++;
}
}
else
{
//ZAG
cnt = thread_nz-1;
while(cnt >= 0)
{
//non-zeroes for this thread start from number of nonzeroes processed by all other threads uptil now.
n = local_row_array[local_index] - local_row_array[0]+cnt;
//Y[local_index] += 2;
Y[local_index] += val_arr[n] * X[col_arr[n]];
cnt--;
}
}
local_index++;
}
/*#pragma omp critical
{
printf("\n\n*******");
printf("Rank %d, Thread %d, Thread nz = %d\n", my_rank, id, thread_nz);
for(i=0; i<local_end- local_start + 1; i++)
{
printf("Y[%d] = %f\n", i, Y[i]);
}
printf("*******\n\n");
}
*/
}
}
MPI_Barrier(MPI_COMM_WORLD);
int base = partition[my_rank];
/*printf("\n**********\nRank %d\n", my_rank);
for(i=0; i<num_rows_local; i++)
{
printf("Y[%d+%d] = %f\n", base,i, Y[i]);
}
*/
//Concatenate output vector Y from all processes.
if(my_rank!=0)
{
//All processes send
MPI_Send(Y, num_rows_local, MPI_FLOAT, 0, 0, MPI_COMM_WORLD);
//exit(0);
}
else{
//Receive from all others
int base, num_rows_to_receive;
for(i=1; i < p; i++){
base = partition[i];
num_rows_to_receive = partition[i+1] - partition[i];
if(num_rows_to_receive>0){
MPI_Recv(&Y[base], num_rows_to_receive, MPI_FLOAT, i, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
}
}
if(my_rank == 0)
{
for(i=0; i<row_num; i++)
{
printf("Y[%d] = %f\n", i, Y[i]);
}
}
fclose(fp);
endTime = clock();
printf("\nNP = %d, Time taken: %ld\n",p,endTime-startTime);
MPI_Finalize();
return 0;
}
void test_bsearch_should_find_value_from_elements(){
int key=6;int result;
int elements[5]={1,2,3,6,8};
ASSERT(6==*(int *)(bSearch(&key,elements,5,sizeof(int),compareInt)));
}
void test_2_bsearch_should_not_find_value_from_elements(){
int key=14;int result;
int elements[5]={1,2,3,6,8};
ASSERT(NULL==(bSearch(&key,elements,5,sizeof(int),compareInt)));
}
void test_6_bsearch_should_find_string_value_from_elements(){
string key="prateek",result;
string elements[5]={"ansu","manish","prateek","tikash","vikash"};
ASSERT(0==strcmp("prateek",*(string*)(bSearch(&key,elements,5,sizeof(string),compareString))));
};
void test_5_bsearch_should_not_find_char_value_from_elements(){
char key='a';
char elements[5]={'b','c','a','d','e'};
ASSERT('a'==*(char*)(bSearch(&key,elements,5,sizeof(char),compareChar)));
}
int binarySearch(int* list, int size, int value){
compareCounter = 0;
return bSearch(list,value,0,size);
}
void test_4_bsearch_should_not_find_doulbe_value_from_elements(){
double key=2.5;
double elements[5]={1.0,2.0,3.0,6.0,8.0};
ASSERT(NULL==(bSearch(&key,elements,5,sizeof(double),compareDouble)));
}
