void mysort(long long int a[], int l, int r)
{
if (l>=r)
return;
long long int mid, x;
int i, j;
mid = a[l+(r-l)/2];
i = l; j = r;
while (i <= j)
{
while (i<=j && a[i] < mid)
i++;
while (i<=j && mid < a[j])
j--;
if (i<=j)
{
x = a[i];
a[i] = a[j];
a[j] = x;
i++;
j--;
}
}
mysort(a, l, j);
mysort(a, i, r);
}
void mysort(vector<pair<int,pair<int,int>>> &n,int start,int end){
int len=end-start;
if (len>1) {
int i=len>1,j=len-i;
mysort(n, start, start+i);
mysort(n, start+i, end);
int posi=start,posj=start+i;
vector<pair<int,pair<int,int>>> temp;
while (!(i==0&&j==0)) {
if (j==0||(i>0&&n[posi].first>=n[posj].first)) {
if (j!=0&&n[posi].first==n[posj].first&&n[posi].second.second>n[posj].second.second) {
temp.push_back(n[posj++]);
j--;
}else{
temp.push_back(n[posi++]);
i--;
}
}else{
temp.push_back(n[posj++]);
j--;
}
}
for (int it=0; it<temp.size(); it++) {
n[start+it]=temp[it];
}
}
}
void mysort(int a[], int l, int r) // 注意自己写的快排的错误方式
{
if (l>=r)
return;
int mid, x, i, j;
mid = a[l+(r-l)/2];
i = l; j = r;
while ( i <= j) // 天煞的，快排写错了
{
while (i<=j && a[i] < mid)
i++;
while (i<=j && mid < a[j])
j--;
if (i <= j)
{
x = a[i];
a[i] = a[j];
a[j] = x;
i++;
j--;
}
}
mysort(a, l, j);
mysort(a, i, r);
}
void mysort(charptr lines[], size_t p, size_t r){
if(p<r){
size_t q = partition(lines, p, r);
mysort(lines, p, q-1);
mysort(lines, q+1, r);
}
return;
}
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> myvec;
if(nums.size() <3) return myvec;
if(nums.size() == 3){
if(nums[0] + nums[1] + nums[2] == 0){
myvec.push_back(mysort(nums));
return myvec;
}
}
vector<int> arr = mysort(nums);
bool zero_flag = false;
for(int i = 0; i< arr.size() - 2; i++){
//if(arr[i] == arr[i+1] && arr[i] !=0 ) continue;
if(i == 0 || arr[i] > arr[i-1]){
if(zero_flag && arr[i] == 0) continue;
int start = i + 1;
int end = arr.size() - 1;
int neg = arr[i] * -1;
while (start < end){
if( arr[start] + arr[end] == neg){
vector<int> mycase;
if(arr[i] == 0 && !zero_flag){
zero_flag = true;
}
mycase.push_back(arr[i]);
mycase.push_back(arr[start]);
start ++;
mycase.push_back(arr[end]);
end -- ;
myvec.push_back(mycase);
mycase.clear();
while(start < end && arr[end] == arr[end + 1] ) end --;
while(start < end && arr[start] == arr[start - 1] ) start ++;
//end if main
}else if(arr[start] + arr[end] > neg){
end --;
}else{
start ++;
}
if(zero_flag) break;
}//end while
}//end if
}//end for i
if(myvec.size()>=2){
for( int i = 0; i < myvec.size()-1; i++){
if(myvec[i][0] == myvec[i+1][0] && myvec[i][1] == myvec[i+1][1] && myvec[i][2] == myvec[i+1][2]){
myvec.erase(myvec.begin() + i );
}
}
}
return myvec;
}
/*polygon sorting function
sorts an array polys of n polygon pointers by either pixel number ('p'),
id number ('i') or weight ('w').
*/
void poly_sort(int npoly, polygon *poly[],char key){
if(key=='p'){
mysort(poly, npoly, sizeof(polygon *),poly_cmp_pixel);
}
else if(key=='i'){
mysort(poly, npoly, sizeof(polygon *),poly_cmp_id);
}
else if(key=='w'){
mysort(poly, npoly, sizeof(polygon *),poly_cmp_weight);
}
else{
fprintf(stderr,"sort key %c not recognized. Array can't be sorted\n", key);
}
}
void mysort(int v[], int left, int right) {
if (left >= right) return;
swap(v, left, (left+right)/2);
int i, last = left;
for (i = left+1; i <= right; ++i){
if (v[i] < v[left]) {
swap(v, i, ++last);
}
}
swap(v, left, last);
mysort(v, left, last-1);
mysort(v, last+1, right);
}
void
testWithStudents1()
{
int i;
int nelements = sizeof(students)/sizeof(Student);
printf("----- Students ----\n");
printf("Before\n");
for ( i = 0; i < nelements; i++ ) {
printf("%d:%-20s %2d\n", i, students[i].name, students[i].grade );
}
printf("----- Students Sorted by Grade ----\n");
mysort( nelements, sizeof(Student), students, 1, compareStudentByGrade );
for ( i = 0; i < nelements; i++ ) {
printf("%d:%-20s %2d\n", i, students[i].name, students[i].grade );
}
// Test that students are ordered by grade
for ( i = 0; i < nelements -1 ; i++ ) {
assert( students[i].grade <= students[i+1].grade );
}
printf( "testWithStudents1 OK\n");
}
int threeSumClosest(vector<int>& nums, int target) {
vector<int> myarr = mysort(nums);
int temp = INT_MAX;
int sum = 0;
for(int i = 0; i < myarr.size() - 2; i ++){
int start = i + 1, end = myarr.size() - 1;
int neg = target - myarr[i];
while(start < end){
int dif = myarr[start] + myarr[end] - neg;
if(absVal(dif) < temp) {
sum = myarr[i] + myarr[start] + myarr[end];
temp = absVal(dif);
}
if(dif > 0){
end --;
}else{
start ++;
}
}//end while
}//end for i
return sum;
}
int main() {
scanf("%d %d %d %d", &n, &m, &S, &T);
for(int i = 1; i <= m; i++){
int a, b;
double c;
scanf("%d %d %lf", &a, &b, &c);
ins(a, b, c);
if (a != b)
d[b]++;
}
mysort();
for(int i = 1; i <= n; i++) {
int x = q[i];
if (x == T)
f[x] = 0;
else{
cal(x);
}
}
if (f[S] < 1e6)
printf("%.10lf\n",f[S]);
else
printf("-1\n");
return 0;
}
void
testWithStudents3()
{
int i;
int nelements = sizeof(students)/sizeof(Student);
printf("----- Students ----\n");
printf("Before\n");
for ( i = 0; i < nelements; i++ ) {
printf("%d:%-20s %2d\n", i, students[i].name, students[i].grade );
}
printf("----- Students Sorted by Name in Descending order ----\n");
mysort( nelements, sizeof(Student), students, 0, compareStudentByName );
for ( i = 0; i < nelements; i++ ) {
printf("%d:%-20s %2d\n", i, students[i].name, students[i].grade );
}
// Test that students are ordered by name in descending order
for ( i = 0; i < nelements-1 ; i++ ) {
assert( strcmp(students[i].name, students[i+1].name) >= 0 );
}
printf( "testWithStudents3 OK\n");
}
void
testWithIntDescending()
{
int i;
int nelements = sizeof(a)/sizeof(int);
printf("--- Numbers ----\n");
for ( i = 0; i < nelements; i++ ) {
printf("a[%d]=%d\n", i, a[i] );
}
mysort( nelements, sizeof(int), a, 0, compareInt );
printf("---- Numbers after Sorting ----\n");
for ( i = 0; i < nelements; i++ ) {
printf("a[%d]=%d\n", i, a[i] );
}
// Test that numbers are ordered
for ( i = 0; i < nelements -1 ; i++ ) {
assert( a[i] >= a[i+1] );
}
printf( "testWithint Ascending OK\n");
}
void treesizesort (struct dirsize_ *dirsize, unsigned int nodir, int sortby) {
/* int (*dircmpfn) (const void *a, const void *b);*/
unsigned long int dircmpfn;
switch (sortby) {
default :
case TREESIZESORTBYDIRSIZE :
dircmpfn = (unsigned long int) qsortdirsizecmp;
break;
case TREESIZESORTBYSUBSIZE :
dircmpfn = (unsigned long int) qsortttldirsizecmp;
break;
case TREESIZESORTBYPAHT :
dircmpfn = (unsigned long int) qsortpathdirsizecmp;
break;
}
#ifdef __TURBOC__
if ((nodir * sizeof (struct dirsize_)) < 65536u) {
qsort ((void *) dirsize, nodir, sizeof (struct dirsize_), (int (*) (const void *a, const void *b)) dircmpfn);
} else {
mysort ((void *) dirsize, nodir, sizeof (struct dirsize_), (int (*) (const void *a, const void *b)) dircmpfn);
}
#else
qsort ((void *) dirsize, nodir, sizeof (struct dirsize_), (int (*) (const void *a, const void *b)) dircmpfn);
#endif
} /* treesizesort */
int main(int argc, char *argv[])
{
dispstr(0,"Welcome to the HMM program!\n");
#ifndef __STDC_IEC_559__
printf("WARNING: ISO/IEC 60559 not respected!\n");
#endif
parse(argc, argv);
dispstr(0,"Loading file...\n");
delays_mt input = getinput();
dispstr(0,"Sorting inputs...\n");
mysort(&input);
//this offsets the timestamps to zero, and finds the min and max value of the delays.
delay_mt ymin = input.delay[0];
delay_mt ymax = ymin;
delay_mt current;
time_mt tmin = input.time[0];
for(long long i = 0; i<input.length; i++)
{
input.time[i] = input.time[i] - tmin;
current = input.delay[i];
if(current < ymin)
ymin = current;
if(current > ymax)
ymax = current;
}
//now, we offset the delays to zero
for(long long i = 0;i<input.length;i++)
{ //MINDELAY is an epsilon in order not to bug the algo
input.delay[i] = input.delay[i] - ymin + MINDELAY;
}
struct params p;
dispstr(0,"Initializing Markov parameters...\n");
initparams(&p, ymax);
input.length = input.length/300;
dispstr(0,"Training model...\n");
train(&p, &input, ymax);
dispstr(0,"Writing results...\n");
write_results(&p);
freeparams(&p);
dispstr(0,"Done.\n");
return EXIT_SUCCESS;
}
int maximumGap(int* nums, int numsSize) {
if (numsSize < 2) return 0;
mysort(nums, 0, numsSize-1);
int i;
int max_diff = 0;
for (i = 1; i < numsSize; ++i) {
max_diff = max(max_diff, nums[i]-nums[i-1]);
}
return max_diff;
}
int main()
{
int a[10];
int i = 0;
scanf("%d %d %d %d %d %d %d %d %d %d" ,&a[0],&a[1],&a[2],&a[3],&a[4],&a[5],&a[6],&a[7],&a[8],&a[9]);
mysort(a,10);
for(i=0;i<10;++i)
printf("%d ",a[i]);
fflush(stdin);
getchar();
}
void mysort(vector<int>& nums, int l, int r)
{
if(l >= r)
return;
int i = r;
for(int j = r-1; j >= l; j--)
{
if(nums[j] >= nums[r])
{
swap(nums[j], nums[i-1]);
i--;
}
}
swap(nums[i], nums[r]);
mysort(nums, l, i-1);
mysort(nums, i+1, r);
}
int main()
{
int i, v, last, val;
int refc = 0;
int acount = 0;
unsigned int s = nondet_unsigned_int(); //s is an arbitrary unsigned_int
__CPROVER_assume(s <= SIZE); // s is used to loop for a[],so assume s<=SIZE
int val = nondet_int(); //val is an arbitrary int
printf("LOG: s = %u, val = %d\n", s, val);
for (i = 0; i < s; i++)
{
v = nondet_int(); //v is an arbitrary int
a[i] = v;
printf("LOG: a[%d] = %d\n", i, v);
if (v == val)
{
refc++; // record times that a[i] has the same value = val
}
}
mysort(a, s); //do sort
printf("LOG: sorted a\n");
//after sort, verify two things: 1. whether sorted 2. whether times of values = val keep the same
//1. think about a[0]
if (s > 0)
{
last = a[0]; //set first tail for comparison
if (a[0] == val)
{
acount++; // record times that a[i] has the same value = val
}
}
//2. think about common a[i]
for (i = 1; i < s; i++)
{
printf("LOG: last = %d, a[%d] = %d\n", last, i, a[i]);
assert(a[i] >= last); //1. assert whether head is always bigger than tail
if (a[i] == val)
{
acount++; // keep recording times that a[i] has the same value = val
}
last = a[i]; // keep updating the tail
}
printf("LOG: refc = %d, acount = %d\n", refc, acount);
assert(refc == acount); //2. assert the number of same value is the same.
}
vector<int> mysort(vector<int>& x){ //non-descending order
vector<int> arr = x;
if(arr.size() == 1){
return arr;
}
if(arr.size() == 2){
if(arr[0]>arr[1]){
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
}
return arr;
}
int midpoint = arr.size() / 2;
vector<int> lo (arr.begin(),arr.begin() + midpoint);
vector<int> hi (arr.begin() + midpoint, arr.end());
lo = mysort(lo);
hi = mysort(hi);
vector<int> retval;
retval.reserve(lo.size()+hi.size());
int ptr1 = 0, ptr2 = 0;
while(lo.size() > ptr1 && hi.size() > ptr2){
if(lo[ptr1]<hi[ptr2]){
retval.push_back((int)lo[ptr1]);
ptr1++;
if(ptr1 >= lo.size()){
retval.insert(retval.end(), hi.begin() + ptr2, hi.end());
}//end if
}else{
retval.push_back((int)hi[ptr2]);
ptr2++;
if(ptr2 >= hi.size()){
retval.insert(retval.end(), lo.begin() + ptr1, lo.end());
}//end if
}//end if lo and hi
}//end while
return retval;
}//end mysort
void mysort(T* data, int N)
{
int i, j;
T v, t;
if (N <= 1) return;
// Partition elements
v = data[0];
i = 0;
j = N;
for (;;)
{
while (data[++i] < v && i < N) {}
while (data[--j] > v) {}
if (i >= j) break;
t = data[i]; data[i] = data[j]; data[j] = t;
}
t = data[i-1]; data[i-1] = data[0]; data[0] = t;
mysort(data, i-1);
mysort(data + i, N-i);
}
array_edges* kruskal(Graphe *graphe)
{
int nb_vertices= graphe->vertices.nb_vertices;
int nb_edges= graphe->edges.nb_edges;
mysort(&(graphe->edges), nb_edges);
array_edges* mst=(array_edges*)malloc(sizeof(array_edges));
// Number of edges initialized at the number of vertices -1
// (number of edges of the final mst)
init_size_edges(mst, nb_vertices-1);
int taille_mst=0;
int noeud_actuel=0;
subset mysubset[nb_vertices-1];
int i;
for(i=0;i<nb_vertices;i++)
{
mysubset[i].father=i;
mysubset[i].value=0;
}
while(taille_mst < (nb_vertices-1))
{
edge *actual_edge=get_edge(graphe->edges, noeud_actuel);
noeud_actuel++;
int compressed_children=path_compression(mysubset,actual_edge->first_v-1);
int compressed_father=path_compression(mysubset,actual_edge->second_v-1);
if(compressed_children != compressed_father)
{
add_edge(mst, actual_edge->first_v,actual_edge->second_v,actual_edge->cost,taille_mst);
taille_mst++;
subset_union(mysubset,compressed_children,compressed_father);
}
}
int total_weight=0;
int nb;
#ifdef DEBUG
display_edges(mst,taille_mst);
for(nb=0;nb<taille_mst;nb++)
{
total_weight+=(get_edge(*mst, nb))->cost;
}
printf("Le cout total est de %d\n",(int) total_weight);
#endif
return mst;
}
int main ()
{
//checks whether the sorted array and unsorted array are the permutation of each other.
//If the arrays are not permutations of each other, so one of them could not be the sorted version of the other.
int i, v, last, val;
int refc = 0;
int acount = 0;
unsigned int s = nondet_unsigned_int();
__CPROVER_assume (s <= SIZE);
int val = nondet_int();
printf ("LOG: s = %u, val = %d\n", s, val);
for (i = 0; i < s; i++) {
v = nondet_int();
printf ("LOG: a[%d] = %d\n", i, v);
a[i] = v;
if (v == val) {
refc++; //counts the number of times which a[i] has the same value as val.
}
}
mysort(a,s);
printf ("LOG: sorted a\n");
//checks whether the array is sorted or not
if (s > 0) {
last = a[0];
if (a[0] == val) {
acount++;
}
}
for (i = 1; i < s; i++) {
printf ("LOG: last = %d, a[%d] = %d\n", last, i, a[i]);
assert (a[i] >= last);
if (a[i] == val) {
acount++;
}
last = a[i];
}
printf ("LOG: refc = %d, acount = %d\n", refc, acount);
assert (refc == acount); //asserts whether the number of occurrence of values are the same in the array before and after sorting.
// assert(0);
}
int main()
{
int i, m;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
mysort(a, 0, n-1);
//qsort(a, n*sizeof(int), sizeof(int), cmp);
m = a[n-k] - a[k-1];
printf("%s\n%d\n", isprime(m)==1?"YES":"NO", m);
scanf("%s", &a); // 记得把Debug信息去掉
return 0;
}
int main()
{
int num[10], i, j ,tmp, flag;
int n = 10;
srand(time(NULL));
for (i = 0; i < n; i++)
num[i] = rand()%100;
for(i = 0; i < n - 1; i++)
{
flag = 0;
for(j = n - 2; j >= i; j--)
if(num[j] > num[j + 1])
{
tmp = num[j + 1];
num[j + 1] = num[j];
num[j] = tmp;
flag = 1;
}
if(!flag)
break;
}
for (i = 0; i < 10; i++)
{
printf("%d ", num[i]);
}
printf("\n");
mysort(num, n);
for (i = 0; i < 10; i++)
{
printf("%d ", num[i]);
}
printf("\n");
return 0;
}
void my_calc()
{
int i, restrest=0;
double exchange=0.00, tmp=0.00;
average = ((double)(int)((totalc/ppl_num)*100))/100;
average = roundm(average,2);
restc= (totalc-(average*ppl_num))*100;
restc = roundm(restc,2);
printf("total : %lf, average %lf, rest : %lf ppl : %d\n",totalc,average,restc,ppl_num);
fprintf(Fout,"total : %lf, average %lf, rest : %lf ppl : %d\n",totalc,average,restc,ppl_num);
mysort();//내림차순 정렬
for(i=0;i<ppl_num;++i)
{
//if(ddabs(charge[i]-188.69)<0.1)
// printf(",");
if((restc-i)>0.5)
{
tmp=ddabs(charge[i]-(average+0.01));
printf("%d tmp : %lf %lf(%lf)\n",i,tmp,charge[i],exchange+tmp);
fprintf(Fout,"%d tmp : %lf %lf(%lf)\n",i,tmp,charge[i],exchange+tmp);
//restc-=0.01;
}
else
{
tmp=ddabs(charge[i]-average);
printf("%d tmp : %lf\n",i,tmp);
fprintf(Fout,"%d tmp : %lf\n",i,tmp);
}
tmp = roundm(tmp,2);
exchange+=tmp;
// printf("tmp : %lf\n",tmp);
}
//printf("total : %.2lf\n",exchange);
exchange = roundm(exchange,2);
result_me = (exchange+0.005)/2;
printf("$%lf $%.2lf\n",(exchange+0.005),result_me);
fprintf(Fout,"$%.2lf\n",result_me);
}
int main()
{
char origin[100];
int len;
char **a;
int i;
while(scanf("%s", origin) != EOF){
len = strlen(origin);
a = (char **)malloc(len * sizeof(char *));
for(i = 0; i < len; i++){
a[i] = origin+i;
}
mysort(a, len);
for(i = 0; i < len; i++){
printf("%s\n", a[i]);
}
free(a);
a = NULL;
}
exit(0);
}
int main()
{
int i;
long long int ans = 0;
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%ld", &x[i]);
mysort(x, 0, n-1);
// for (i = 0; i< n; i++) printf("%d ", x[i]); putchar('\n');
for ( i = 0; i < n-1; i++)
ans += (i+1)*(n-i-1)*(x[i+1]-x[i]);
ans*=2;
//putchar('\n');
printf("%ld", ans);
//scanf("%d", &i);
return 0;
}
main(int argc, char *argv[]) {
char *num[MAX_SIZE];
int i, len;
// default: compare as string
FunCmp cmp = cmpstr;
i = 0;
while(--argc) {
if ((*++argv)[0] == '-') {
// - means options
char c;
while (c = *++argv[0]) {
switch(c) {
case 'r':
reverse = -1;
break;
case 'n':
cmp = cmpnum;
break;
case 'f':
cmp = cmp_ignore_case;
break;
default:
puts("argument error.");
exit(0);
}
}
} else {
// not - means number (negtive number not considered)
num[i++] = *argv;
}
}
len = i;
mysort(num, 0, len - 1, cmp);
for (i = 0; i < len; ++i) {
puts(num[i]);
}
}
void dirsort (int dbidx, int sorttype) {
/* int (*dircmpfn) (const void *a, const void *b);*/
unsigned long int dircmpfn;
qsortidx0 = dbidx;
qsortidx1 = dbidx;
switch (sorttype) {
default :
case SORTBYDIR :
dircmpfn = (unsigned long int) qsortdircmp;
break;
case SORTBYDUP :
dircmpfn = (unsigned long int) qsortdupcmp;
break;
case SORTBYDUPNONM :
dircmpfn = (unsigned long int) qsortnonamedupcmp;
break;
}
#ifdef __TURBOC__
if ((dirptr [dbidx] * sizeof (struct dirlist)) < 65536u) {
qsort ((void *) dirbuf [dbidx], dirptr [dbidx], sizeof (struct dirlist),
(int (*) (const void *a, const void *b)) dircmpfn);
} else {
mysort ((void *) dirbuf [dbidx], dirptr [dbidx], sizeof (struct dirlist),
(int (*) (const void *a, const void *b)) dircmpfn);
}
#else
qsort ((void *) dirbuf [dbidx], dirptr [dbidx], sizeof (struct dirlist),
(int (*) (const void *a, const void *b)) dircmpfn);
#endif
} /* dirsort */
void test(int N)
{
T* data;
time_t begin, end;
double time_elapsed;
int i;
if (N < 1) { printf("N must be at least 1\n"); return; }
data = (T*) malloc(N*sizeof(T));
if (!data) return;
for (i = 0; i < N; i++)
data[i] = rand();
begin = clock();
mysort(data, N);
end = clock();
time_elapsed = (double) (end-begin) / CLOCKS_PER_SEC;
printf("%.2lf\n", time_elapsed);
free(data);
}
