int find_median(int A[], int B[], int p, int r, int n) { assert(A && B && p>0 && r>0 && n>0); if (p > r) return -1; int k = (p+r)/2; if (k == n) { if (A[n] <= B[1]) return k; else return find_median(A, B, p, k-1, n); } if (A[k] >= B[n-k] && A[k] <= B[n-k+1]) { return k; } if (A[k] < B[n-k]) { return find_median(A, B, k+1, r, n); } if (A[k] > B[n-k+1]) { return find_median(A, B, p, k-1, n); } }
/* 从数组A和B中找下中位数 */ int find_median(int *A, int *B, int m, int n, int s, int t) { int p, c; c = (m+n-1)/2; /* 有多少个数小于下中位数 */ p = (s+t)/2; /* 如果下中位数不在A中,就从数组B找 */ if (s > t) { return find_median(B, A, n, m, 0, n-1); } /* 数组A中有p个数小于A[p], 当且进当数组B中有c-p个数小于A[p], A[p]才是中位数 */ if (A[p] >= B[c-p-1] && A[p] <= B[c-p]) { return A[p]; } /* A[p]太小了,从数组A中找一个更大的数尝试 */ if (A[p] < B[c-p-1]) { return find_median(A, B, m, n, p+1, t); } /* A[p]太大了,从数组A中找一个更小的数尝试 */ return find_median(A, B, m, n, s, p-1); }
// 从有序数组A和B中找出中位数 // 平均时间复杂度O(lgN),最坏时间复杂度O(lgN) int median_two_array(int A[], int B[], int n) { assert(A && B && n>0); int m = find_median(A, B, 1, n, n); if (-1 != m) return m; return find_median(B, A, 1, n, n); }
int main(int argc, char *argv[]) { struct timespec start, end; int sz = 0, *data = NULL; switch (argc) { case 2: printf("Generating %d numbers\n", sz = atoi(argv[1])); clock_gettime(CLOCK_MONOTONIC, &start); data = alloc_random_data(sz); print_data("allocated", data, sz); clock_gettime(CLOCK_MONOTONIC, &end); printf("Generating took %ld usecs\n", timespec_diff_us(&start, &end)); break; default: printf("Bad input arguments!\n"); exit(-1); } printf("Computing median...\n"); clock_gettime(CLOCK_MONOTONIC, &start); int median = find_median(data, 0, sz-1, sz); clock_gettime(CLOCK_MONOTONIC, &end); free(data); printf("Median = %d\n", median); printf("Running time = %ld usecs\n", timespec_diff_us(&start, &end)); return 0; }
int main(void) { char *number,ch; int size=0,flag=0; number=(char*)malloc(sizeof(char)*1); printf("\nEnter your number\n"); while ((ch = getchar()) != '\n') { number=(char*)realloc(number,size+1); number[size]=ch; size++; } number[size]='\0'; while((number[0]=='-')||(number[0]=='0')) { if((number[0]=='-')&&(number[1]!='0')) { flag=1; number++; } else if(number[0]=='0') { number++; } } to_linked_list(number,flag); find_median(start); display(start); getch(); return 0; }
static void eval_robust_residual (double *x, /* The independent points */ double *y, /* The dependent points */ int n, /* Number of points */ double b, /* Slope */ double *aa, /* Intercept giving smallest absolute value for the above equation */ double *rr /* Corresponding value of equation */ ) { int i; double a, res, del; double d[MAX_POINTS]; for (i=0; i<n; i++) { d[i] = y[i] - b * x[i]; } a = find_median(d, n); res = 0.0; for (i=0; i<n; i++) { del = y[i] - a - b * x[i]; if (del > 0.0) { res += x[i]; } else if (del < 0.0) { res -= x[i]; } } *aa = a; *rr = res; }
int main() { head='\0'; int no_opr,val,count=0,median,output[100000],var,i; char opr; scanf("%d",&no_opr); //printf("F1"); for(i=0;i<no_opr;i++) { scanf("%c%d",&opr,&val); printf("F3"); if(opr=='r'&&head=='\0') {output[i]=0; printf("F2");} else { var=ins_sort(opr,val); if(var==0) { output[i]=0; } else { median=find_median(); output[i]=median; } } } for(i=0;i<no_opr;i++) { output[i]==0?printf("Wrong"):printf("%d",output[i]); } return 0; }
int main() { int arr1[]={1, 5, 7, 10, 13, 27}; int arr2[]={11, 15, 23, 30, 45}; int n1=6; int n2=5; cout<<find_median(arr1,arr2,0,n1-1,0,n2-1); }
int ping_ultrasonic_median(int echo, int trig, int max_distance, int iterations) { int flight_time[iterations]; int i; int start_time; for(i = 0; i < iterations; i++){ flight_time[i] = ping_ultrasonic(echo, trig, max_distance); start_time = ReadCoreTimer(); while(ReadCoreTimer() - start_time < 4000000){//i think this is 50 ms } } return find_median(flight_time, iterations); }
struct kd_node_t* make_tree(struct kd_node_t *t, int len, int i, int dim) { struct kd_node_t *n; if (!len) return 0; if ((n = find_median(t, t + len, i))) { i = (i + 1) % dim; n->left = make_tree(t, n - t, i, dim); n->right = make_tree(n + 1, t + len - (n + 1), i, dim); } return n; }
int main() { int m, n; // int A[]={1,3,5,7,8,9,10,12,24,45,65}; // int B[]={2,4,6,10,11,12,13,14,17,19,20,34,44,45,66,99}; int A[]={0, 1, 2, 3}; int B[] = {10, 11, 12, 14, 15}; m = sizeof(A)/sizeof(int); n = sizeof(B)/sizeof(int); printf("%d\n", find_median(A, B, m, n, 0, m-1)); return 0; }
int main() { int m,n; scanf("%d",&m); int *a=(int *)malloc(m*sizeof(int)); int i; for(i=0;i<m;i++) { scanf("%d",&a[i]); } scanf("%d",&n); int *b=(int *)malloc(n*sizeof(int)); for(i=0;i<n;i++) { scanf("%d",&b[i]); } float median=find_median(a,b,m,n); printf("median:%0.1lf\n",median); return 0; }
int main() { srand(time(0)); for(int n=0;n<25;n++) { x[n]=rand()%11; } sortem(); find_median(); find_mode(); histogram(); sortem(); cout<<"To see the data scroll, "<<endl; system("pause"); scroll(); return 0; }
static void median (void) /*{{{*/ { SLang_Array_Type *sx = NULL; double med = DBL_MAX; double *x; int n; if ((-1 == SLang_pop_array_of_type (&sx, SLANG_DOUBLE_TYPE)) || (sx == NULL) || (sx->num_elements < 1)) { isis_throw_exception (Isis_Error); SLang_free_array (sx); return; } x = (double *)sx->data; n = sx->num_elements; (void) find_median (x, n, &med); SLang_push_double (med); SLang_free_array (sx); }
int find_median(int arr1[],int arr2[],int start1,int end1, int start2,int end2) { int mid1=start1+(end1-start1)/2; int mid2=start2+(end2-start2)/2; int mid=min(mid1,mid2); if(start1==end1) { if(start2==end2) return (arr1[start1]+arr2[start2])/2; if((start2-end2)%2==1) { if(arr1[start1]<arr2[mid2]) return arr2[mid2]; if(arr1[start1]>arr2[mid2+1]) return arr2[mid2+1]; else return arr1[start1]; } else { int arr[]={arr1[start1],arr2[mid2-1],arr2[mid2],arr2[mid2+1]}; for(int i=0;i<4;i++) for(int j=i+1;j<4;j++) { if(arr[i]>arr[j]) { int temp=arr[j]; arr[j]=arr[i]; arr[i]=temp; } } return (arr[1]+arr[2])/2; } } if(start1==end1-1) { if(start2==end2) { if(arr1[start1]>arr2[mid2]) return arr1[start1]; if(arr1[start1+1]<arr2[mid2]) return arr1[start1+1]; else return arr2[mid2]; } if((start2-end2)%2==0) { int arr[]={arr1[start1],arr1[start1+1],arr2[mid2-1],arr2[mid2],arr2[mid2+1]}; for(int i=0;i<5;i++) for(int j=i+1;j<5;j++) { if(arr[i]>arr[j]) { int temp=arr[j]; arr[j]=arr[i]; arr[i]=temp; } } return arr[2]; } /*check else if(arr1[start1]<arr2[mid2] && (start2-end2)%2==1) return (arr2[start2]+arr1[start1])/2; also check if arr2 has only one/2 elements */ else assert(0); } int m1=arr1[mid1]; int m2=arr2[mid2]; cout<<m1<<" "<<m2; if(m1==m2) return m1; if(m1>m2) find_median(arr1,arr2,start1,end1-mid,start2+mid,end2); else if(m1<m2) find_median(arr1,arr2,start1,end1-mid,start2+mid,end2); }
std::vector<int> find_k_closest_to_median (std::vector<int>& A, const int k) { Cmp cmp{find_median(A)}; std::nth_element(A.begin(), A.begin() + k, A.end(), cmp); return {A.begin(), A.begin() + k}; }
/** * This algorithm follows the following strategy: * 1. Find the median element by density of the subset of `objects` defined * by the open-ended interval [start..end). [ O(n) ] * 2. Break up `objects` into the following subsets: [ O(n) ] * 2.1. A set `R_1`, in which all elements are less than the median. * 2.2. A set `R_2`, in which all elements are equal to the median. * 2.3. A set `R_3`, in which all elements are greater than the median. * 3. If the sum of the weights of elements in `R_3` is greater than `weight`, * recurse on `R_3`. [ T(n/2) -- throw away lower half ] * 4. Otherwise, add all elements of `R_3` completely to the knapsack. [ O(n) ] * 5. Then, add as many as possible elements of `R_2` to the knapsack. [ O(n) ] * 6. Recurse on `R_1` with `weight` updated to (`weight` - (|`R_3`| + |`R_2`|)). * [ T(n/2) -- throw away upper half ] * * In the end, it will have updated the instances of inserted objects by * assigning each its frequency. * * In the execution of this algorithm, we always traverse perform O(n) operation, * then throwing away n/2 elements in the recursive calls. Therefore: * T(n) <= T(n/2) + O(n) * From the Master Theorem, it follows that the worst-case time complexity is O(n). * * @param objects * Set of objects containing the subset to be tentatively inserted into * the knapsack. * @param length * Number of elements in `objects`. * @param weight * Free space within the knapsack. */ void kpfrac_linear (Object * objects, int length, int weight) { // Base case: We have an empty array or a full knapsack, return; if (length <= 0 || weight == 0) return; Object * R_1, * R_2, * R_3; int idx_R_1, idx_R_2, idx_R_3; R_1 = new Object[length]; R_2 = new Object[length]; R_3 = new Object[length]; idx_R_1 = idx_R_2 = idx_R_3 = 0; // Step 1. Taking advantage of `find_kth` side-effects. Object median = find_median(objects, length); // O(length) // Step 2 int R_3_weight = 0; for (int i = 0; i < length; i++) { // O(length) // Step 2.1 if (objects[i] < median) { R_1[idx_R_1++] = objects[i]; } // Step 2.2 else if (objects[i] == median) { R_2[idx_R_2++] = objects[i]; } // Step 2.3 else { R_3[idx_R_3++] = objects[i]; R_3_weight += objects[i].weight; } } // Step 3 if (R_3_weight > weight) { kpfrac_linear(R_3, idx_R_3, weight); // T(length/2) } else { // Step 4 for (int i = 0; i < idx_R_3; i++) { // O(idx_R_3) < O(length) R_3[i].frequency = 1.0; weight -= R_3[i].weight; inserted.push_back(R_3[i]); } // Step 5. // Either takes all from `R_2` completely with leftover space or exhausts // the knapsack. for (int i = 0; i < idx_R_2 && weight > 0; i++) { if (R_2[i].weight < weight) { R_2[i].frequency = 1.0; weight -= R_2[i].weight; } else { R_2[i].frequency = weight * 1.0 / R_2[i].weight; weight = 0; } inserted.push_back(R_2[i]); } // Step 6. kpfrac_linear(R_1, idx_R_1, weight); // T(length/2) } delete [] R_1; delete [] R_2; delete [] R_3; }
int main(int argc, char *argv[]) { double results[NUM_TRIALS]; #if !defined(DEBUG) #if defined(PAPI_ENABLED) int papi_setnum, num_desired, num_sets; #else double median_counts_per_sec; #endif #endif int i; printf("7-point stencil, no add, naive C code with non-periodic boundary conditions\n"); #if !defined(DEBUG) #if defined(PAPI_ENABLED) // initialize papi int desired_events[] = {PAPI_TOT_CYC, PAPI_FP_INS, PAPI_L2_DCA, PAPI_L2_DCM, PAPI_L3_DCM, PAPI_TLB_DM, PAPI_LD_INS, PAPI_SR_INS}; num_desired = 9; PAPI_event_set_wrapper_t* event_sets; papi_init(desired_events, num_desired, &event_sets, &num_sets); #else // calculate clock rate GET_CLOCK_RATE(results, NUM_TRIALS); median_counts_per_sec = find_median(results, NUM_TRIALS); #endif #endif // initialize arrays init_flush_cache_array(); malloc_grids(argv); printf("\n"); #if defined(DEBUG) init_grids(); printf("SINGLY NESTED LOOP:\n"); printf("\nGRID A BEFORE:"); print_grid(A); printf("\nGRID B BEFORE:"); print_grid(B); naive_singly_nested_loop(); printf("\nGRID A AFTER:"); print_grid(A); printf("\nGRID B AFTER:"); print_grid(B); init_grids(); printf("TRIPLY NESTED LOOPS:\n"); printf("\nGRID A BEFORE:"); print_grid(A); printf("\nGRID B BEFORE:"); print_grid(B); naive_triply_nested_loops(); printf("\nGRID A AFTER:"); print_grid(A); printf("\nGRID B AFTER:"); print_grid(B); #else #if defined(PAPI_ENABLED) printf("SINGLY NESTED LOOP:\n"); for (papi_setnum=0; papi_setnum < num_sets; papi_setnum++) { PAPI_MAKE_MEASUREMENTS(event_sets[papi_setnum].set, naive_singly_nested_loop(), NUM_TRIALS, results); print_papi_measurements(&(event_sets[papi_setnum]), results, NUM_TRIALS); } printf("\n"); printf("TRIPLY NESTED LOOPS:\n"); for (papi_setnum=0; papi_setnum < num_sets; papi_setnum++) { PAPI_MAKE_MEASUREMENTS(event_sets[papi_setnum].set, naive_triply_nested_loops(), NUM_TRIALS, results); print_papi_measurements(&(event_sets[papi_setnum]), results, NUM_TRIALS); } printf("\n"); papi_cleanup(event_sets, num_sets); #else printf("SINGLY NESTED LOOP:\n"); TIMER_MAKE_MEASUREMENTS(naive_singly_nested_loop(), results, NUM_TRIALS); print_timer_measurements(results, NUM_TRIALS, median_counts_per_sec); printf("\n"); printf("TRIPLY NESTED LOOPS:\n"); TIMER_MAKE_MEASUREMENTS(naive_triply_nested_loops(), results, NUM_TRIALS); print_timer_measurements(results, NUM_TRIALS, median_counts_per_sec); printf("\n"); printf("\n"); #endif #endif printf("\nFinal interior values: A[%lu, %lu, %lu] = %4.2e, B[%lu, %lu, %lu] = %4.2e\n", nx/2, ny/2, nz/2, A[Index3D(nx/2, ny/2, nz/2)], nx/2, ny/2, nz/2, B[Index3D(nx/2, ny/2, nz/2)]); fc_checksum(); free(A); free(B); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { pthread_t *threads; pthread_attr_t attr; uint32_t **ranks; void *status; #if defined(PAPI_ENABLED) && !defined(DEBUG) int num_sets; PAPI_event_set_wrapper_t* event_sets; #endif int rc; uint32_t t; printf("Optimized Stream benchmark (using SSE intrinsics)\n"); init_flush_cache_array(); malloc_arrays(argv); print_array_parameters(); select_code_variant(argv); print_code_variant_parameters(); threads = (pthread_t *) malloc(numThreads * sizeof(pthread_t)); ranks = (uint32_t **) malloc(numThreads * sizeof(uint32_t *)); #if !defined(DEBUG) #if defined(PAPI_ENABLED) papi_init(desired_events, num_desired, &event_sets, &num_sets); // initialize threaded PAPI if (PAPI_thread_init((unsigned long (*)(void)) (pthread_self)) != PAPI_OK) { printf("Error with PAPI_thread_init().\n"); exit(EXIT_FAILURE); } results = (double *) malloc(num_sets * numThreads * NUM_TRIALS * sizeof(double)); if (results==NULL) { printf("Error on array results malloc.\n"); exit(EXIT_FAILURE); } #else results = (double *) malloc(numThreads * NUM_TRIALS * sizeof(double)); if (results==NULL) { printf("Error on array results malloc.\n"); exit(EXIT_FAILURE); } #if defined(CYCLE_TIME) // calculate clock rate GET_CLOCK_RATE(results, NUM_TRIALS); median_counts_per_sec = find_median(results, NUM_TRIALS); //printf("Median ticks per second = %e\n", median_counts_per_sec); #else timer_init(); median_counts_per_sec = 1.0; #endif #endif #endif pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); barrier_init(&my_barrier, numThreads); #if defined(AFFINITY_ENABLED) Affinity_Init(); #endif // run stream tests for (t=0; t < numThreads; t++) { ranks[t] = (uint32_t *) malloc(sizeof(uint32_t)); *ranks[t] = t; } for (t=1; t < numThreads; t++) { #if defined(DEBUG) printf("Creating thread %u\n", t); #endif rc = pthread_create(&threads[t], &attr, pthreads_each, (void *) ranks[t]); if (rc) { printf("ERROR; return code from pthread_create() is %d\n", rc); exit(EXIT_FAILURE); } } pthreads_each((void *) ranks[0]); // join the other threads for (t=1; t < numThreads; t++) { pthread_join(threads[t], &status); } #if defined(PAPI_ENABLED) && !defined(DEBUG) papi_cleanup(event_sets, num_sets); #endif pthread_attr_destroy(&attr); pthread_exit(NULL); barrier_destroy(&my_barrier); free_arrays(); return EXIT_SUCCESS; }
uint8_t get_IR_sensor(uint8_t sensor_num) { // this routine uses ADCB channel 0, all the time int8_t meas[3]; int16_t average; int8_t scaled_median, scaled_average; //printf("\r\nget IR %i sen, CH0\r\n",sensor_num); switch(sensor_num) { case 0: ADCB.CH0.MUXCTRL &= ~0b01111000; // clear out the old value ADCB.CH0.MUXCTRL |= IR_SENSOR_0_FOR_ADCB_MUXPOS; break; case 1: ADCB.CH0.MUXCTRL &= ~0b01111000; // clear out the old value ADCB.CH0.MUXCTRL |= IR_SENSOR_1_FOR_ADCB_MUXPOS; break; case 2: ADCB.CH0.MUXCTRL &= ~0b01111000; // clear out the old value ADCB.CH0.MUXCTRL |= IR_SENSOR_2_FOR_ADCB_MUXPOS; break; case 3: ADCB.CH0.MUXCTRL &= ~0b01111000; // clear out the old value ADCB.CH0.MUXCTRL |= IR_SENSOR_3_FOR_ADCB_MUXPOS; break; case 4: ADCB.CH0.MUXCTRL &= ~0b01111000; // clear out the old value ADCB.CH0.MUXCTRL |= IR_SENSOR_4_FOR_ADCB_MUXPOS; break; case 5: ADCB.CH0.MUXCTRL &= ~0b01111000; // clear out the old value ADCB.CH0.MUXCTRL |= IR_SENSOR_5_FOR_ADCB_MUXPOS; break; default: return 0; } for (uint8_t i = 0; i < 3; i++) { ADCB.CTRLA |= ADC_CH0START_bm; while (ADCB.CH0.INTFLAGS==0){}; // wait for 'complete flag' to be set ADCB.CH0.INTFLAGS = 1; // clear the complete flag meas[i] = ADCB.CH0.RES; //printf("meas1: %i\r\n",meas1); } average = ((int16_t)meas[0] + (int16_t)meas[1] + (int16_t)meas[2]) / 3; scaled_average = (uint8_t)(average+ADC_offset[sensor_num]); scaled_median = (uint8_t)(find_median(meas)+ADC_offset[sensor_num]); //printf("measA: %i, measB: %i, measC: %i\r\n",meas[0],meas[1],meas[2]); //printf("avg: %i, scale_avg: %u, scale_med: %u\r\n",average, scaled_average, scaled_median); return scaled_median; // notes on how this works: // the usual range of outputs for the 8 bit signed ADC is -127 to 128 // right now the range of outputs we can actually get is limited by the negative input voltage to the ADC (VINN) // since we use ADCB pin0, with a constant voltage of 0.54 V, this sets the 0 of our scale (-127 to 128) // at 0.54 V, this also means the GND evaluates to about -73. This means that values below -73 are inaccessible to us, // since we will never have an ADC input that is below GND. That makes the new range -73 to 128. // when we shift this range to get only unsigned values, the new range becomes 0 to 201. // Conclusion: this measurement will always output a number between 0 and abt 200. // furthermore, experimentally, the ambient room light levels are typically around 20 (unsigned shift already applied, so 0 = GND) // and so the range of outputs that could be used for actual measurements will be limited to about 20 to 200 (only 180 significant values) // this range could be improved slightly by increasing the VINN voltage. If ADCA pin0 is used, VINN becomes 0.71 V and the range is shifted upwards. return scaled_average; }