pr-meltout

level1/p01_runningLetter/runningLetter.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <windows.h>
+#include <string.h>
+
+#define MAXN 100
+#define EDGE 120
+#define SPEED 10
+
+void PrintStr(char s[], int x, int y)
+{
+	HANDLE hd;
+	COORD pos;
+	pos.X = x;
+	pos.Y = y;
+	hd = GetStdHandle(STD_OUTPUT_HANDLE);
+	SetConsoleCursorPosition(hd, pos);
+	printf("%s",s);
+}
+
+int main()
+{
+	char a[MAXN]="a";
+	int x = 1, y = 0, dir = 1, len = strlen(a);
+	PrintStr(a, 0, 0); Sleep(50);
+	while (1)
+	{
+		system("cls");
+		if (x == 0 || x == EDGE - len)
+		{
+			dir *= -1;
+			y++;
+		}
+		x += dir;
+		PrintStr(a, x, y);
+		Sleep(SPEED);
+	}
+	return 0;
+}

level1/p02_isPrime/isPrime.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <math.h>
+
+typedef long long ll;
+
+int isPrime(ll x)
+{
+    if(x==1)return 0;
+	ll sq = sqrt(x);
+	for (int i = 2; i <= sq; ++i)
+	{
+		if (x%i == 0)return 0;
+	}
+	return 1;
+}
+
+int main()
+{
+	ll num;
+	scanf("%I64d",&num);
+	if (isPrime(num))printf("a prime\n");
+	else printf("not a prime\n");
+	return 0;
+}

level1/p03_Diophantus/Diophantus.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+	for (int age = 0; age <= 200; ++age)
+	{
+		if (age % 12 == 0 && age % 7 == 0 && age - age / 6 - age / 12 - age / 7 - 5 - 4 == age / 2)
+		{
+			printf("age = %d\n", age - 4);
+			break;
+		}
+	}
+	return 0;
+}

level1/p04_ narcissus/narcissus.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+	int x, y, z;
+	for (int i = 100; i < 1000; ++i)
+	{
+		x = i / 100;
+		y = (i - i / 100 * 100) / 10;
+		z = i % 10;
+		if (pow(x, 3) + pow(y, 3) + pow(z, 3) == i)
+			printf("%d\n", i);
+	}
+	return 0;
+}

level1/p05_allPrimes/allPrimes.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <time.h>
+#define MAXN 1000
+
+int notprime[MAXN + 5], primes[MAXN + 5], len;
+
+void GetPrime()
+{
+	for (int i = 2; i <= MAXN; i++)
+	{
+		if (!notprime[i])
+		{
+			primes[len++] = i;
+			printf("%d\n", i);
+		}
+		for (int j = 0; j < len; j++)
+		{
+			if (i*primes[j] > MAXN) break;
+			notprime[i*primes[j]] = 1;
+			if (i%primes[j] == 0) break;
+		}
+	}
+}
+
+int main()
+{
+	clock_t StartTime, FinishTime;
+	StartTime = clock();
+	GetPrime();
+	FinishTime = clock();
+	printf("%.3lf seconds", (double)(FinishTime - StartTime) / CLOCKS_PER_SEC);
+	//system("pause");
+	return 0;
+}

level1/p06_Goldbach/Goldbach.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+
+#define MAXN 100
+
+int isprime[MAXN + 5], primes[MAXN + 5], len;
+
+void GetPrime()
+{
+	memset(isprime, 1, sizeof(isprime));
+	isprime[0] = isprime[1] = 0;
+	for (int i = 2; i <= MAXN; i++)
+	{
+		if (isprime[i])primes[len++] = i;
+		for (int j = 0; j < len; j++)
+		{
+			if (i*primes[j] > MAXN) break;
+			isprime[i*primes[j]] = 0;
+			if (i%primes[j] == 0) break;
+		}
+	}
+}
+
+int main()
+{
+	GetPrime();
+	int flag;
+	for (int i = 4; i <= 100; i += 2)
+	{
+		flag = 0;
+		for (int j = 0; j < len; ++j)
+		{
+			if (isprime[i - primes[j]])
+				flag = 1;
+		}
+		if (!flag)
+		{
+			printf("false\n");
+			return 0;
+		}
+	}
+	printf("true\n");
+	//system("pause");
+	return 0;
+}

level1/p07_encrypt_decrypt/encrypt_decrypt(rsa&xor).c

@@ -0,0 +1,130 @@
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define MINN 1000
+#define MAXN 10000
+
+typedef long long ll;
+
+ll n, p, q, e, d, x, y, phi, iv, cipher[MAXN];
+ll len, MesLen, primes[MAXN + 5], isprime[MAXN + 5];
+char Message[MAXN], DecMes[MAXN];
+
+int GetRand(int LowerBound, int UpperBound)
+{
+	return rand() % (UpperBound - LowerBound + 1) + LowerBound;
+}
+
+void GetPrime()
+{
+	memset(isprime, 1, sizeof(isprime));
+	isprime[0] = isprime[1] = 0;
+	for (int i = 2; i <= MAXN; i++)
+	{
+		if (isprime[i])primes[len++] = i;
+		for (int j = 0; j < len; j++)
+		{
+			if (i*primes[j] > MAXN) break;
+			isprime[i*primes[j]] = 0;
+			if (i%primes[j] == 0) break;
+		}
+	}
+}
+
+ll gcd(ll a, ll b)
+{
+	if (b == 0)return a;
+	return gcd(b, a%b);
+}
+
+ll pow_mod(ll a, ll b, ll mod)
+{
+	ll ans = 1;
+	while (b)
+	{
+		if (b & 1)ans = ans * a%mod;
+		a = a * a%mod; b >>= 1;
+	}
+	return ans;
+}
+
+ll exgcd(ll a, ll b)
+{
+	ll d = a, tmp;
+	if (b != 0)
+	{
+		tmp = x; x = y; y = tmp;
+		d = exgcd(b, a % b);
+		tmp = x; x = y; y = tmp;
+		y -= (a / b) * x;
+	}
+	else
+	{
+		x = 1; y = 0;
+	}
+	return d;
+}
+
+ll mod_inverse(ll a, ll mod)
+{
+	exgcd(a, mod);
+	return (mod + x % mod) % mod;
+}
+
+void init()
+{
+	srand(time(NULL));
+	iv = GetRand(0, 255);
+	GetPrime();
+	p = primes[GetRand(1000, len - 1)];
+	q = primes[GetRand(1000, len - 1)];
+	n = p * q;
+	phi = (p - 1)*(q - 1);
+	e = GetRand(10, phi - 1);
+	while (gcd(e, phi) != 1)
+		e = GetRand(10, phi - 1);
+	d = mod_inverse(e, phi);
+}
+
+ll RSA_enc(ll x)
+{
+	x = pow_mod(x, e, n);
+	return x;
+}
+
+ll RSA_dec(ll x)
+{
+	return (char)pow_mod(x, d, n);
+}
+
+void get_enc()
+{
+	cipher[0] = iv;
+	for (int i = 1; i <= MesLen; ++i)
+		cipher[i] = RSA_enc(cipher[i - 1] ^ (ll)Message[i - 1]);
+}
+
+void get_dec()
+{
+	cipher[0] = iv;
+	for (int i = 0; i < MesLen; ++i)
+		DecMes[i] = (char)RSA_dec(cipher[i + 1]) ^ cipher[i];
+}
+
+int main()
+{
+	init();
+	scanf("%s", Message);
+	MesLen = strlen(Message);
+	get_enc();
+	printf("cipher is : ");
+	for (int i = 1; i <= MesLen; ++i)
+		printf("%010I64d", cipher[i]);
+	printf("\n");
+	get_dec();
+	printf("Decrypted Message is : %s", DecMes);
+	return 0;
+}

level1/p07_encrypt_decrypt/encrypt_decrypt.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define MAXN 1000005
+
+int XorArray[MAXN], n;
+char Message[MAXN], Cipher[MAXN * 2], DecMess[MAXN];
+
+char ToHex(int _oct)
+{
+	if (_oct < 10)return _oct + '0';
+	else return _oct - 10 + 'a';
+}
+
+int ToOct(int _hex)
+{
+	if (_hex >= '0' && _hex <= '9')return _hex - '0';
+	else return _hex - 'a' + 10;
+}
+
+int GetRand(int LowerBound, int UpperBound)
+{
+	return rand() % (UpperBound - LowerBound + 1) + LowerBound;
+}
+
+void GenerateXorArray()
+{
+	n = GetRand(10, 100);
+	for (int i = 0; i < n; ++i)
+		XorArray[i] = GetRand(0, 255);
+}
+
+void Encrypt()
+{
+	int num, len = strlen(Message);
+	for (int i = 0; i < len; ++i)
+	{
+		num = (int)Message[i] ^ XorArray[i%n];
+		Cipher[i * 2] = ToHex(num / 16);
+		Cipher[i * 2 + 1] = ToHex(num % 16);
+	}
+}
+
+void Decrypt()
+{
+	int num, len = strlen(Cipher);
+	for (int i = 0; i < len; i += 2)
+	{
+		num = ToOct(Cipher[i]) * 16 + ToOct(Cipher[i + 1]);
+		DecMess[i / 2] = (char)(num^XorArray[(i / 2) % n]);
+	}
+}
+
+int main()
+{
+	srand(time(NULL));
+	GenerateXorArray();
+	scanf("%s", Message);
+	Encrypt();
+	printf("Cipher = %s\n", Cipher);
+	Decrypt();
+	printf("Decrypted Message = %s\n", DecMess);
+	return 0;
+}

level1/p08_hanoi/hanoi.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+
+void ChangePosition(int _res, char _from, char _trans, char _to)
+{
+	if (_res == 1)
+	{
+		printf("No.%d moved from %c to %c\n", _res, _from, _to);
+		return;
+	}
+	ChangePosition(_res - 1, _from, _to, _trans);
+	printf("No.%d moved from %c to %c\n", _res, _from, _to);
+	ChangePosition(_res - 1, _trans, _from, _to);
+}
+
+int main()
+{
+	int n;
+	scanf("%d", &n);
+	ChangePosition(n, 'A', 'B', 'C');
+	printf("Done\n");
+	return 0;
+}

level1/p09_maze/maze.c

@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include <conio.h>
+#include <time.h>
+
+#define MINN 10
+#define MAXN 30
+
+char Maze[MAXN][MAXN];
+int ToX[4] = { 0,0,1,-1 };
+int ToY[4] = { 1,-1,0,0 };
+int h, w, Vis[MAXN][MAXN];
+int DesX, DesY, NowX, NowY;
+
+int GetRand(int LowerBound, int UpperBound)
+{
+	return rand() % (UpperBound - LowerBound + 1) + LowerBound;
+}
+
+int Check(int x, int y)
+{
+	return Vis[x][y] == 0 && Maze[x][y] != '#';
+}
+
+int Dfs(int x, int y)
+{
+	if (!Check(x, y))return 0;
+	if (x == DesX && y == DesY)return 1;
+	Vis[x][y] = 1;
+	for (int i = 0; i < 4; ++i)
+	{
+		if (Dfs(x + ToX[i], y + ToY[i]))
+			return 1;
+	}
+	return 0;
+}
+
+void GenerateNewMaze()
+{
+	memset(Vis, 0, sizeof(Vis));
+	h = GetRand(MINN, MAXN);
+	w = GetRand(MINN, MAXN);
+	if (h > w) { int tmp = h; h = w; w = tmp; }
+	for (int i = 1; i <= h; ++i)
+	{
+		for (int j = 1; j <= w; ++j)
+		{
+			if (GetRand(0, 2) == 0)Maze[i][j] = '#';
+			else Maze[i][j] = ' ';
+		}
+	}
+	for(int i=0;i<=h+1;++i)Maze[i][0]=Maze[i][w+1]='#';
+	for(int i=0;i<=w+1;++i)Maze[0][i]=Maze[h+1][i]='#';
+	DesX = h; DesY = w;
+	NowX = 1; NowY = 1;
+	Maze[DesX][DesY] = 'T';
+	if (!Dfs(NowX, NowY))
+		GenerateNewMaze();
+}
+
+void PrintMaze()
+{
+	for (int i = 0; i <= h+1; ++i)
+	{
+		for (int j = 0; j <= w+1; ++j)
+		{
+			if (i == NowX && j == NowY)printf("S");
+			else printf("%c", Maze[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+int main()
+{
+	unsigned char ch;
+	srand(time(NULL));
+	GenerateNewMaze();
+	PrintMaze();
+	memset(Vis, 0, sizeof(Vis));
+	while (1)
+	{
+		if (_kbhit())
+		{
+			ch = _getch();
+			if(ch==224)ch=_getch();
+			if (ch == 72 && Check(NowX - 1, NowY))NowX--;
+			if (ch == 80 && Check(NowX + 1, NowY))NowX++;
+			if (ch == 75 && Check(NowX, NowY - 1))NowY--;
+			if (ch == 77 && Check(NowX, NowY + 1))NowY++;
+			system("cls"); PrintMaze();
+			if (NowX == DesX && NowY == DesY)break;
+		}
+	}
+	printf("Done\n");
+	return 0;
+}

level1/p10_pushBoxes/maps/1.txt

@@ -0,0 +1,23 @@
+19 25
+###########################
+#      # #    #   ####    #
+##  #   #    # #    #  #  #
+#  ##  ##   # # ## ##  ## #
+# # #                     #
+## #   ##     #   # # #   #
+##    # ##   #   #    ##  #
+#    # ##  # ### #  ##    #
+# ###  #    #       #   ###
+# ## #  ##     #       ## #
+#   #  #    #      #     ##
+# # ## ###  #    ##   # # #
+#  # ## ##O#   # #     #  #
+# #   # ###    # # ##   # #
+#  #  ###   #   ##o## # ###
+#    #  ####   #       # ##
+#         #               #
+#### ## # #       #  #   ##
+#     # #   #   # ##  ##  #
+#   #      # # ##   ##   ##
+###########################
+0

level1/p10_pushBoxes/maps/10.txt

@@ -0,0 +1,23 @@
+19 26
+############################
+#     ##  ##  #     ## #   #
+### #      #  #O   ##    # #
+#   ### # ####  #    # #   #
+## ##  ##       # ##      ##
+#  #          ##      ### ##
+##         #   #   # #    ##
+#  ###  #  #  #   #  #  #  #
+##  #      #     #   #   # #
+#   ### # o  ### #   #     #
+#   # # #   ## # #  ## # o #
+#      ##  # #     ##  #  ##
+# # #     ###  #  ###     ##
+##  # #    ##      #   #  ##
+##      # #   ####         #
+# ###  ########   ###   #  #
+#  ##O##   #####    #      #
+#   ## #  # #  #  ###    # #
+##   #     #  #  ## #  ##  #
+##      #   #  ## #####    #
+############################
+0

level1/p10_pushBoxes/maps/2.txt

@@ -0,0 +1,18 @@
+14 25
+###########################
+#        ##  #  #  #  #   #
+## # #      ##   # #  ##  #
+## #       ##     #  #### #
+#  #         # #     ##   #
+#  ###   #     ### #  #   #
+#       #             ##  #
+#   ###  ## # ## ##   #   #
+#   #  # #  #       o # ###
+#    #   #  #  #  #  #### #
+##O##  ##    # ##     #  ##
+#####  #  ###        ## # #
+#         #   #####  ###  #
+# # #      # #  #     # # #
+##    #  #   #     #  # ###
+######################## ##
+0

level1/p10_pushBoxes/maps/3.txt

@@ -0,0 +1,23 @@
+19 20
+######################
+#       # #  ##    # #
+#   # #  ##       ## #
+# #  # # #        # ##
+# #  # # ## ###     ##
+#     # # #        # #
+#  #  #   #  #    # ##
+#     ##      #   ## #
+##   ###   ###  ### ##
+# #     # ###    # ###
+# # ##      #  #   # #
+###  #o# #  # O# ##  #
+##                  ##
+# ##### ## ##     #  #
+#   ## # #   #  #### #
+##    #        ##  ###
+# #  #           #  ##
+##          #   #  ###
+# ##    #      ## #  #
+##     ##   #  ##  ###
+######################
+0

level1/p10_pushBoxes/maps/4.txt

@@ -0,0 +1,15 @@
+11 30
+################################
+#     # #   # ## ## # #  # ###O#
+####     O     ##         #  # #
+# ### ## #   #   ##  #         #
+#    # #   ##   ##   #### ##   #
+# ##  #      # #  #   #   ###  #
+# #   # ##          o     #  # #
+## ## ##    ###  #    ##  ## # #
+## ##  # ## ##    ###  ### #   #
+#    #      # # #  #      ##   #
+# #    ## o      #  ### #      #
+# # #      # ##   #      # #   #
+################################
+0

level1/p10_pushBoxes/maps/5.txt

@@ -0,0 +1,15 @@
+11 21
+#######################
+#  ##  ##  O#         #
+# # ##     #  #   # # #
+#    ##     # #    #  #
+#    #       #    ## ##
+#  #   #    # ### # # #
+###   ##   o        # #
+# #       #  #     #  #
+# #  ###       ##    ##
+##   ##        # # ## #
+## # ##               #
+#        # # #       ##
+#######################
+0

level1/p10_pushBoxes/maps/6.txt

@@ -0,0 +1,24 @@
+20 20
+######################
+#      #   # # #     #
+#      #  ####    ## #
+#   o# #  #  #    #  #
+#        #    #  #  ##
+#         ##  #    O #
+##     #          # ##
+#   #    ##   ## #  ##
+#   #      #### #    #
+#   #O#           #  #
+#  # ##   # ##    #  #
+## #  ###    #   ## ##
+# ##      #  # #    ##
+#    ## ##   #       #
+# # ##              ##
+#  # # #   ## ## #   #
+#      ##  ##        #
+#       ##  ###  ### #
+#           #  ##  # #
+##  o       ##  # # ##
+#  #####      # ## # #
+######################
+0

level1/p10_pushBoxes/maps/7.txt

@@ -0,0 +1,15 @@
+11 24
+##########################
+#    #    #      #   # # #
+###  ##            ## #  #
+# #o     # #     #   #   #
+#    #  # #     # # ##   #
+##       # #O  ##  ##  ###
+##       ###   ##    ##  #
+####     #    #       ####
+#       # ### ##       # #
+# o  #        # #  #   # #
+## ###     #           O #
+##         #   #       # #
+##########################
+0

level1/p10_pushBoxes/maps/8.txt

@@ -0,0 +1,17 @@
+13 30
+################################
+#      #      ## #   # ##  ##  #
+# # ###   # #       #      ##  #
+##  ##            ##    #      #
+#  #       # #O   #       #    #
+#  # ##  #    #    #    #   ## #
+##   #  #   # ###    ## ##     #
+## #   ###  ####  #  #  ### # ##
+#         #        ## ##  #    #
+#  # ##   #   # #             ##
+#    #       #  #  # ##       ##
+#    #  #       o #  # # ##    #
+##        # ##    #  #  ### #  #
+#   ######## # #  ## # ### #   #
+################################
+0

level1/p10_pushBoxes/maps/9.txt

@@ -0,0 +1,30 @@
+26 26
+############################
+# # #   ##      ##     # ###
+#  ##   #   #  ####  #  #  #
+#    #   # #  # ##   o   # #
+##  #   ## ##    #    ## ###
+#  #      # ##  #  #  #  # #
+#  # ####    # #  #      # #
+# #     ##        ##  # #  #
+#    # #          #     ## #
+#  # ##    #  ### ##### #  #
+#      ### # ##  #    # ## #
+##   #   ###  #   ##       #
+##     #   #  ###     ###  #
+##  #  ## # # #   #  # ## ##
+##    ## # #   #         # #
+##  ###  ###   ###  ### # ##
+##   #    ###  #O       # ##
+# ## ##     # #    # #    ##
+#  #      ##  # ##      ## #
+# # #      # ####    ###   #
+#      #   # ## #    ###   #
+#     #  ##  ### # ##  #  ##
+#  ## #####         # # #  #
+### #   ## #        #     ##
+# ##      # #            # #
+#      ##   #  #####  ######
+#     #  #    #  #     #####
+############################
+0

level1/p10_pushBoxes/pushBoxes.c

@@ -0,0 +1,173 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include <conio.h>
+
+#define MAXN 50
+#define CASES 10
+
+char Maze[MAXN][MAXN];
+int h, w, NowX, NowY, Score, Record;
+int AimNum, AimX[5], AimY[5];
+
+int CheckStatus(int x, int y)
+{
+	if (x < 0 || x > h + 1 || y < 0 || y > w + 1)return -1;
+	if (Maze[x][y] == '#')return 0;
+	if (Maze[x][y] == 'o')return 1;
+	else
+	{
+		for (int k = 1; k <= AimNum; ++k)
+		{
+			if (x == AimX[k] && y == AimY[k])
+				return 2;
+		}
+	}
+	return 3;
+}
+
+void PrintMaze(int _case)
+{
+	printf("Case#%d begins,your game record is %d\n", _case, Record);
+	for (int i = 0; i <= h + 1; ++i)
+	{
+		for (int j = 0; j <= w + 1; ++j)
+		{
+			if (i == NowX && j == NowY)printf("S");
+			else if (CheckStatus(i, j) == 2)printf("O");
+			else printf("%c", Maze[i][j]);
+		}
+		printf("\n");
+	}
+}
+
+int GameFin()
+{
+	for (int i = 1; i <= AimNum; ++i)
+	{
+		if (Maze[AimX[i]][AimY[i]] != 'o')
+			return 0;
+	}
+	return 1;
+}
+
+void ReadMapFromFile(int _case)
+{
+	FILE *fp;
+	unsigned char ch;
+	char FileName[20];
+	sprintf(FileName, ".\\maps\\%d.txt", _case);
+	fp = fopen(FileName, "r");
+	fscanf(fp, "%d %d%c", &h, &w, &ch);
+	for (int i = 0; i <= h + 1; ++i)
+	{
+		for (int j = 0; j <= w + 1; ++j)
+		{
+			fscanf(fp, "%c", &Maze[i][j]);
+			if (Maze[i][j] == 'O')
+			{
+				++AimNum;
+				AimX[AimNum] = i;
+				AimY[AimNum] = j;
+			}
+		}
+		fscanf(fp, "%c", &ch);
+	}
+	fscanf(fp, "%d", &Record);
+	fclose(fp);
+}
+
+void GetCopy(int _case)
+{
+	FILE *fp;
+	char FileName[20];
+	sprintf(FileName, ".\\maps\\%d.swp", _case);
+	fp = fopen(FileName, "w");
+	fprintf(fp, "%d %d\n", h, w);
+	for (int i = 0; i <= h + 1; ++i)
+		fprintf(fp, "%s\n", Maze[i]);
+	fclose(fp);
+}
+
+void AddScore(int _case, int _score)
+{
+	FILE *fp;
+	char FileName_1[20], FileName_2[20];
+	sprintf(FileName_1, ".\\maps\\%d.txt", _case);
+	sprintf(FileName_2, ".\\maps\\%d.swp", _case);
+	fp = fopen(FileName_2, "a+");
+	fprintf(fp, "%d", _score);
+	fclose(fp);
+	remove(FileName_1);
+	rename(FileName_2, FileName_1);
+}
+
+int MoveCharacter(int tx, int ty)
+{
+	int flag[2];
+	flag[0] = CheckStatus(NowX + tx, NowY + ty);
+	flag[1] = CheckStatus(NowX + tx * 2, NowY + ty * 2);
+	if (flag[0] == 1 && flag[1] >= 2)
+	{
+		Maze[NowX + tx][NowY + ty] = ' ';
+		Maze[NowX + tx * 2][NowY + ty * 2] = 'o';
+		NowX += tx; NowY += ty;
+		Score--;
+	}
+	else if (flag[0] >= 2)
+	{
+		NowX += tx;
+		NowY += ty;
+		Score--;
+	}
+	else return 1;
+	return 0;
+}
+
+int main()
+{
+	unsigned char ch;
+	int tx, ty, Score;
+	for (int i = 1; i <= CASES; ++i)
+	{
+		NowX = NowY = 1;
+		Score = 300; AimNum = 0;
+		ReadMapFromFile(i);
+		GetCopy(i);
+		PrintMaze(i);
+		while (1)
+		{
+			if (_kbhit())
+			{
+				ch = _getch();
+				if (ch == 224)ch = _getch();
+				if (ch == 80) { tx = 1; ty = 0; }
+				if (ch == 77) { tx = 0; ty = 1; }
+				if (ch == 72) { tx = -1; ty = 0; }
+				if (ch == 75) { tx = 0; ty = -1; }
+				if (ch == 27)
+				{
+					AddScore(i, Record);
+					return 0;
+				}
+				if (MoveCharacter(tx, ty))continue;
+				system("cls");
+				PrintMaze(i);
+				if (GameFin())break;
+			}
+		}
+		printf("Case#%d Done,your score is %d.\n", i, Score);
+		AddScore(i, max(Record, Score));
+		while (1)
+		{
+			if (_kbhit())
+			{
+				system("cls");
+				ch = _getch();
+				break;
+			}
+		}
+	}
+	return 0;
+}

level1/p11_linkedList/LinkedList.c

@@ -0,0 +1,105 @@
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+
+#define MAXN 20
+#define MAXNUM 10
+#define LEN sizeof(struct LinkNode)
+
+struct LinkNode
+{
+	int Value;
+	struct LinkNode *Nxt;
+}*Head, *Tail;
+
+void AddNode(int _val)
+{
+	struct LinkNode *_newnode;
+	_newnode = (struct LinkNode *)malloc(LEN);
+	_newnode->Value = _val;
+	_newnode->Nxt = NULL;
+	Tail->Nxt = _newnode;
+	Tail = _newnode;
+}
+
+void Traversal()//2
+{
+	struct LinkNode *Now = Head;
+	while (Now != NULL)
+	{
+		printf("%d ", Now->Value);
+		Now = Now->Nxt;
+	}
+	printf("\n");
+}
+
+void RevNode(struct LinkNode *Now)//3
+{
+	if (Now->Nxt != NULL)
+	{
+		RevNode(Now->Nxt);
+		Now->Nxt->Nxt = Now;
+	}
+	else Head = Now;
+}
+
+void Reverse()//3
+{
+	Tail = Head;
+	RevNode(Head);
+	Tail->Nxt = NULL;
+}
+
+int FindNode(int _val, int _t)//4
+{
+	int id = 0;
+	struct LinkNode *Now = Head;
+	while (Now != NULL)
+	{
+		if (Now->Value == _val)_t--;
+		if (!_t)return id;
+		Now = Now->Nxt; id++;
+	}
+	return -1;
+}
+
+int GetRand(int LowerBound, int UpperBound)
+{
+	return rand() % (UpperBound - LowerBound + 1) + LowerBound;
+}
+
+int GetRandNum()
+{
+	if (GetRand(1, 4) == 1)return 5;
+	return GetRand(1, MAXNUM);
+}
+
+void init()
+{
+	Head = Tail = NULL;
+	srand(time(NULL));
+	int n = GetRand(5, MAXN);
+	for (int i = 0; i < n; ++i)
+	{
+		if (!i)
+		{
+			Head = Tail = (struct LinkNode *)malloc(LEN);
+			Head->Nxt = NULL;
+			Head->Value = GetRandNum();
+		}
+		else AddNode(GetRandNum());
+	}
+}
+
+int main()
+{
+	init();
+	printf("The list is:\n");
+	Traversal();
+	Reverse();
+	printf("The reversed list is:\n");
+	Traversal();
+	printf("The serial number of the first node that has a value of 5 is %d(reversed)\n", FindNode(5, 1));
+	printf("The serial number of the second node that has a value of 5 is %d(reversed)\n", FindNode(5, 2));
+	return 0;
+}

level1/p12_warehouse/warehouse.c

@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include <windows.h>
+#include <conio.h>
+
+#define MAXN 10000
+
+char Message[11][50] = { "please input the type of goods\n","please input the quantity of goods\n","invalid input,please try again",\
+"Please choose:\n","1:Display the inventory list\n","2:Inbound\n","3:Outbound\n","4:Exit\n","done\n","No goods\n","input any key to continue\n" };
+char FileName_1[10] = "list.txt", FileName_2[10] = "list.swp";
+
+struct goods
+{
+	int Quantity;
+	char Type[50];
+}Goods[MAXN + 5];
+
+int TypeNum, OutNum;
+
+void Refresh()
+{
+	while (1)
+	{
+		if (_kbhit())
+		{
+			_getch();
+			break;
+		}
+	}
+}
+
+void ReadFromFile()
+{
+	FILE *fp;
+	fp = fopen(FileName_1, "at+");
+	fscanf(fp, "%d", &TypeNum);
+	for (int i = 0; i < TypeNum; ++i)
+		fscanf(fp, "%s%d", Goods[i].Type, &Goods[i].Quantity);
+	fclose(fp);
+}
+
+void PrintToFile()
+{
+	FILE *fp;
+	fp = fopen(FileName_2, "w");
+	fprintf(fp, "%d\n", TypeNum - OutNum);
+	for (int i = 0; i < TypeNum; ++i)
+	{
+		if (Goods[i].Quantity > 0)
+			fprintf(fp, "%s %d\n", Goods[i].Type, Goods[i].Quantity);
+	}
+	fclose(fp);
+	remove(FileName_1);
+	rename(FileName_2, FileName_1);
+}
+
+void DisplayList()
+{
+	if (TypeNum == 0)
+		printf("%s", Message[9]);
+	for (int i = 0; i < TypeNum; ++i)
+	{
+		if (Goods[i].Quantity > 0)
+			printf("%s:%d\n", Goods[i].Type, Goods[i].Quantity);
+	}
+	printf("%s", Message[10]);
+}
+
+void Inbound()
+{
+	int _num;
+	char _type[50];
+	system("cls");
+	printf("%s", Message[0]);
+	scanf("%s", _type);
+	printf("%s", Message[1]);
+	scanf("%d", &_num);
+	for (int i = 0; i < TypeNum; ++i)
+	{
+		if (strcmp(Goods[i].Type, _type) == 0)
+		{
+			Goods[i].Quantity += _num;
+			return;
+		}
+	}
+	strcpy(Goods[TypeNum].Type, _type);
+	Goods[TypeNum].Quantity = _num;
+	TypeNum++;
+	printf("%s", Message[8]);
+	printf("%s", Message[10]);
+}
+
+
+void Outbound()
+{
+	int _num;
+	char _type[50];
+	system("cls");
+	printf("%s", Message[0]);
+	scanf("%s", _type);
+	printf("%s", Message[1]);
+	scanf("%d", &_num);
+	for (int i = 0; i < TypeNum; ++i)
+	{
+		if (strcmp(Goods[i].Type, _type) == 0 && Goods[i].Quantity >= _num)
+		{
+			Goods[i].Quantity -= _num;
+			if (Goods[i].Quantity == 0)OutNum++;
+			printf("%s", Message[8]);
+			printf("%s", Message[10]);
+			return;
+		}
+	}
+	printf("%s", Message[2]);
+	printf("%s", Message[10]);
+}
+
+void Menu()
+{
+	unsigned char ch;
+	do
+	{
+		system("cls");
+		printf("%s", Message[3]);
+		printf("%s", Message[4]);
+		printf("%s", Message[5]);
+		printf("%s", Message[6]);
+		printf("%s", Message[7]);
+		while (1)
+		{
+			if (_kbhit())
+			{
+				ch = _getch();
+				switch (ch)
+				{
+				case '1':
+					DisplayList();
+					break;
+				case '2':
+					Inbound();
+					break;
+				case '3':
+					Outbound();
+					break;
+				case '4':
+					PrintToFile();
+					return;
+				default:
+					printf("%s", Message[2]);
+				}
+				Refresh();
+				break;
+			}
+		}
+	} while (1);
+}
+
+int main()
+{
+	ReadFromFile();
+	Menu();
+	return 0;
+}