软件开发训练 OJ 练习

Game 24点游戏算法

问题：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利

输入：4个1-10的数字。[数字允许重复，测试用例保证无异常数字]

输出：True or False

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
using namespace std;

void cal(double re[6], double a, double b) {
	re[0] = a + b;
	re[1] = a - b;
	re[2] = b - a;
	re[3] = a * b;
	re[4] = a * 1.0 / b;
	re[5] = b * 1.0 / a;
}

bool is24Points(double a, double b) {
	double re[6];
	cal(re, a, b);
	int i;
	for (i = 0; i < 6; ++i) {
		if (re[i] == 24) {
			return true;
		}
	}
	return false;
}

void calThree(double re[108], double a, double b, double c) {
	int i, j, k;
	k = 0;
	double fi[6];
	double tt[6];
	cal(fi, a, b);
	for (i = 0; i < 6; ++i) {
		cal(tt, fi[i], c);
		for (j = 0; j < 6; ++j) {
			re[k++] = tt[j];
		}
	}
	cal(fi, a, c);
	for (i = 0; i < 6; ++i) {
		cal(tt, fi[i], b);
		for (j = 0; j < 6; ++j) {
			re[k++] = tt[j];
		}
	}
	cal(fi, b, c);
	for (i = 0; i < 6; ++i) {
		cal(tt, fi[i], a);
		for (j = 0; j < 6; ++j) {
			re[k++] = tt[j];
		}
	}
}

bool Game24Points(int a, int b, int c, int d) {
	double re[108];
	int i;
	calThree(re, b, c, d);
	for (i = 0; i < 108; i++) {
		if (is24Points(re[i], a))
			return true;
	}
	calThree(re, a, c, d);
	for (i = 0; i < 108; i++) {
		if (is24Points(re[i], b))
			return true;
	}
	calThree(re, a, b, d);
	for (i = 0; i < 108; i++) {
		if (is24Points(re[i], c))
			return true;
	}
	calThree(re, a, b, c);
	for (i = 0; i < 108; i++) {
		if (is24Points(re[i], d))
			return true;
	}
	return false;
}

int main() {
	cout << Game24Points(1, 2, 3, 4) << endl;
	cout << Game24Points(7, 2, 1, 10) << endl;
	cout << Game24Points(7, 7, 7, 7) << endl;
	return 0;
}

周期串问题

问题：如果一个字符串可以由某个长度为k的字符串重复多次得到，我们说该串以k为周期。例如，abcabcabcabc以3为周期（注意，它也可以6和12为周期,结果取最小周期3）。字符串的长度小于等于100，由调用者保证。

接口： int GetMinPeriod(char *inputstring)

输入： char * inputstring 字符串

返回： int 字符串最小周期

int GetMinPeriod(char *inputstring) {
	/*在这里实现功能*/
	int i, j;
	int len = strlen(inputstring);
	int result = len;
	for (i = 1; i < len / 2 + 1; i++) {
		for (j = 0; j < len - i; j++) {
			if (inputstring[j] != inputstring[j + i])
				break;
		}
		if (j == len - i) {
			result = i;
			break;
		}
	}
	return result;
}

删除重复字符

问题：给定一个字符串，将字符串中所有和前面重复多余的字符删除，其余字符保留，输出处理后的字符串。需要保证字符出现的先后顺序，并且区分大小写。

接口：int GetResult(const char *input, char *output)

输入：input 输入字符串 输出：output 输出字符串

返回：0 成功 -1 失败及异常

#include <map>
#include <iostream>
using namespace std;

int GetResult(const char *input, char *output) {
	if (input == NULL || output == NULL)
		return -1;
	map<char, int> m;
	const char *p = input;
	while (*p) {
		m.insert(map<char, int>::value_type(*p, 0));
		p++;
	}
	p = input;
	char *p2 = output;
	while (*p) {
		m[*p]++;
		if (m[*p] == 1) {
			*p2++ = *p;
		}
		p++;
	}
	*p2 = '\0';
	return 0;
}

int main() {
	char *p = "aabbcdae";
	char *ou = (char *) malloc(1000);
	GetResult(p, ou);
	cout << ou << endl;
}

N皇后

问题：皇后是国际象棋中威力最大的棋子。在下面所示的棋盘上，皇后可以攻击位于箭头所覆盖位置的所有棋子。我们能不能把N个皇后放在棋盘(N×N)上，它们中的任何一个都无法攻击其余的皇后?请编写程序找出一共有几种方法。

接口：intPlaceQueenMethodNum(int
n);

输入：int
n 皇后的个数 返回：放置 n 皇后方案的个数

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

bool find(int row, int col, int *q) {
	int i = 1;
	while (i < row) {
		if (q[i] == col || abs(i - row) == abs(q[i] - col))
			return false;
		i++;
	}
	return true;
}

void place(int row, int n, int *q, int *re) {
	if (row > n) {
		(*re)++;
		return;
	}
	int col;
	for (col = 1; col <= n; col++) {
		if (find(row, col, q)) {
			q[row] = col;
			place(row + 1, n, q, re);
		}
	}
}

int PlaceQueenMethodNum(int n) {
	int re = 0;
	int q[20];
	place(1, n, q, &re);
	return re;
}

int main(){
	std::cout<<PlaceQueenMethodNum(8);
}

可怕的阶乘

问题：计算阶乘n!是一件可怕的事情，因为当n并不是很大时，n!将是一个很大的值。例如13! = 6227020800，已经超过了我们常用的unsigned int类型的取值范围。请设计一个程序，使其可以计算100以内的数的阶乘，结果用字符串的形式输出

接口：void CalcNN(int n, char *pOut)

输入：int n 需要输入的阶乘数

输出：char *pOut 结算结果，内存由调用者负责管理

#include <iostream>
using namespace std;
void CalcNN(int n, char *pOut) {
	int a[5000];
	memset(a, 0, sizeof(a));
	a[0] = 1;
	int i, j, k, len = 0;
	for (i = 1; i <= n; ++i) {
		for (j = 0; j <= len; ++j)
			a[j] *= i;
		for (j = 0; j <= len; ++j) {
			if (a[j] < 10)
				continue;
			k = j;
			while (k <= len) {
				if (a[len] > 9)
					++len;
				a[k + 1] += a[k] / 10;
				a[k] %= 10;
				++k;
			}
		}
	}
	char *p = pOut;
	for (i = len; i >= 0; --i) {
		*p++ = '0' + a[i];
	}
	*p = '\0';
	return;
}

int main() {
	char *p = (char *) malloc(1000);
	CalcNN(13, p);
	cout << p;
}