void dc3(int *r, int *sa, int n, int m) {
int j, *rn = r + n, *san = sa + n, ta = 0, tb = (n + 1) / 3, tbc = 0, p;
r[n] = r[n + 1] = 0;
rep(i, n)
if (i % 3 != 0) wa[tbc++] = i;
rsort(r + 2, wa, wb, tbc, m);
rsort(r + 1, wb, wa, tbc, m);
rsort(r, wa, wb, tbc, m);
for (p = 1, rn[F(wb[0])] = 0, j = 1; j < tbc; j++)
rn[F(wb[j])] = c0(r, wb[j - 1], wb[j]) ? p - 1 : p++;
if (p < tbc) dc3(rn, san, tbc, p);
else rep(i, tbc)
san[rn[i]] = i;
rep(i, tbc)
if (san[i] < tb) wb[ta++] = san[i] * 3;
if (n % 3 == 1) wb[ta++] = n - 1;
rsort(r, wb, wa, ta, m);
rep(i, tbc)
wv[wb[i] = G(san[i])] = i;
int i;
for (i = j = p = 0; i < ta && j < tbc; p++)
sa[p] = c12(wb[j] % 3, r, wa[i], wb[j]) ? wa[i++] : wb[j++];
for (; i < ta; p++) sa[p] = wa[i++];
for (; j < tbc; p++) sa[p] = wb[j++];
}
int main()
{
int i,nums[MAX],right,left,cnt=0;
FILE *fp;
if((fp=fopen("kadai-02-1.txt","r"))==NULL){
printf("can't open a file\n");
exit(1);
}
while(fscanf(fp,"%d",&nums[cnt]) != EOF) cnt++;
left=0;right=cnt-1;
while(left<right){
right=rsort(nums,left,right);
if(left>=right-1) break;
left=lsort(nums,left,right);
}
for(i=0;i<cnt;i++){
printf("%d\n",nums[i]);
}
return 0;
}
static F2(jtcfrz){A z;B b=0,p;I j,n;Z c,d,*t,*u,*v;
RZ(w=rsort(w));
n=AN(w); u=ZAV(w);
GATV(z,CMPX,1+n,1,0); v=ZAV(z); *v=c=*ZAV(a); p=!c.im;
for(j=0;j<n;++j){
d=znegate(u[j]); t=j+v; *(1+t)=*t;
DO(j, *t=zplus(*(t-1),ztymes(d,*t)); --t;);
*v=ztymes(d,*v);
if(p&&d.im)if(b=!b)c=u[j]; else if(p=ZCJ(c,u[j])){t=v; DO(2+j, t++->im=0.0;);}
void suffixarray(char text[],int t[],int m)
{
int i,j,k,n;
static int s[N*2],tmp[N+2];
for(n=0;text[n];n++)s[n]=text[n],t[n]=n;
for(t[n]=i=n;i<n*2;i++)s[i]=0;
for(i=1;i<n;i*=2)
{
rsort(s+i,t,tmp,n,m);
rsort(s,tmp,t,n,m);
for(j=0;j<n;j++)tmp[j]=s[j];
for(j=0,m=1;j<n;j++)
{
s[t[j]]=m;
if(tmp[t[j]]!=tmp[t[j+1]] || tmp[t[j]+i]!=tmp[t[j+1]+i])m++;
}
}
}
int main()
{
int numeros[10] = {1,3,6,2,4,3,1,8,6,9};
imprimir (numeros, 10);
sort(numeros, 10);
imprimir (numeros, 10);
rsort(numeros, 10);
imprimir (numeros, 10);
return EXIT_SUCCESS;
}
int main()
{
int round,i,tmp;
node_ptr root=NULL;
scanf("%d",&round);
for(i=0;i<round;i++)
{
scanf("%d",&tmp);
root=insert_list(root,tmp);
}
root=rsort(root);
print_list(root);
}
int main(int argc, char** argv){
uint8_t prefix = atoi(argv[argc-1]);
/////////////////////////////////////////////////////////////
// PartitionCount
/////////////////////////////////////////////////////////////
FILE *partition = fopen(argv[2], "rb");
if(partition == NULL) {
fprintf(stderr, "%s\n", "Fail to open file");
exit(0);
}
fread(partitionCount, sizeof(unsigned long long), 256, partition);
fclose(partition);
/////////////////////////////////////////////////////////////
// Load Partition
/////////////////////////////////////////////////////////////
FILE *fp = fopen(argv[1], "rb");
if(fp == NULL) {
fprintf(stderr, "%s\n", "Fail to open file");
exit(0);
}
S_Prefix = malloc(sizeof(*S_Prefix) * partitionCount[prefix]);
if(S_Prefix == NULL) {
fprintf(stderr, "%s\n", "Fail to alloc memory: S_Prefix");
exit(0);
}
prefixMemory = malloc(sizeof(*prefixMemory)*READ_CODE_LEN* partitionCount[prefix]);
unsigned int readNum = 0;
while(fread(prefixMemory + readNum*READ_CODE_LEN*1024, sizeof(uint8_t), READ_CODE_LEN*1024, fp))
readNum++;
fclose(fp);
unsigned long long i, j;
for(i = 0; i < partitionCount[prefix]; i++){
S_Prefix[i] = prefixMemory + i * READ_CODE_LEN;
if(S_Prefix[i] == NULL){
fprintf(stderr, "Fail to alloc memory: S_Prefix[%llu]\n", i);
}
}
///////////////////////////////////////////////////////////////////
// Print Pre-sort suffixes
///////////////////////////////////////////////////////////////////
//printf("Pre-sort suffixes with prefix %d\n", prefix);
//PrinfSuffixes(S_Prefix, partitionCount[prefix]);
///////////////////////////////////////////////////////////////////
// Sort suffixes
///////////////////////////////////////////////////////////////////
ta = malloc(sizeof(*ta)*partitionCount[prefix]); // Total size: 4n
if(ta == NULL) {
fprintf(stderr, "%s\n", "Fail to alloc memory: ta");
exit(0);
}
stack = malloc(sizeof(*stack)*partitionCount[prefix]);
if(stack == NULL) {
fprintf(stderr, "%s\n", "Fail to alloc memory: stack");
exit(0);
}
rsort(S_Prefix, ta, stack, partitionCount[prefix]);
free(stack); stack = NULL;
free(ta); ta = NULL;
///////////////////////////////////////////////////////////////////
// Print sorted suffixes
///////////////////////////////////////////////////////////////////
//printf("Sorted suffixes with prefix %d\n", prefix);
//PrinfSuffixes(S_Prefix, partitionCount[prefix]);
free(prefixMemory);
free(S_Prefix);
}
/*!
* \param argv[1] Dimension of square matrix, i.e. number of rows = number of columns
*/
int main(int argc, char** argv) {
/* Message identifier for sending/receiving columns in a matrix */
int COLUMN_TAG = 0;
/* Dimension of square matrix (i.e. number of rows = number of columns) */
int DIMENSION;
/* Used for error handling */
int error_code;
/* Total number of processes used in this program */
int NUMBER_OF_PROCESSES;
/* Current process */
int PROCESS_ID;
/* Main loop counter. Counts from 0 to \f$\log_2 N\f$, where N = DIMENSION. */
int program_counter;
/* Message identifier for sending/receiving rows in a matrix */
int ROW_TAG = 1;
/* Used to start timing shearsort algorithm */
time_t start;
/* Used to end timing shearsort algorithm */
time_t end;
/* Derived datatype for sending a column in a matrix to a process */
MPI_Datatype column_type;
/* Used in MPI_Recv */
MPI_Status status;
/***************************************************************************************************/
if (argc != 2) {
printf("Usage: ./shearsort [dimension of square matrix]\nPlease try again.\n");
exit(1);
}
if ((DIMENSION = atoi(argv[1])) <= 0) {
printf("Error: Invalid argument for dimension of square matrix. Please try again.\n");
exit(1);
}
/***************************************************************************************************/
error_code = MPI_Init(&argc, &argv);
error_code = MPI_Comm_size(MPI_COMM_WORLD, &NUMBER_OF_PROCESSES);
error_code = MPI_Comm_rank(MPI_COMM_WORLD, &PROCESS_ID);
if (error_code != 0) {
printf("Error initializing MPI and obtaining task information.\n");
MPI_Finalize();
exit(1);
}
if (DIMENSION != NUMBER_OF_PROCESSES) {
printf("Dimension of square matrix = %d\tNumber of processes = %d\n", DIMENSION, NUMBER_OF_PROCESSES);
printf("Number of processes does NOT equal dimension of square matrix. Please try again.\n");
MPI_Finalize();
exit(1);
}
srand(time(NULL));
/***************************************************************************************************/
int matrix[DIMENSION][DIMENSION];
int numbers[DIMENSION];
/***** Create a derived datatype that contains all of the elements in a column *****/
error_code = MPI_Type_vector(DIMENSION, 1, DIMENSION, MPI_INT, &column_type);
error_code = MPI_Type_commit(&column_type);
if (error_code != 0) {
printf("Error creating derived vector datatype.\n");
MPI_Finalize();
exit(1);
}
/****************************************************************************************************
** MASTER **
****************************************************************************************************/
if (PROCESS_ID == MASTER) {
int current_column,
current_row,
i,
destination, /* recipient of data */
source; /* sender of data */
unsigned char is_sorted; /* TRUE if matrix is sorted diagonally in ascending order */
printf("\n");
printf("Initializing matrix...\n");
printf("\n");
initialize(&matrix[0][0], DIMENSION, DIMENSION);
#ifdef DEBUG
/*************************************************************************************
** Note: Be sure that DIMENSION is not too large so that the matrix will be small **
** enough to be viewable. --BPD **
*************************************************************************************/
printf("======================================================================\n");
printf("== Initial matrix ==\n");
printf("======================================================================\n\n");
print_matrix(&matrix[0][0], DIMENSION, DIMENSION);
printf("\n");
#endif
printf("Sorting matrix...\n");
printf("\n");
start = time(NULL);
for (program_counter = 0; program_counter < (int) ceil(log((double) DIMENSION) / log(2.0)); program_counter++) {
printf(" Pass %d of %d...\n\n", program_counter + 1, (int) ceil((log((double) DIMENSION) / log(2.0))));
/****************************************************************************************************
** Send unsorted rows to workers, then receive sorted rows from them **
****************************************************************************************************/
printf(" Sending rows to workers... ");
for (destination = 1; destination < NUMBER_OF_PROCESSES; destination++) {
MPI_Send(&matrix[destination][0], DIMENSION, MPI_INT, destination, ROW_TAG, MPI_COMM_WORLD);
}
for (source = 1; source < NUMBER_OF_PROCESSES; source++) {
MPI_Recv(&matrix[source][0], DIMENSION, MPI_INT, source, ROW_TAG, MPI_COMM_WORLD, &status);
}
/***** Master sorts its row *****/
sort(&matrix[0][0], DIMENSION);
printf("Received sorted rows from workers.\n\n");
/****************************************************************************************************
** Send unsorted columns to workers, then receive sorted columns from them **
****************************************************************************************************/
printf(" Sending columns to workers... ");
for (destination = 1; destination < NUMBER_OF_PROCESSES; destination++) {
MPI_Send(&matrix[0][destination], 1, column_type, destination, COLUMN_TAG, MPI_COMM_WORLD);
}
for (source = 1; source < NUMBER_OF_PROCESSES; source++) {
MPI_Recv(&numbers, DIMENSION, MPI_INT, source, COLUMN_TAG, MPI_COMM_WORLD, &status);
for (i = 0; i < DIMENSION; i++) {
matrix[i][source] = numbers[i];
}
}
printf("Received sorted columns from workers.\n\n");
/***** Master sorts its column *****/
for (i = 0; i < DIMENSION; i++) {
numbers[i] = matrix[i][0];
}
sort(numbers, DIMENSION);
for (i = 0; i < DIMENSION; i++) {
matrix[i][0] = numbers[i];
}
}
/****************************************************************************************************
** For the last time, send unsorted rows to workers and then receive sorted rows from them **
****************************************************************************************************/
printf(" Sending rows to workers... ");
for (destination = 1; destination < NUMBER_OF_PROCESSES; destination++) {
MPI_Send(&matrix[destination][0], DIMENSION, MPI_INT, destination, ROW_TAG, MPI_COMM_WORLD);
}
for (source = 1; source < NUMBER_OF_PROCESSES; source++) {
MPI_Recv(&matrix[source][0], DIMENSION, MPI_INT, source, ROW_TAG, MPI_COMM_WORLD, &status);
}
printf("Received sorted rows from workers.\n\n");
/****************************************************************************************************
** Check if diagonals below and above the main diagonal are sorted in ascending order **
****************************************************************************************************/
printf("Checking if matrix is sorted... ");
for (i = 0, is_sorted = TRUE; i < DIMENSION - 1 && is_sorted == TRUE; i++) {
for (current_row = i, current_column = 0; current_row < DIMENSION - 1 && is_sorted == TRUE; current_row++, current_column++) {
if (matrix[current_row][current_column] > matrix[current_row + 1][current_column + 1]) {
is_sorted = FALSE;
}
}
}
for (i = 0; i < DIMENSION - 1 && is_sorted == TRUE; i++) {
for (current_row = 0, current_column = i; current_column < DIMENSION - 1 && is_sorted == TRUE; current_row++, current_column++) {
if (matrix[current_row][current_column] > matrix[current_row + 1][current_column + 1]) {
is_sorted = FALSE;
}
}
}
if (is_sorted == TRUE) {
printf("Matrix is sorted.\n\n");
printf("Printing results...\n\n");
}
else {
printf("Matrix is NOT sorted. Aborting...\n\n");
MPI_Finalize();
exit(1);
}
end = time(NULL);
}
/****************************************************************************************************
** WORKERS **
****************************************************************************************************/
else {
/****************************************************************************************************
** Get rows from Master, sort them, and then return them back to Master **
****************************************************************************************************/
for (program_counter = 0; program_counter < (int) ceil((log((double) DIMENSION) / log(2.0))); program_counter++) {
MPI_Recv(&numbers, DIMENSION, MPI_INT, MASTER, ROW_TAG, MPI_COMM_WORLD, &status);
/***** Sort even rows in ascending order and odd rows in descending order *****/
if (PROCESS_ID % 2 == 0) {
sort(numbers, DIMENSION);
}
else {
rsort(numbers, DIMENSION);
}
MPI_Send(&numbers, DIMENSION, MPI_INT, MASTER, ROW_TAG, MPI_COMM_WORLD);
/****************************************************************************************************
** Get columns from Master, sort them, and then return them back to Master **
****************************************************************************************************/
MPI_Recv(&numbers, DIMENSION, MPI_INT, MASTER, COLUMN_TAG, MPI_COMM_WORLD, &status);
sort(numbers, DIMENSION);
MPI_Send(&numbers, DIMENSION, MPI_INT, MASTER, COLUMN_TAG, MPI_COMM_WORLD);
}
/****************************************************************************************************
** For the last time, get rows from Master, sort them, and then return them back to Master **
****************************************************************************************************/
MPI_Recv(&numbers, DIMENSION, MPI_INT, MASTER, ROW_TAG, MPI_COMM_WORLD, &status);
sort(numbers, DIMENSION);
MPI_Send(&numbers, DIMENSION, MPI_INT, MASTER, ROW_TAG, MPI_COMM_WORLD);
}
/****************************************************************************************************
** Print results **
****************************************************************************************************/
if (PROCESS_ID == MASTER) {
#ifdef DEBUG
int current_column,
current_row,
i;
printf("======================================================================\n");
printf("== Diagonals ==\n");
printf("======================================================================\n\n");
printf("Below main diagonal in sorted matrix:\n\n");
for (i = 0; i < DIMENSION; i++) {
for (current_row = i, current_column = 0; current_row < DIMENSION; current_row++, current_column++) {
printf("%10d\t", matrix[current_row][current_column]);
}
printf("\n");
}
printf("\nAbove main diagonal in sorted matrix:\n\n");
for (i = 0; i < DIMENSION; i++) {
for (current_row = 0, current_column = i; current_column < DIMENSION; current_row++, current_column++) {
printf("%10d\t", matrix[current_row][current_column]);
}
printf("\n");
}
printf("\n");
printf("======================================================================\n");
printf("== Sorted matrix ==\n");
printf("======================================================================\n\n");
print_matrix(&matrix[0][0], DIMENSION, DIMENSION);
printf("\n");
#endif
printf("======================================================================\n");
printf("== Summary ==\n");
printf("======================================================================\n\n");
printf("Total number of processes: %10d\n\n", NUMBER_OF_PROCESSES);
printf("Dimension of square matrix: %10d\n", DIMENSION);
printf("Number of elements in matrix: %10d\n\n", DIMENSION * DIMENSION);
printf("Total runtime: %10.2f seconds\n\n", difftime(end, start));
}
MPI_Finalize();
return 0;
}
