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