int main()
{
int t, max_meet, temp;
int ang_route[3000], t_route[3000], al, tl;
scanf("%d", &t);
while(t--) {
//read Angena's route
max_meet = 0;
read_arr(ang_route, &al);
while(1) { //read possible routes by tom
read_arr(t_route, &tl);
if(tl == 1 && t_route[0] == 0) {
break;
}
max_meet = max(max_meet, int_lcs(ang_route, t_route, al, tl));
}
printf("%d\n", max_meet);
}
return 0;
}
int main(int argc, char *argv[]){
if(argc < 3){
printf("Usage: ./sort method array_length array\n");
exit(1);
}
int method = SORT_QUICK;
if(argc == 4){
if(is_prefix(argv[1], "quick")){
method = SORT_QUICK;
} else if(is_prefix(argv[1], "merge")){
method = SORT_MERGE;
} else if(is_prefix(argv[1], "insertion")){
method = SORT_INSERTION;
} else if(is_prefix(argv[1], "radix")){
method = SORT_RADIX;
} else {
fprintf(stderr, "Uknown sorting method %s, using default\n", argv[1]);
}
argv++;
}
ulong len;
int err = strtoul_checked(argv[1], &len, NULL);
if(err){
perror("strtoul");
exit(1);
}
ulong *arr = read_arr(len, argv[2]);
if(!arr){
perror("strtoul");
exit(1);
}
//sort stuff
switch(method){
case(SORT_QUICK):
qsort_u64(arr,len); break;
case(SORT_MERGE):
mergesort_u64(arr,len);break;
case(SORT_INSERTION):
insertion_sort_u64(arr,len);break;
case(SORT_RADIX):
radix_sort_u64(arr,len);break;
}
if(is_sorted(arr,len)){
printf("Array was sorted\n");
} else {
printf("Failed to sort array\n");
}
print_arr(arr, len, stdout);
free(arr);
return 0;
}
state task1(void* data, void* params)
{
arr_count = 0;
system("cls");
char ch;
if (exist(ARR_FILE_NAME))
{
printf(Rus("Файл существует, прочитать? Y/N: "));
do {
ch = fgetc(stdin);
} while (ch != 'Y' &&
ch != 'y' &&
ch != 'N' &&
ch != 'n');
switch (ch)
{
case 'Y':
case 'y':
read_arr(NULL, NULL);
break;
default:
break;
}
}
//Создаем меню
menu_t* menu = menu_create("Задание 1");
//Добавляем пункты в меню
menu_add_item(menu, Rus("Добавить элементы в массив"), &input_arr, NULL, NULL);
menu_add_item(menu, Rus("Вывести массив на экран"), &print_arr, NULL, NULL);
menu_add_item(menu, Rus("Сохранить массив в файл"), &save_arr, NULL, NULL);
menu_add_item(menu, Rus("Прочитать массив из файла"), &read_arr, NULL, NULL);
menu_add_item(menu, Rus("Выполнить задание варианта 2"), &do_task1, NULL, NULL);
menu_add_item(menu, Rus("Вернутся в главное меню"), &exit_sub, menu, NULL);
//Выполняем меню
menu_execute(menu, NULL);
menu_free(menu);
return REDRAW_ALL;
}
bool test_one_file(std::ifstream& in, int verbose_level)
{
std::list<X_monotone_curve_2> xcurves;
std::list<Point_2> isolated_points;
read_arr(in, std::back_inserter(xcurves),
std::back_inserter(isolated_points));
Arrangement arr1;
construct_arr(arr1, xcurves.begin(), xcurves.end(),
isolated_points.begin(), isolated_points.end(), verbose_level);
isolated_points.clear();
xcurves.clear();
init_arr(arr1, verbose_level);
read_arr(in, std::back_inserter(xcurves),
std::back_inserter(isolated_points));
Arrangement arr2;
construct_arr(arr2, xcurves.begin(), xcurves.end(),
isolated_points.begin(), isolated_points.end(), verbose_level);
isolated_points.clear();
xcurves.clear();
init_arr(arr2, verbose_level);
// Read the number of cells left.
Arrangement::Size num_vertices, num_edges, num_faces;
in >> num_vertices >> num_edges >> num_faces;
// Read the expected face data:
std::vector<int> fdata(num_faces);
std::copy(std::istream_iterator<int>(in), std::istream_iterator<int>(),
fdata.begin());
Arrangement arr;
Overlay_traits overlay_traits;
if (verbose_level > 2) std::cout << "overlaying" << " ... "; std::cout.flush();
CGAL::overlay(arr1, arr2, arr, overlay_traits);
if (verbose_level > 2) std::cout << "overlaid" << std::endl;
// Verify the resulting arrangement.
Arrangement::Size num_vertices_res = arr.number_of_vertices();
Arrangement::Size num_edges_res = arr.number_of_edges();
Arrangement::Size num_faces_res = arr.number_of_faces();
if (verbose_level > 0) std::cout << "Arrangement Output: " << std::endl;
if (verbose_level > 1) {
std::cout << "Halfedge Data: " << std::endl;
Halfedge_iterator heit;
for (heit = arr.halfedges_begin(); heit != arr.halfedges_end(); ++heit)
std::cout << heit->source()->point() << " "
<< heit->target()->point() << " " << heit->data()
<< std::endl;
}
if (verbose_level > 0) {
std::cout << "Face Data: " << std::endl;
Face_iterator fit;
for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit)
std::cout << fit->data() << std::endl;
}
if ((num_vertices_res != num_vertices) ||
(num_edges_res != num_edges) ||
(num_faces_res != num_faces))
{
std::cerr << "ERROR: The number of arrangement cells is incorrect:"
<< std::endl
<< " V = " << arr.number_of_vertices()
<< ", E = " << arr.number_of_edges()
<< ", F = " << arr.number_of_faces()
<< std::endl;
arr.clear();
return false;
}
std::vector<int> fdata_res(num_faces);
std::vector<int>::iterator it = fdata_res.begin();
Face_iterator fit;
for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit)
*it++ = fit->data();
std::sort(fdata_res.begin(), fdata_res.end());
if (! std::equal(fdata_res.begin(), fdata_res.end(), fdata.begin())) {
std::cerr << "ERROR: Incorrect face data:" << std::endl;
std::copy(fdata_res.begin(), fdata_res.end(),
std::ostream_iterator<int>(std::cout, "\n"));
arr.clear();
return false;
}
arr.clear();
return true;
}
int main(int argc, char *argv[]) {
if(argc < 3) {
printf("Usage: ./sort method array_length array\n");
exit(1);
}
int method = SORT_ALL;
if(argc == 4) {
if(is_prefix(argv[1], "quick")) {
method = SORT_QUICK;
} else if(is_prefix(argv[1], "merge")) {
method = SORT_MERGE;
} else if(is_prefix(argv[1], "insertion")) {
method = SORT_INSERTION;
} else if(is_prefix(argv[1], "radix")) {
method = SORT_RADIX;
} else if(is_prefix(argv[1], "heap")) {
method = SORT_HEAP;
} else if(is_prefix(argv[1], "all")) {
method = SORT_ALL;
} else {
fprintf(stderr, "Uknown sorting method %s, using default\n", argv[1]);
}
argv++;
}
ulong len;
int err = strtoul_checked(argv[1], NULL, 0, &len);
if(err) {
perror("strtoul");
exit(1);
}
ulong *arr;
int fd = open(argv[2], O_RDONLY);
if(fd>0) {
size_t sz;
char *file = mmap_file(fd, 1, PROT_READ, &sz);
if(!file) {
exit(1);
}
//char *file = read_file_to_string(fd, NULL);
close(fd);
arr = read_arr(len, file);
munmap(file, sz);
//free(file);
} else {
arr = read_arr(len, argv[2]);
}
if(!arr) {
perror("strtoul");
exit(1);
}
//sort stuff
double time;
switch(method) {
case(SORT_INSERTION):
time = time_sort(arr, len, insertion_sort_u64);
break;
case(SORT_MERGE):
time = time_sort(arr, len, mergesort_u64);
break;
case(SORT_HEAP):
time = time_sort(arr, len, heapsort_u64);
break;
case(SORT_QUICK):
time = time_sort(arr, len, qsort_u64);
break;
case(SORT_RADIX):
time = time_sort(arr, len, radix_sort_u8_u64);
double time2 = time_sort(arr, len, radix_sort_u16_u64);
printf("Radix sort with byte histograms: %f\n"
"Radix sort with word histograms: %f\n", time, time2);
return 0;
case(SORT_ALL): {
double times[6];
uint64_t *arr_bkup = xmalloc(len * sizeof(uint64_t));
memcpy(arr_bkup, arr, (len * sizeof(uint64_t)));
times[0] = time_sort(arr, len, bubble_sort_u64);
memcpy(arr, arr_bkup, (len * sizeof(uint64_t)));
times[1] = time_sort(arr, len, insertion_sort_u64);
memcpy(arr, arr_bkup, (len * sizeof(uint64_t)));
times[2] = time_sort(arr, len, mergesort_u64);
memcpy(arr, arr_bkup, (len * sizeof(uint64_t)));
times[3] = time_sort(arr, len, heapsort_u64);
memcpy(arr, arr_bkup, (len * sizeof(uint64_t)));
times[4] = time_sort(arr, len, qsort_u64);
memcpy(arr, arr_bkup, (len * sizeof(uint64_t)));
times[5] = time_sort(arr, len, radix_sort_u64);
printf("Times taken to sort:\n"
"Bubble sort: %f\n"
"Insertion sort: %f\n"
"Merge sort: %f\n"
"Heap sort: %f\n"
"Quick sort: %f\n"
"Radix sort: %f\n",
times[0], times[1], times[2], times[3], times[4], times[5]);
return 0;
}
default:
return 1;
}
printf("Time taken to sort: %f\n", time);
return 0;
}
