/**
* @brief main Example used for testing the algorithm, the correct usage ./isort max cnt.
* This creates a random array of size max constrained to -cnt to +cnt
*
* @return
*/
int main ( int argc, char *argv[] )
{
size_t len;
uint32_t i;
int32_t *src;
int32_t max;
if(argc < 3){
printf("Correct Usage isort len max\n");
perror("Incorrect isort.c usage");
return EXIT_FAILURE;
}
srand(time(NULL));
len = (size_t) atoi(argv[1]);
max = (int32_t) atoi(argv[2]);
printf("Creating random array of input %d and constrained to %d\n",
(int) len, (int) max);
src = cr_rnd_arr(len, max);
print_arr(src,len);
printf("Printing UP SORTED array\n");
isort(src, len, ISORT_UP);
print_arr(src, len);
printf("Printing DOWN SORTED array\n");
isort(src, len, ISORT_DOWN);
print_arr(src,len);
free(src);
return EXIT_SUCCESS;
}
// 使用辅助数组 L[LEN], R[LEN]
void solve_1()
{
int L[LEN], R[LEN];
int i, _max = 0;
for (i = 0;i < LEN;i++)
{
_max = max(_max, arr[i]);
L[i] = _max;
}
_max = 0;
for (i = LEN - 1;i >= 0;i--)
{
_max = max(_max, arr[i]);
R[i] = _max;
}
print_arr(arr, LEN);
print_arr(L, LEN);
print_arr(R, LEN);
int water_tol = 0;
for (i = 1;i < LEN - 1;i++)
{
water_tol += max(0, (min(L[i - 1], R[i + 1]) - arr[i]));
}
printf("water_tol: %d\n", water_tol);
}
int main()
{
int arr[] = {1, 20 ,6, 4, 5};
print_arr(arr, 0, 4);
merge_sort(arr, 5);
print_arr(arr, 0, 4);
}
int main()
{
int arr[] = {5, 2, 4, 6, 1, 3};
print_arr(arr, 6);
merge_sort (arr, 0, 5);
print_arr(arr, 6);
return 0;
}
int main()
{
int* arr = createArr(10, INT);
print_arr(arr, 10);
mergeSort(arr, 0 , 9);
print_arr(arr, 10);
free(arr);
return 0;
}
int main(int argc, char* argv[]) {
const int N_SIZE = 10;
int n[N_SIZE] = { 9,8,7,6,5,4,3,2,1,0 };
insertion_sort(n, N_SIZE);
print_arr(n, N_SIZE);
int n2[N_SIZE] = {-9,-8, -7, -6, -5, -4, -3, -2, -1, 0};
insertion_sort(n2, N_SIZE);
print_arr(n2, N_SIZE);
}
int main(int argc, char* argv[])
{
clock_t start, stop;
int i, j;
int N;
double* a;
double* b;
double* c;
if(argc < 2)
{
printf("Enter matrix size N=");
//please enter small number first to ensure that the
//multiplication is correct! and then you may enter
//a "reasonably" large number say like 500 or even 1000
scanf("%d",&N);
}
else
{
N = atoi(argv[1]);
}
a=(double*) malloc( sizeof(double)*N*N );
b=(double*) malloc( sizeof(double)*N*N );
c=(double*) malloc( sizeof(double)*N*N );
init_arr(N,a);
init_arr(N,b);
//DGEMM Multiply
//reallocate to force cash to be flushed
a=(double*) malloc( sizeof(double)*N*N );
b=(double*) malloc( sizeof(double)*N*N );
c=(double*) malloc( sizeof(double)*N*N );
init_arr(N,a);
init_arr(N,b);
start = clock();
//for(i=0;i<1000;i++)
Dgemm_multiply(a,b,c,N);
stop = clock();
printf("Dgemm_multiply(). Elapsed time = %g seconds\n",
((double)(stop - start)) / CLOCKS_PER_SEC);
//print simple test case of data to be sure multiplication is correct
if (N < 7) {
print_arr(N,"a", a);
print_arr(N,"b", b);
print_arr(N,"c", c);
}
free(a);
free(b);
free(c);
return 0;
}
void insertion_sort(int* arr, int s) {
int V = *(arr + s - 1);
int idx = s - 2;
while ( -1 < idx && V < *(arr + idx) ) {
*(arr + idx + 1) = *(arr + idx);
print_arr(arr, s);
--idx;
}
*(arr + idx + 1) = V;
print_arr(arr, s);
}
int main(void)
{
int arr[20];
init_arr(arr, 20);
print_arr(arr, 20);
sort_arr(arr, 20);
print_arr(arr, 20);
return 0;
}
void map() {
int* arr;
double dt = 0.01;
int N = 100000;
Quadrotor* r = new Quadrotor(dt, N);
VQPoles(r);
int choices = 5;
int repeat = 3;
//int len = pow(choices, repeat);
product(choices, repeat, arr);
//double center[] = {10.0, 3.0, 7.0, 3.0};
//double length[] = { 9.9, 2.9, 6.9, 2.9};
double center[] = {-10.0, -10.0, -00.0};
double length[] = { 5.0, 5.0, 0.0};
double* coeff = new double[choices * repeat];
printf("map start\n");
for(int b = 0; b < 20; b++) {
int a = -1;
set_coeff(center, length, choices, repeat, coeff);
a = sub1(r, arr, coeff, choices, repeat);
if(a == -1) {
printf("failed\n");
return;
}
for(int c = 0; c < repeat; c++) {
center[c] = coeff[c*choices + arr[a*repeat + c]];
length[c] = length[c] * 0.8;
}
printf("center length\n");
print_arr(center, repeat);
print_arr(length, repeat);
//printf("a %i\n",a);
}
}
int main(int argc, char **argv)
{
int i,array[N];
srand((unsigned)time(NULL));
for(i = 0; i < N; i++)
array[i] = rand() % 100; //取随机数赋值
print_arr(array,N);
bobsort(array,N);
print_arr(array,N);
return 0;
}
/*
* Print an array of randomly-generated integers,
* quicksort it, and then print it again
*
* Accept a command-line arg for the array length
* and a -q flag to suppress output
*
* Sample input:
* $ while true; do time quicksort -q 999999; done
*
* Spawn 4 background processes:
* $ for i in {1..4}; do time quicksort -q 999999 & done
*/
int main(const int argc, const char *argv[])
{
size_t arg, length = 0;
int i, quiet = 0;
int *numbers;
/* Parse args */
for (i = 1; i < argc; i++) {
if (strncmp(argv[i], "-q", 2) == 0) {
quiet = 1;
} else {
arg = strtoul(argv[i], NULL, 10);
/* Use strtol in case sign is negative */
if (strtol(argv[i], NULL, 10) < 2 || arg > MAX_LEN) {
puts("ERROR: Invalid argument");
printf("%s\n", argv[i]);
return 1;
}
/* Set length if it isn't already set */
if (length == 0)
length = arg;
}
}
/* No length set in parse args */
if (length == 0)
length = 64;
/* No need to zero array with calloc, init_arr will init */
numbers = malloc(length * sizeof(int));
srandom(time(NULL));
init_arr(numbers, length);
if (! quiet) {
puts("Array:");
print_arr(numbers, length);
}
/* Pass first and last indices to quicksort */
quicksort(numbers, 0, length - 1);
if (! quiet) {
puts("Quicksort:");
print_arr(numbers, length);
}
/* Do the polite thing */
free(numbers);
return 0;
}
int
main()
{
int nums[] = {21, 42, 50, 17, 12, 8, 54, 33, 22, 9, 10, 12, 3};
int len = arr_len(nums);
print_arr(nums, len);
bucket_sort(nums, len);
print_arr(nums, len);
return 0;
}
int
main()
{
int nums[] = {2, 4, 3, 1, 5, 9, 10, 8, 7, 6};
int len = arr_len(nums);
print_arr(nums, len);
shell_sort(nums, len);
print_arr(nums, len);
return 0;
}
void InsertionSortWithSteps(int N, int *A)
{
int j, pivot = A[N-1];
for(j = N-2; j >= 0; j--)
if(A[j] > pivot && (A[j+1] = A[j])) //Same as if(A[j] > pivot){ A[j+1] = A[j]; print_arr(N, A); } else ..
print_arr(N, A);
else
break;
A[j+1] = pivot;
print_arr(N, A);
}
int main(void){
ArrayUtil arr = create(4, 1);
ArrayUtil arr2 = create(4, 3);
areEqual(arr, arr2);
arr = resize(arr, 7);
print_arr(arr);
int x = 20;
*((int *)arr.base) = 20;
printf("The index of %d is %d ", x, findIndex(arr, &x));
print_arr(arr);
dispose(arr);
return 0;
};
int main(int argc, char *argv[])
{
int *arr1, *arr2;
int i;
int num_element = atoi(argv[1]);
int num_generation = atoi(argv[2]);
/* Check command-line violations */
if (argc > MaxArgc + 1 || num_element == 0 || num_generation == 0)
{
fprintf(stderr, "usage: %s #cells #generations\n", argv[0]);
exit(1);
}
arr1 = initial_array(num_element);
print_arr(arr1, num_element);
if (num_generation > 1) /* If there is 1 generation, loop does not work */
{
for (i = 1; i < num_generation; i++)
{
/* Alternate between arr1, arr2 to store the updated array */
if (i % 2 == 1)
{
arr2 = update(arr1, num_element);
print_arr(arr2, num_element);
free(arr1);
}
else
{
arr1 = update(arr2, num_element);
print_arr(arr1, num_element);
free(arr2);
}
}
/* Prevent memory leakage of the array used last */
if (num_generation % 2 == 0)
{
free(arr2);
}
else
{
free(arr1);
}
}
else
{
free(arr1);
}
print_memory_leaks();
return 0;
}
int main(int argc, char **argv)
{
int array[N];
int i;
srand((unsigned)time(NULL));
for(i = 0; i < N; i++)
array[i] = rand() % 100;
print_arr(array,N);
quicksort(array,N);
print_arr(array,N);
return 0;
}
int main(void)
{
int i;
int* arr = malloc(10 * sizeof(int));
for (i = 0; i < 10; i++)
arr[i] = i-5;
print_arr(arr, 10);
shuffle(arr, 0, 9);
print_arr(arr, 10);
free(arr);
return 0;
}
int main() {
add_elem('a');
add_elem('b');
add_elem('c');
print_arr();
printf("\nRemoved Elem: %c",remove_elem());
printf("\nRemoved Elem: %c",remove_elem());
add_elem('d');
print_arr();
add_elem('e');
print_arr();
add_elem('f');
print_arr();
return 0;
}
int main()
{
int* A = createArr(20, INT);
print_arr(A, 20);
int* B = createArr(10, INT);
print_arr(B, 10);
int i;
int size = 10;
for( i = 0 ; i < 10 ; i++)
{
insertionSort(A, B[i], i + 10);
}
print_arr(A, 20);
return 0;
}
int main(int argc, char** argv) {
/* read command line args if any */
size = (argc > 1) ? atoi(argv[1]) : MAX_SIZE;
if (size > MAX_SIZE) size = MAX_SIZE;
randomize_arr();
#ifdef DEBUG
print_arr();
#endif
do_seq_quicksort();
do_parallel_quicksort();
check_sorting();
#ifdef DEBUG
print_arr();
#endif
return (EXIT_SUCCESS);
}
int
main()
{
int size = SIZE;
int **arr;
if (SIZE > MAX_SIZE) {
printf("Unsupported size %d. Max supported = %d\n", SIZE,
MAX_SIZE);
}
if (NUM_EP > SIZE) {
printf("Number of endpoints %d greater than grid size %d\n",
NUM_EP, SIZE);
}
arr = alloc_n_by_n_array(size);
initialize_arr(arr, size);
setup_puzzle(ref_arr, arr, size);
printf("Problem:\n");
printf("===============\n");
print_arr(arr, size);
printf("\nSolutions: \n");
printf("===============\n");
failure_count = 0;
solution_count = 0;
solve_puzzle(arr, size);
printf("\nCompletions but no array full = %d\n", failure_count);
printf("\nSolution count = %d\n", solution_count);
print_cc();
}
int main(int argc, const char *argv[])
{
int *A;
int n;
clock_t start, end;
if (argc < 2) {
fprintf(stderr, "Usage: %s <file to sort>\n", argv[0]);
return EXIT_FAILURE;
}
n = readfile(&A, argv[1]);
if (n < 0) {
fprintf(stderr, "Failed to parse file\n");
return -1;
}
start = clock();
qsort(A, n, sizeof(int), compar);
end = clock();
print_arr(A, n);
fprintf(stderr, "%ld bytes sorted in %f seconds\n", n * sizeof(int), (double)(end - start) / CLOCKS_PER_SEC);
free(A);
return 0;
}
int check_builtins(t_cpe *cpe)
{
check_cmd_path(cpe);
if (ft_strcmp(CMD, "exit") == 0)
return (exec_err(cpe));
if (ft_strcmp(CMD, "echo") == 0)
return (ft_echo(cpe) + 10);
else if (ft_strcmp(CMD, "cd") == 0)
return (ft_chdir(cpe));
else if (ft_strcmp(CMD, "env") == 0)
return (check_envi(cpe));
else if (ft_strcmp(CMD, "setenv") == 0)
{
if (!PRM)
return (print_arr(ENV) + 10);
if (arr_size(PRM) > 2)
{
ft_putendl("setenv: Too many arguments");
ft_putendl("usage: setenv [name[value]]");
return (11);
}
return (ft_setenv(cpe) + 10);
}
else if (ft_strcmp(CMD, "unsetenv") == 0)
return (ft_unsetenv(cpe) + 10);
else
return (-1);
}
/*
* Juho Gävert & Santeri Hiltunen
Starting point of calculation. Searches for temperature balance in Array for
maximum iterations of max_iters.
*/
double calculate_heatconduct(Array* arr, unsigned int max_iters)
{
if (max_iters == 0 || arr->width < 3 || arr->height < 3)
return -1;
Array* temp_arr = new_array(arr->width, arr->height);
copy_array(arr, temp_arr);
double prev_mean = -1;
for (unsigned int i = 0; i < max_iters; ++i) {
double new_mean = calculate_iteration(arr, temp_arr);
swap_ptrs((void**) &arr, (void**) &temp_arr);
if (conf.verbose) {
printf("Iter: %d Mean: %.15f\n", i + 1, new_mean);
if (conf.verbose > 1) {
print_arr(arr);
}
}
if (fabs(new_mean - prev_mean) < 0.0000000000001) {
printf("Found balance after %d iterations.\n", i);
del_array(temp_arr);
return new_mean;
}
prev_mean = new_mean;
}
del_array(temp_arr);
printf("Didn't find balance after %d iterations.\n", max_iters);
return prev_mean;
}
int main()
{
const int nth=13,nph=9;
for(double u=0;u<2*M_PI;u+=2*M_PI/nth)
for(double v=0;v<2*M_PI;v+=2*M_PI/nph)
{
double x1=cos(u)*(1.0*cos(v)+3),y1=sin(u)*(1.0*cos(v)+3),z1=1.0*sin(v);
double x2=cos(u)*(1.3*cos(v)+3),y2=sin(u)*(1.3*cos(v)+3),z2=1.3*sin(v);
for(int i=0;i<10;i++)
{
print_arr(x1,y1,z1,x2,y2,z2);
double r,th,ph;
cart_to_pol(r,th,ph,x2-x1,y2-y1,z2-z1);
double x3,y3,z3;
pol_to_cart(x3,y3,z3,r,th+((double)rand()/RAND_MAX-0.5)/3,ph+((double)rand()/RAND_MAX-0.5)/3);
x1=x2;
y1=y2;
z1=z2;
x2+=x3;
y2+=y3;
z2+=z3;
}
//printf("set arrow %d from %lg,%lg,%lg to %lg,%lg,%lg\n",iarr++,x1,y1,z1,x2,y2,z2);
}
return 0;
}
int bubble_sort(int arr[], int n)//冒泡算法
{
int i, j;
for(i = 0; i < n - 1; i++)
{
int flag = 0;//设置标志
for(j = i + 1; j < n; j++)//注意每次进入内层for循环时都会对j进行一次初始化，不要写成j=1;
{
if (arr[i] > arr[j])
{
int temp = 0;
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
flag = 1;
}
else
continue;
}
if(flag == 0)//不要写成 =
break;//若flag没变，说明数组有序，无需再排，直接break输出
}
print_arr(arr,n );
return 0;
}
int
main(void)
{
int i;
int a[] = {3, 49, 90, 3, 7, 1, 67};
printf("排序前：\n");
print_arr(a, 7);
quick_sort(a, 0, 6);
printf("输出快速排序结果：\n");
print_arr(a, 7);
return ;
}
int main()
{
int arr[9] = {9, 3, 2, 7, 6, 1, 4, 5, 8};
selection_sort(arr, 0, 9);
print_arr(arr, 9);
return 0;
}
