#include <stdio.h>

typedef unsigned char *byte_pointer;

void show_bytes(byte_pointer start, size_t len)
{
truesize_t i;
truefor(i=0; i<len; i++){
truetrueprintf("%.2x", start[i]);
true}
trueprintf("\n");
}

int main()
{
trueint i = 1;
trueshow_bytes((byte_pointer)&i, sizeof(int));    
}

// 先取数据地址，转换成单字节长度的类型（unsigned char）的指针，
// 然后按照十六进制逐字节打印即可，格式为“%.2x”。
printf("%.2x ", *(unsigned char*)(str + i));

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int utf8len(char* str)
{
//      unsigned char c1 = 1 << 7;
        unsigned char c2 = 1 << 6;
        unsigned char c3 = 7 << 4;
        unsigned char c4 = 15 << 3;
        int i = 0;
        int num = 0;
        for(i = 0; i < strlen(str); i++) {
                unsigned char byte = *(unsigned char*)(str + i);
                if(byte <= 0x7F) {
                        // 0xxx xxxx
                        num++;
                } else if ((byte & c2) == 0x40) {
                        // 110x xxxx  xxxx xxxx
                        num++;
                        i++;
                } else if ((byte & c3) == 0x60) {
                        // 1110 xxxx  xxxx xxxx  xxxx xxxx
                        num++;
                        i += 2;
                } else if ((byte & c4) == 0x70) {
                        // 1111 0xxx  xxxx xxxx  xxxx xxxx  xxxx xxxx
                        num++;
                        i += 3;
                }
        }
        return num;
}

int main()
{
        char *str = (char*)malloc(sizeof(char)*100);
        scanf("%s", str);
        int i = 0;
        for(i = 0; i < strlen(str); i++) {
                printf("%.2x ", *(unsigned char*)(str + i));
        }
        printf("\n");
        int len = utf8len(str);
        printf("The number of characters is %d\n", len);
        free(str);
        return 0;
}

int __cdecl strcmp (const char * src, const char * dst)
{
    int ret = 0 ;
    while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
                ++src, ++dst;  
    if ( ret < 0 )
           ret = -1 ;
    else if ( ret > 0 )
           ret = 1 ;
    return( ret );
}

#include <stdio.h>
#include <string.h>
#include <assert.h>

int main()
{
        char str[100];
        scanf("%s", str);
        int i;
        int res = 0;
        for(i = 0; i < strlen(str); i++) {
                res = res * 10 + (str[i] - '0');
        }
        printf("int: %d\n", res);
        assert(res == atoi(str));
        return 0;
}


#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <float.h>
#include <math.h>
#include <stdlib.h>

int main()
{
        char str[100];
        scanf("%s", str);
        int i;
        int len = strlen(str);
        double res = 0;
        for(i = 0; i < len && str[i] != '.'; i++) {
                res = res * 10 + (str[i] - '0');
        }
        double t = 10;
        for(i = i+1; i < len; i++,t*=10) {
                res += (str[i] - '0') / t;
        }
        printf("double: %lf\n", res);
        double atod = atof(str);
        assert(fabs(res - atod) <= 1e-5);
        return 0;
}

#include <stdio.h>
#include <string.h>

char *  itoa ( int value, char * str, int base );

int main()
{
        int i;
        char c[100];
        c[99] = '\0';
        int num = 98;
        scanf("%d", &i);
        while(i != 0) {
                c[num--] = i % 10 + '0';
                i /= 10;
        }
        printf("%s\n", &c[num+1]);
        return 0;
}

#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

char * itoa(int value, char * str, int base);

int main()
{
        double d;
        char c[100];
        c[99] = '\0';
        int num = 98;
        int time = 0;
        scanf("%lf", &d);
        while(fabs((double)((long long)(d*10)/10) - d) > DBL_EPSILON) {
                // still have .
                d *= 10;
                time++;
        }
        long long l = (long long) d;
        while(l != 0) {
                c[num--] = l % 10 + '0';
                time--;
                if(time == 0) {
                        c[num--] = '.';
                        time--;
                }
                l /= 10;
        }
        printf("%s\n", &c[num+1]);
        return 0;
}

if(fabs(f1 - f2) <= 1e-6) {  //equal
    ...
}
// 或者使用 float.h 中的 FLT_ESPILON(1.1920929e-7) | DBL_EPSILON(2.22045e-16)

int func4(int n) 
{
    if(n == 0) {
        return 0;
    } else if(n == 1) {
        return 输入的第二个数字
    } else {
        int res1 = func(n-1);
        int res2 = func(n-2);
        return res1 + res2 + 输入的第二个数字
    }
}

for(int i = 0; i < 6; i++) {
    if(input[i] - 1 > 5) return;
    for(int j = i+1; j < 6; j++) {
        if(input[i] == input[j]) return;
    }
}

char orEYJGWrtE[256];
void do_phase(){
        const char cookie[] = PHASE3_COOKIE;
        for( int i=0; i<sizeof(cookie)-1; i++ )
                printf( "%c", orEYJGWrtE[ (unsigned char)(cookie[i]) ] );
        printf( "\n" );
}

void do_phase()
{
        const char cookie[] = PHASE4_COOKIE;
        char c;
        for ( int i = 0; i < sizeof(cookie)-1; i++ ) 
       {
                c = cookie[i];
                switch (c) 
                {
                      // 映射关系
                      case ‘A’: { c = 48; break; } 
                      case ‘B’: { c = 121; break; }
                        …
                      case ‘Z’: { c = 93; break; }
                }
               printf("%c", c);
        }
}

/* 
 * cachelab.h - Prototypes for Cache Lab helper functions
 */

#ifndef CACHELAB_TOOLS_H
#define CACHELAB_TOOLS_H

#define MAX_TRANS_FUNCS 100

typedef struct trans_func{
  void (*func_ptr)(int M,int N,int[N][M],int[M][N]);
  char* description;
  char correct;
  unsigned int num_hits;
  unsigned int num_misses;
  unsigned int num_evictions;
} trans_func_t;

/* 
 * printSummary - This function provides a standard way for your cache
 * simulator * to display its final hit and miss statistics
 */ 
void printSummary(int hits,  /* number of  hits */
                  int misses, /* number of misses */
                  int evictions); /* number of evictions */

/* Fill the matrix with data */
void initMatrix(int M, int N, int A[N][M], int B[M][N]);

/* The baseline trans function that produces correct results. */
void correctTrans(int M, int N, int A[N][M], int B[M][N]);

/* Add the given function to the function list */
void registerTransFunction(
    void (*trans)(int M,int N,int[N][M],int[M][N]), char* desc);

#endif /* CACHELAB_TOOLS_H */

/*
 * cachelab.c - Cache Lab helper functions
 */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "cachelab.h"
#include <time.h>

trans_func_t func_list[MAX_TRANS_FUNCS];
int func_counter = 0; 

/* 
 * printSummary - Summarize the cache simulation statistics. Student cache simulators
 *                must call this function in order to be properly autograded. 
 */
void printSummary(int hits, int misses, int evictions)
{
    printf("hits:%d misses:%d evictions:%d\n", hits, misses, evictions);
    FILE* output_fp = fopen(".csim_results", "w");
    assert(output_fp);
    fprintf(output_fp, "%d %d %d\n", hits, misses, evictions);
    fclose(output_fp);
}

/* 
 * initMatrix - Initialize the given matrix 
 */
void initMatrix(int M, int N, int A[N][M], int B[M][N])
{
    int i, j;
    srand(time(NULL));
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            // A[i][j] = i+j;  /* The matrix created this way is symmetric */
            A[i][j]=rand();
            B[j][i]=rand();
        }
    }
}

void randMatrix(int M, int N, int A[N][M]) {
    int i, j;
    srand(time(NULL));
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            // A[i][j] = i+j;  /* The matrix created this way is symmetric */
            A[i][j]=rand();
        }
    }
}

/* 
 * correctTrans - baseline transpose function used to evaluate correctness 
 */
void correctTrans(int M, int N, int A[N][M], int B[M][N])
{
    int i, j, tmp;
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            tmp = A[i][j];
            B[j][i] = tmp;
        }
    }    
}



/* 
 * registerTransFunction - Add the given trans function into your list
 *     of functions to be tested
 */
void registerTransFunction(void (*trans)(int M, int N, int[N][M], int[M][N]), 
                           char* desc)
{
    func_list[func_counter].func_ptr = trans;
    func_list[func_counter].description = desc;
    func_list[func_counter].correct = 0;
    func_list[func_counter].num_hits = 0;
    func_list[func_counter].num_misses = 0;
    func_list[func_counter].num_evictions =0;
    func_counter++;
}

#include <getopt.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <assert.h>
#include <math.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include "cachelab.h"

//#define DEBUG_ON 
#define ADDRESS_LENGTH 64

/* Type: Memory address */
typedef unsigned long long int mem_addr_t;

/* Type: Cache line
   LRU is a counter used to implement LRU replacement policy  */
typedef struct cache_line {
    char valid;
    mem_addr_t tag;
    unsigned long long int lru;
} cache_line_t;

typedef cache_line_t* cache_set_t;
typedef cache_set_t* cache_t;

/* Globals set by command line args */
int verbosity = 0; /* print trace if set */
int s = 0; /* set index bits */
int b = 0; /* block offset bits */
int E = 0; /* associativity */
char* trace_file = NULL;

/* Derived from command line args */
int S; /* number of sets */
int B; /* block size (bytes) */

/* Counters used to record cache statistics */
int miss_count = 0;
int hit_count = 0;
int eviction_count = 0;
unsigned long long int lru_counter = 1;

/* The cache we are simulating */
cache_t cache;  
mem_addr_t set_index_mask;//用于从内存地址得到缓存组的索引值

/* 
 * initCache - Allocate memory, write 0's for valid and tag and LRU
 * also computes the set_index_mask
 */
void initCache()
{
truecache = (cache_t) malloc (sizeof(cache_set_t) * S);
trueint i;
truefor (i = 0; i < S; i++) {
truetruecache[i] = (cache_set_t) malloc (sizeof(cache_line_t) * E);
truetruememset (cache[i], 0, sizeof(cache_line_t) * E);
true}
trueset_index_mask = (mem_addr_t) (pow(2, s) - 1);
}


/* 
 * freeCache - free allocated memory
 */
void freeCache()
{
trueint i;
truefor (i = 0; i < S; i++) {
truetruefree (cache[i]);
true}
truefree (cache);
}


/* 
 * accessData - Access data at memory address addr.
 *   If it is already in cache, increase hit_count
 *   If it is not in cache, bring it in cache, increase miss count.
 *   Also increase eviction_count if a line is evicted.
 */
void accessData(mem_addr_t addr)
{
truemem_addr_t set_index = (addr >> b) & set_index_mask;
truemem_addr_t tag = addr >> (s+b);
truecache_set_t set = cache[set_index];
trueunsigned long long int eviction_lru = ULLONG_MAX;
trueint eviction_line = 0;
trueint i;
truefor (i = 0; i < E; i++) {
truetrueif (set[i].valid == 1 && set[i].tag == tag) {
truetruetrueset[i].lru = lru_counter++;
truetruetruehit_count++;
truetruetrueprintf("hit ");
truetruetruereturn;
truetrue}
true}
truemiss_count++;
trueprintf("miss ");
truefor (i = 0; i < E; i++) {
truetrueif (set[i].valid == 0) {
truetruetrueset[i].valid = 1;
truetruetrueset[i].tag = tag;
truetruetrueset[i].lru = lru_counter++;
truetruetruereturn;
truetrue} else if (set[i].lru < eviction_lru) {
truetruetrueeviction_lru = set[i].lru;
truetruetrueeviction_line = i;
truetrue}
true}
trueeviction_count++;
trueprintf("eviction ");
trueset[eviction_line].valid = 1;
trueset[eviction_line].tag = tag;
trueset[eviction_line].lru = lru_counter++;
}


/*
 * replayTrace - replays the given trace file against the cache 
 */
void replayTrace(char* trace_fn)
{
    char buf[1000];
    mem_addr_t addr=0;
    unsigned int len=0;
    FILE* trace_fp = fopen(trace_fn, "r");

    if(!trace_fp){
        fprintf(stderr, "%s: %s\n", trace_fn, strerror(errno));
        exit(1);
    }

    while( fgets(buf, 1000, trace_fp) != NULL) {
        if(buf[1]=='S' || buf[1]=='L' || buf[1]=='M') {
            sscanf(buf+3, "%llx,%u", &addr, &len);
      
            if(verbosity)
                printf("%c %llx,%u ", buf[1], addr, len);

            accessData(addr);

            /* If the instruction is R/W then access again */
            if(buf[1]=='M')
                accessData(addr);
            
            if (verbosity)
                printf("\n");
        }
    }

    fclose(trace_fp);
}

/*
 * printUsage - Print usage info
 */
void printUsage(char* argv[])
{
    printf("Usage: %s [-hv] -s <num> -E <num> -b <num> -t <file>\n", argv[0]);
    printf("Options:\n");
    printf("  -h         Print this help message.\n");
    printf("  -v         Optional verbose flag.\n");
    printf("  -s <num>   Number of set index bits.\n");
    printf("  -E <num>   Number of lines per set.\n");
    printf("  -b <num>   Number of block offset bits.\n");
    printf("  -t <file>  Trace file.\n");
    printf("\nExamples:\n");
    printf("  linux>  %s -s 4 -E 1 -b 4 -t traces/yi.trace\n", argv[0]);
    printf("  linux>  %s -v -s 8 -E 2 -b 4 -t traces/yi.trace\n", argv[0]);
    exit(0);
}

/*
 * main - Main routine 
 */
int main(int argc, char* argv[])
{
    char c;

    while( (c=getopt(argc,argv,"s:E:b:t:vh")) != -1){
        switch(c){
        case 's':
            s = atoi(optarg);
            break;
        case 'E':
            E = atoi(optarg);
            break;
        case 'b':
            b = atoi(optarg);
            break;
        case 't':
            trace_file = optarg;
            break;
        case 'v':
            verbosity = 1;
            break;
        case 'h':
            printUsage(argv);
            exit(0);
        default:
            printUsage(argv);
            exit(1);
        }
    }

    /* Make sure that all required command line args were specified */
    if (s == 0 || E == 0 || b == 0 || trace_file == NULL) {
        printf("%s: Missing required command line argument\n", argv[0]);
        printUsage(argv);
        exit(1);
    }

    /* Compute S, E and B from command line args */
    S = 1 << s;
trueB = 1 << b;
 
    /* Initialize cache */
    initCache();

#ifdef DEBUG_ON
    printf("DEBUG: S:%u E:%u B:%u trace:%s\n", S, E, B, trace_file);
    printf("DEBUG: set_index_mask: %llu\n", set_index_mask);
#endif
 
    replayTrace(trace_file);

    /* Free allocated memory */
    freeCache();

    /* Output the hit and miss statistics for the autograder */
    printSummary(hit_count, miss_count, eviction_count);
    return 0;
}

for (i = 0; i < N; i += 8) {
    for (j = 0; j < M; j += 8) {
        for (k = i; k < i + 4; k++) {
            a0 = A[k][j];
            a1 = A[k][j + 1];
            a2 = A[k][j + 2];
            a3 = A[k][j + 3];
            a4 = A[k][j + 4];
            a5 = A[k][j + 5];
            a6 = A[k][j + 6];
            a7 = A[k][j + 7];

            B[j][k] = a0;
            B[j + 1][k] = a1;
            B[j + 2][k] = a2;
            B[j + 3][k] = a3;

            B[j][k + 4] = a4;
            B[j + 1][k + 4] = a5;
            B[j + 2][k + 4] = a6;
            B[j + 3][k + 4] = a7;
        }
        for (l = j + 4; l < j + 8; l++) {

            a4 = A[i + 4][l - 4]; // A left-down col
            a5 = A[i + 5][l - 4];
            a6 = A[i + 6][l - 4];
            a7 = A[i + 7][l - 4];

            a0 = B[l - 4][i + 4]; // B right-above line
            a1 = B[l - 4][i + 5];
            a2 = B[l - 4][i + 6];
            a3 = B[l - 4][i + 7];

            B[l - 4][i + 4] = a4; // set B right-above line 
            B[l - 4][i + 5] = a5;
            B[l - 4][i + 6] = a6;
            B[l - 4][i + 7] = a7;

            B[l][i] = a0;         // set B left-down col
            B[l][i + 1] = a1;
            B[l][i + 2] = a2;
            B[l][i + 3] = a3;

            B[l][i + 4] = A[i + 4][l];
            B[l][i + 5] = A[i + 5][l];
            B[l][i + 6] = A[i + 6][l];
            B[l][i + 7] = A[i + 7][l];
        }
    }
}

void transpose_submit(int M, int N, int A[N][M], int B[M][N])
{
    int value0, value1, value2, value3, value4, value5, value6, value7;
    for (int i = 0; i < N; i += 8) {
        for (int j = 0; j < M; j += 8) {
            for (int k = i; k < i + 4; k++) {
                value0 = A[k][j];
                value1 = A[k][j+1];
                value2 = A[k][j+2];
                value3 = A[k][j+3];
                value4 = A[k][j+4];
                value5 = A[k][j+5];
                value6 = A[k][j+6];
                value7 = A[k][j+7];

                // a
                B[j][k] = value0;
                B[j+1][k] = value1;
                B[j+2][k] = value2;
                B[j+3][k] = value3;

                // b 逆序放置
                B[j+0][k+4] = value7;
                B[j+1][k+4] = value6;
                B[j+2][k+4] = value5;
                B[j+3][k+4] = value4;
            }
            for (int h = 0; h < 4; h++) {
                value0 = A[i+4][j+3-h];
                value1 = A[i+5][j+3-h];
                value2 = A[i+6][j+3-h];
                value3 = A[i+7][j+3-h];
                value4 = A[i+4][j+4+h];
                value5 = A[i+5][j+4+h];
                value6 = A[i+6][j+4+h];
                value7 = A[i+7][j+4+h];

                // b'到c'(左下角)
                B[j+4+h][i+0] = B[j+3-h][i+4];
                B[j+4+h][i+1] = B[j+3-h][i+5];
                B[j+4+h][i+2] = B[j+3-h][i+6];
                B[j+4+h][i+3] = B[j+3-h][i+7];

                // 存放c, d
                B[j+3-h][i+4] = value0;
                B[j+3-h][i+5] = value1;
                B[j+3-h][i+6] = value2;
                B[j+3-h][i+7] = value3;
                B[j+4+h][i+4] = value4;
                B[j+4+h][i+5] = value5;
                B[j+4+h][i+6] = value6;
                B[j+4+h][i+7] = value7;
            }
        }
    }
}

void transpose_submit(int M, int N, int A[N][M], int B[M][N])
{
    int i, j, k, a, b, c, d, e, f, g, h;

    // 48 * 48
    for (i = 0; i+16 < N; i += 16) {
        for (j = 0; j+16 < M; j+=16) {
            for (k = i; k < i+16; k++) {
                a = A[k][j];
                b = A[k][j+1];
                c = A[k][j+2];
                d = A[k][j+3];
                e = A[k][j+4];
                f = A[k][j+5];
                g = A[k][j+6];
                h = A[k][j+7];

                B[j+0][k] = a;
                B[j+1][k] = b;
                B[j+2][k] = c;
                B[j+3][k] = d;
                B[j+4][k] = e;
                B[j+5][k] = f;
                B[j+6][k] = g;
                B[j+7][k] = h;

                a = A[k][j+8];
                b = A[k][j+9];
                c = A[k][j+10];
                d = A[k][j+11];
                e = A[k][j+12];
                f = A[k][j+13];
                g = A[k][j+14];
                h = A[k][j+15];
                B[j+8][k] = a;
                B[j+9][k] = b;
                B[j+10][k] = c;
                B[j+11][k] = d;
                B[j+12][k] = e;
                B[j+13][k] = f;
                B[j+14][k] = g;
                B[j+15][k] = h;

            }
        }
    }

    // 处理不规则的部分
    for (k = i; k < N; k++) {
        for (h = 0; h < M; h++){
            B[h][k] = A[k][h];
        }
    }
    for (k = 0; k < i; k++) {
        for (h = j; h < M; h++) {
            B[h][k] = A[k][h];
        }
    }
}