int binarysearch(int *v, int size, int element){ int begin = 0; int end = size - 1; int middle = (begin + end)/2; int returned; if(begin > end) return -1; else if(v[middle] < element){ returned = binarysearch(v+middle+1,size-middle-1,element); if(returned == -1) return -1; else return (middle + 1 + returned); } else if(v[middle] > element){ returned = binarysearch(v,middle,element); if(returned == -1) return -1; else return returned; } else return middle; }

bool binarysearch(int value, int values[], int lower, int upper) { if (upper - lower > 1) { int mid = (int) (lower + upper) / 2; if (value <= values[mid]) { return binarysearch(value, values, lower, mid); } else { return binarysearch(value, values, mid, upper); } } else { if (value == values[lower] || value == values[upper]) { return true; } else { return false; } } }

//先二分找到pivot int binarysearch(int* nums, int target, int start, int end){ if(start > end) return -1; int mid = (start + end) / 2; if(nums[mid] == target) return mid; if(nums[mid] < target) return binarysearch(nums, target, mid+1, end); if(nums[mid] > target) return binarysearch(nums, target, start, mid-1); return -1; }

int binarysearch(int *a,int *S,int n,int k,int i,int u) { int l=(i+u)/2; int value=l*(a[i])-S[i+l]-S[i]; if(value==k) return l; if(value<k&&((l+1)*(a[i])-S[i+l+1]-S[i])>k) return l; else if(value<k) return binarysearch(a,S,n,k,l+1,u); else if(value>k) return binarysearch(a,S,n,k,i,l-1); }

int binarysearch(int a[], int low, int high, int key) //Function for binary search is defined { int mid; if(high<low) {return -1;} //Base Case mid=(high+low)/2; if(key==a[mid]) {return mid;} //if key is middle term, mid will be returned else if (key<a[mid]) {return binarysearch(a,low,mid-1,key);} else if (key>a[mid]) return binarysearch(a,mid+1,high,key); }

int binarysearch(int a[],int key,int beg,int end) { if(beg>end) return -1; int mid=(beg+end)/2; if(a[mid]==key) return mid; else if(a[mid]>key) return binarysearch(a,key,beg,mid-1); else return binarysearch(a,key,mid+1,end); }

int binarysearch(int *A, int low, int high, int key){ if(low > high){ return -1; } int mid = (low + high) / 2; if(key > A[mid]) return binarysearch(A, mid + 1, high, key); else if (key < A[mid]) return binarysearch(A, low, mid - 1, key); else return mid; }

int main() { int array[100]; for (int i = 0; (size_t) i < NELEM(array); i++) array[i] = 10*i; for (int i = 0; (size_t) i < NELEM(array); i++) { assert(binarysearch(array, NELEM(array), array[i]) == i); assert(binarysearch(array, NELEM(array), array[i]+5) == -1); } assert(binarysearch(array, NELEM(array), -5) == -1); return 0; }

int binarysearch(int list[], int search_num, int left_index, int right_index) { int middle_index; if(left_index <= right_index) { middle_index = (left_index + right_index) / 2; switch(COMPARE(list[middle_index], search_num)) { case -1: return binarysearch(list, search_num, middle_index+1, right_index); case 0: return middle_index; case 1: return binarysearch(list, search_num, left_index, middle_index-1); } } return -1; }

int main(int argv, char **argc) { int i, n, search_num; int list[MAX_SIZE]; printf("Enter the number of numbers to generate: "); scanf("%d", &n); if( n < 1 || n > MAX_SIZE) { fprintf(stderr, "Improper value of n\n"); exit(EXIT_FAILURE); } for (i=0; i < n; i++) { list[i] = rand() % 1000; printf("%d ", list[i]); } printf("\n"); //sort sort(list, n); print_list(list, n); //binary search printf("Enter the search number: "); scanf("%d", &search_num); printf("%d index is %d.\n", search_num, binarysearch(list, search_num, 0, n-1)); }

int main() { int n,count=0; scanf("%d",&n); //Enter the size of array int a[n]; int i; for(i=0;i<n;i++) { scanf("%d",&a[i]); //Enter the array elements } int key; scanf("%d",&key); //Enter the key to be searchedf for(i=0;i<n;i++) { if(key==a[i]) {count++;} } if(count<1) { int b; b=binarysearch(a,0,n-1,key); printf("%d",b); // Printing the output... } else { for(i=0;i<n;i++) { if(key==a[i]) {break;} } printf("%d",i); //Printing for another case } return 0; }

inline bool insert(int *&Gu, int v){ int maxlength=Gu[0]; int deg=Gu[1]; if(deg==0){ Gu[deg+2]=v; Gu[1]++; return true; }else{ if(deg>=maxlength-2){ Gu=(int *)realloc(Gu,sizeof(int)*(maxlength+100)); Gu[0]=maxlength+100; } int *temp=Gu+2; int cur=binarysearch(temp,deg,v); //if v is not in G[u], then insert v into G[u] //and reorder G[u] if(cur<0){ for(int i=deg+2;i>-cur+1;i--){ Gu[i]=Gu[i-1]; } Gu[-cur+1]=v; Gu[1]++; return true; }else return false; } }

int main( void ) { int a[ 6 ] = { 0, 1, 3, 5, 7, 9 }; printf("%d\n", binarysearch(a, 6, 2)); return 0; }

int* searchRange(int* nums, int numsSize, int target, int* returnSize) { int index = binarysearch(nums, target, 0, numsSize-1); int* ret = malloc(sizeof(int)*2); printf("%d\n", index); if(index == -1){ ret[0] = -1; ret[1] = -1; *returnSize = 2; return ret; } *returnSize = 2; int lo = index; int hi = index; while(nums[lo-1] == target && lo > 0){ lo--; // (*returnSize)++; } while(nums[hi+1] == target && hi < numsSize-1){ hi++; // (*returnSize)++; } ret[0] = lo; ret[1] = hi; return ret; }

int main() { int a[100001]; int S[100001]={0}; int n,k; //scanf("%d %d",&n,&k); n=readInt(); k=readInt(); for(int i=0;i<n;i++) { a[i]=readInt(); } qsort (a,n, sizeof(int), compare); int x=0; for(int i=0;i<n;i++) { S[i]=x+a[i]; x=S[i]; //printf("%d ",S[i]); } int maxCount=0; for(int i=0;i<n;i++) { int count=binarysearch(a,S,n,k,i,n-1); if(count>maxCount) count=maxCount; } writeInt(maxCount); //printf("%d\n",maxCount); return 0; }

int main(int argc, char **argv) { int member = 1; int index = binarysearch(a, member); printf("%d index = %d \n", member, index); return 0; }

int binarysearch( ListA& l, int ArraySize, int compare, int index ) { int hold,tempi = ArraySize/2; ListA newL( tempi+1 ); //if the array size is larger than one run this condition if( ArraySize > 1 ) { l.gotoBeginning(); //put the cursor on the middle of the list toNext( tempi, l, index ); l.getCursor( hold ); //if the number appears in the lower half of the list runs this condition if( compare < hold ) { tempi = ArraySize/2; //creates a new list from the bottom half of the current list l.gotoBeginning(); newList( newL, tempi, l ); //passes the new list for recursion return binarysearch( newL, tempi, compare, index-tempi ); } //if the number appears in the upperhalf of the list runs this condition else { tempi = ArraySize - ArraySize/2; //creates a new list from the top half of the current list newList( newL, tempi, l ); //passes the new list for recursion return binarysearch( newL, tempi, compare, index ); } } else //this is the end condition return index; //the function should never reach this point this is just to stop the warning return -1; }

int main() { int myVec[] = {4,5,6,7,8,9}; printf("%d\n",binarysearch(myVec,sizeof(myVec)/sizeof(int),9)); return 0; }

static int item_find(struct configsection* haystack, const char* needle) { if(haystack->items) { return binarysearch(haystack->item, needle, sizeof(struct configitem*), haystack->items-1, item_compare); } return -1; }

int main(void) { int i=0; int m=0; scanf("%d",&i); printf("%d\n",binarysearch(i)); return 0; }

int main(){ int A,B,C; scanf("%d%d%d",&A,&B,&C); printf("%.11f\n",binarysearch(0.0,1000.0,1e-11,[&](double t){ double n=A*t+B*sin(C*t*M_PI); return n<100; })); }

int main(){ int N,C,i=0; scanf("%d%d",&N,&C); for(;i<N;i++)scanf("%d",a+i); printf("%d\n",binarysearch(0,1<<30,[&](int m){ return ok(m,N,C); })); }

int search(int* nums, int numsSize, int target) { if(nums==NULL||numsSize<1){ return -1; } int begin=0; int end=numsSize-1; return binarysearch(nums,begin,end,target); }

struct configsection* config_find_section(struct config* haystack, const char* needle) { if(haystack->sections) { int i = binarysearch(haystack->section, needle, sizeof(struct configsection*), haystack->sections-1, section_compare); if(i>=0) return haystack->section[i]; } return NULL; }

// time O(n*log n). No extra space needed. Using quicksort, and binary search after int uniqueCharac3(char *ptr) { char *sorted = quicksort(ptr); while (*ptr++ != '\0') { if (binarysearch(ptr + 1, *ptr)) { printf("Letter %c repeated\n", *ptr); return TRUE; } } return FALSE; }

int search(const vector<int> &A, int B) { int pivotpoint = -1; int done = false; int start = 0; int end = A.size()-1; int sz = end+1; while(start<=end) { if(start==end) { pivotpoint = start; break; }else{ //case 1: mid is pivot int mid = start + (end-start)/2; if((mid==0 || A[mid]<A[mid-1]) && (A[mid]<A[mid+1] || mid==sz-1)) { pivotpoint = mid; break; }else if(A[mid]>A[end]) { start = mid+1; } else { end = mid-1; } } } if(pivotpoint ==0) return binarysearch(A, 0, sz-1, B); if(B>=A[0]) { return binarysearch(A, 0, pivotpoint-1, B); } return binarysearch(A, pivotpoint, sz-1, B); }

int binarysearch(const vector<int> &A, int start, int end, int val) { int sz = A.size(); if(start<=end) { if(start==end && A[start]==val) return start; else if(start==end) return -1; int mid = start + (end-start)/2; if(A[mid]==val) return mid; else if(A[mid]>val) return binarysearch(A, start, mid-1, val); return binarysearch(A, mid+1, end, val); } return -1; }

int main() { int a[] = { 2, 8,12,14,16,19,24,28,31,33,// 0-9 39,40,45,49,51,53,54,56,57,60,// 10-19 63,69,77,82,88,89,94,96,97}; // 20-28 int i,val; // for (i = 0; i < 29; i++) // printf("%i ", binarysearch(LEN, a, a[i])); printf("\n"); // printf("Found On Index: %i ", binarysearch(LEN, a, 57)); // val=binarysearch(LEN, a, 57); display_result(binarysearch(LEN, a, 57),57); // val=binarysearch(LEN, a, 1); display_result(binarysearch(LEN, a, 1),1); // printf("%i ", binarysearch(LEN, a, 17)); // printf("%i ", binarysearch(LEN, a, 42)); // printf("%i ", binarysearch(LEN, a, 99)); printf("\n"); }

int sorted(int *sarr, int l, int u, int s){ /* lets now further send the sorted array l and u down to the binary search */ int l2 = binarysearch(sarr, l, s); int u2 = binarysearch(sarr, u, s); /* if we get a return from the binary search (found) we can then compare to see where they are in the array. since the array is sorted, it makes sense to assume that if the value where l and u were found are not either the start of the array or the end, then there are elements greater and less than them */ if (l2 != 1 && u2 != s) printf("TRUE\n"); else { fprintf(stderr, "FALSE\n"); return -1; } }

int main() { ListN numbers; int tempint; char *ifile = new char[25]; //get file name from user cout << "Enter file name numbers are stored in: "; cin >> ifile; ifstream fin( ifile ); fin >> tempint; //import numbers from a file while( fin.good() ) { numbers.insertAfter( tempint ); if( fin.good() ) fin >> tempint; } //sorts the array in ascending order sortListN( numbers ); //gets the number of nodes in the array numbers.getSize( tempint ); //declare an array based list the same size as the node based list ListA sorted( tempint ); //copies the node based list to the array based list sorted.copy( numbers ); cout << endl << "Sorted " << sorted; int input; //loops taking inputs and display the function result stops when -1 is input while( input != -1 ) { cout << "Enter number to search for or -1 to exit: "; cin >> input; //returns an index value unless the list is empty if( input != -1 && !sorted.empty() ) cout << "index: " << binarysearch( sorted, tempint, input, 1 ) << endl; else if( sorted.empty() ) cout << "index: Empty List No Index Available" << endl; } return 0; }