2021年07月13日 函数习题

1、编写两个函数，分别求最大公约数（greatest common divisor）和最小公倍数（least common multiple）。

public class GCD_LCM {
	public static void main(String[] args) {
		int a = 12, b = 10;

		a = 4;
		b = 2;
		int gcd = getGCD(a, b);
		System.out.println(a + "和" + b + "的最大公约数为：" + gcd);
		System.out.println(a + "和" + b + "的最小公倍数为：" + lcm(a, b, gcd));
	}

	/**
	 * 辗转相除法求最大公约数入口
	 * 
	 * @param a 一个整数
	 * @param b 另一个整数
	 * @return 整数a和整数b的最大公约数
	 */
	private static int getGCD(int a, int b) {
		if (a > b) {
			return gcd(a, b);
		} else {
			return gcd(b, a);
		}
	}

	/**
	 * 辗转相除法求最大公约数
	 * 
	 * @param big 大的整数
	 * @param small 小的整数
	 * @return big和small这整数的最大公约数
	 */
	private static int gcd(int big, int small) {
		int remainder = big % small;
		if (remainder == 0) {
			return small;
		} else {
			return gcd(small, remainder);
		}
	}

	/**
	 * 求最小公倍数
	 * 
	 * @param a 整数
	 * @param b 另一个整数
	 * @param gcd a和b的最大公约数
	 * @return a和b的最小公倍数
	 */
	private static int lcm(int a, int b, int gcd) {
		return (a * b) / gcd;
	}
}

2、编写一个判断素数（prime number）的函数。

public class PrimeNumber {
	public static void main(String[] args) {
		for (int i = 2; i < 1000; i++) {
			if (isPrime_sqrt(i)) {
				if (i != 2) {
					System.out.print(",");
				}
				System.out.print(i);
			}
		}
		System.out.println();
	}

	/**
	 * 判断是否是质数
	 * 优化版本1
	 * 
	 * @param n 一个数
	 * @return 如果num是质数的话，返回true,否则返回false.
	 */
	private static boolean isPrime_sqrt(int n) {
		// n只需要被小于等于sqrt(n)的数整除即可判断是否为质数
		int sqrtN = (int) Math.sqrt(n);
		for (int i = 2; i <= sqrtN; i++) {
			// 如果能被小于它的数整除的话，那就不是质数
			if (n % i == 0)
				return false;
		}
		return true;
	}
}

3、编写函数，使得给定的一个二维数组（3*3）转置（transposition）。

public class MatrixTranspose {
	public static void main(String[] args) {
		int[][] a = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
		printMatrix(a);

		// int[][] b = transposeByCopy(a);
		// System.out.println();
		// printMatrix(b);
		
		System.out.println();
		transpose(a);
		printMatrix(a);
	}
	/**
	 * 矩阵转置（方阵）
	 * @param a 保存正方形矩阵的二维数组
	 */
	private static void transpose(int[][] a) {
		for (int i = 0, temp; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				// 交换主对角(j==i)线上下方的元素位置
				if (j < i) {
					temp = a[i][j];
					a[i][j] = a[j][i];
					a[j][i] = temp;
				}
			}
		}
	}
	/**
	 * 矩阵转置
	 * @param a 保存矩阵的二维数组
	 * @return 保存转置后的矩阵的二维数组
	 */
	private static int[][] transposeByCopy(int[][] a) {
		int[][] b = new int[a.length][a[0].length];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				b[j][i] = a[i][j];
			}
		}
		return b;
	}

	/**
	 * 打印矩阵
	 * 
	 * @param a 保存矩阵的二维数组
	 */
	private static void printMatrix(int[][] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print("│");
			for (int j = 0; j < a[i].length; j++) {
				if (j > 0)
					System.out.print(",");
				System.out.print(a[i][j]);
			}
			System.out.println("│");
		}
	}
}

4、编写一个函数，使得输入的一个字符串反序存放。

public class StringStoredInReverseOrder {
	public static void main(String[] args) {
		// char[] ch=new char[100];
		String str = "hello world!!";
		char[] ch = str.toCharArray();
		printChars(ch);
		inverse(ch);
		printChars(ch);
	}
	/**
	 * 反序存放字符串
	 * @param ch 保存字符串的字符数组。
	 */
	private static void inverse(char[] ch) {
		char temp;
		for (int i = 0; i < ch.length / 2; i++) {
			temp = ch[i];
			ch[i] = ch[ch.length - 1 - i];
			ch[ch.length - 1 - i] = temp;
		}
	}

	private static void printChars(char[] ch) {
		for (int i = 0; i < ch.length; i++) {
			System.out.print(ch[i]);
		}
		System.out.println();
	}
}

5、编写一个函数，连接（connect）两个字符串。

public class StringConcatenation {
	public static void main(String[] args) {
		String str1 = "hello";
		String str2 = "world";
		char[] ch1 = str1.toCharArray();
		char[] ch2 = str2.toCharArray();

		char[] ch3 = connect(ch1, ch2);
		printChars(ch3);
	}

	/**
	 * 连接两个字符串
	 * 
	 * @param ch1 保存第一个字符串的字符数组
	 * @param ch2 保存另一个字符串的字符数组
	 * @return ch1和ch2串联起来形成的字符数组
	 */
	private static char[] connect(char[] ch1, char[] ch2) {
		char[] ch3 = new char[ch1.length + ch2.length];
		for (int i = 0; i < ch1.length; i++) {
			ch3[i] = ch1[i];
		}
		for (int i = 0; i < ch2.length; i++) {
			ch3[ch1.length + i - 1] = ch2[i];
		}
		return ch3;
	}

	private static void printChars(char[] ch) {
		for (int i = 0; i < ch.length; i++) {
			System.out.print(ch[i]);
		}
		System.out.println();
	}
}

6、编写一个函数，将一个字符串中的元音字母（vowel：a、e、i、o、u）复制到另一个字符串中。

public class TakeOutVowels {
	public static void main(String[] args) {
		// 待输入的字符串
		String str = "helloWorld+aeiou";
		// 元音字典
		char[] vowels = { 'a', 'e', 'i', 'o', 'u' };
		char[] strCh = str.toCharArray();

		char[] vowelsBuffer = vowel(vowels, strCh);
		printChars(vowelsBuffer);
	}

	private static char[] vowel(char[] vowels, char[] strCh) {
		int k = 0;
		char[] vowelsBuffer = new char[200];
		for (int i = 0; i < strCh.length; i++) {
			for (int j = 0; j < vowels.length; j++) {
				if (strCh[i] == vowels[j]) {
//					System.out.print("(" + i + "," + strCh[i] + ")");
					if (k < 200)
						vowelsBuffer[k++] = strCh[i];
					else {
						System.out.println("内存已满");
						k = 0;
					}
				}
			}
		}
		return vowelsBuffer;
	}

	private static void printChars(char[] ch) {
		for (int i = 0; i < ch.length; i++) {
			System.out.print(ch[i]);
		}
		System.out.println();
	}
}

7、编写一个函数，将字符串中最长的单词输出。

public class FindLongestWord {

	public static void main(String[] args) {
		String[] strs = { "i", "like", "chinese", "NiceToMeetYouToo", "helloworld", "NiceToMeetYou" };
		int longestIndex = findLongestWordIndex(strs);
		System.out.println("最长的单词为" + strs[longestIndex]);
	}

	private static int findLongestWordIndex(String[] strs) {
		int[] strLengths = new int[strs.length];
		// 最长的单词的下标
		int longestWordIndex = 0;
		for (int i = 0; i < strLengths.length; i++) {
			// 如果当前的单词比最长的单词还要长
			if (strs[i].length() > strs[longestWordIndex].length()) {
				// 那么认为当前这个单词是最长的
				longestWordIndex = i;
			}
		}
		return longestWordIndex;
	}
}

8、编写一个编码函数

根据码长Key，把输入字符串按如下要求进行编码，并返回；
若是字母a-z 或是 A-Z, 0-9
假定key=1,
则源码中
字母 b->c , z->a
字母 2-> 3 9->0

Key=-1, 则 a->z, 0->9
函数原型为： char[] encoding(String s, int key)

public class Encoding {

	public static void main(String[] args) {
		String str = "abcdefg";
		str = "abcdefghijklmnopqrstuvwxyz";
		str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		str = "0123456789";
		str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

		int key = 2;
		key = 3;

		
		char[] coded = shiftCoding(str, key);

		System.out.println(String.valueOf(coded));
		
		
		
		// printAsciiCodeSequence('a', 26, "'", "'", ",");
		// printAsciiCodeSequence('A', 26, "'", "'", ",");
		// printAsciiCodeSequence('0', 10, ",");
		// printAsciiCodeSequence('0', 10, "'", "'", ",");

		// printAsciiCodeSequence('a', 26);
		// printAsciiCodeSequence('A', 26);
		// printAsciiCodeSequence('0', 10);
	}

	/**
	 * 移位编码，讲一个单词在字母表中后移n位或者前移n位实现编码
	 * 
	 * @param str 需要编码的字符串(只支持大小写加数字)
	 * @param key 需要移动的位数
	 */
	private static char[] shiftCoding(String str, int key) {
		char[] lowerCaseLetters = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
				'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
		char[] upperCaseLetters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
				'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
		char[] numbers = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
		char[] strs = str.toCharArray();
		char[] coded = new char[strs.length];

		for (int i = 0; i < strs.length; i++) {
			if (strs[i] >= 'a' && strs[i] <= 'z') {
				if (strs[i] + key > 'z') {
					// System.out.print((char) (strs[i] + key - 26));
					coded[i] = (char) (strs[i] + key - 26);
				} else {
//					System.out.print((char) (strs[i] + key));
					coded[i] = (char) (strs[i] + key);
				}
			}
			if (strs[i] >= 'A' && strs[i] <= 'Z') {
				if (strs[i] + key > 'Z') {
					// System.out.print((char) (strs[i] + key - 26));
					coded[i] = (char) (strs[i] + key - 26);
				} else {
					// System.out.print((char) (strs[i] + key));
					coded[i] = (char) (strs[i] + key);
				}
			}
			if (strs[i] >= '0' && strs[i] <= '9') {
				if (strs[i] + key > '9') {
					// System.out.print((char) (strs[i] + key - 10));
					coded[i] = (char) (strs[i] + key - 10);
				} else {
					// System.out.print((char) (strs[i] + key));
					coded[i] = (char) (strs[i] + key);
				}
			}
		}
		return coded;
	}

	/**
	 * 打印连续的ASCII码
	 * 
	 * @param firstASCII 刚开始的ASCII码
	 * @param times 要排在firstASCII之后多少位的ASCII
	 * @param head 打印在 ASCII码 前面的字符串
	 * @param tail 打印在ASCII码 之后的字符串
	 * @param delimiter 分隔符
	 */
	private static void printAsciiCodeSequence(char firstASCII, int times, String head, String tail, String delimiter) {
		for (int i = 0; i < times; i++) {
			if (i > 0)
				System.out.print(delimiter);
			System.out.print(head + (char) (firstASCII + i) + tail);
		}
		System.out.println();
	}
	/**
	 * 连续打印ASCII字符序列
	 * @param firstASCII 要打印的ASCII字符的开始字符
	 * @param times 要打印的ASCII字符序列的长度
	 */
	private static void printAsciiCodeSequence(char firstASCII, int times) {
		printAsciiCodeSequence(firstASCII, times, "", "", "");
	}

	private static void printAsciiCodeSequence(char firstASCII, int times, String delimiter) {
		printAsciiCodeSequence(firstASCII, times, "", "", delimiter);
	}
}

9、Int atoi(String s) // 把数字字符串转成数值 “367”

public class StringtoInt {
	public static void main(String[] args) {
		String str = "367";
		int num = stringToInt(str);
		System.out.println(num);
	}

	private static int stringToInt(String str) {
		char[] ch = str.toCharArray();
		int num = 0;
		for (int i = 0, value; i < ch.length; i++) {
			// 取出每一位的值
			value = (int) (ch[i] - '0');
			// 计算每一位对应的值
			for (int j = 0; j < ch.length - 1 - i; j++) {
				value = value * 10;
			}
			// System.out.println(value);
			// 和前面的数字对应的值相加
			num += value;
		}
		return num;
	}
}

10、 Double atod(String s)

String类型的小数转double

11、输入年月，输出该月的月历

（1） 输入年月日，求出当年的第几天（一个函数）
（2） 输入年月日，输入星期几（ 以1990-1-1星期一为基准）
（3） 输入年月，打印日历

12、 Char[] change(String s) 实现字符串单词倒置

例如：

Hello**world
olleH**dlrow