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