【蓝桥杯】【组素数】

【题目】

组素数

 

    素数就是不能再进行等分的数。比如：2 3 5 7 11 等。
    9 = 3 * 3 说明它可以3等分，因而不是素数。
    我们国家在1949年建国。如果只给你 1 9 4 9 这4个数字卡片，
    可以随意摆放它们的先后顺序（但卡片不能倒着摆放啊，我们不是在脑筋急转弯！），那么，你能组成多少个4位的素数呢？
    比如：1949，4919 都符合要求。
    请你提交：能组成的4位素数的个数，不要罗列这些素数!!

 

    注意：不要提交解答过程，或其它的辅助说明文字。

 

【分析】

这个题目有两种思想去做，

一种是递归的思想找出所有可能的组合，全排列，

一种是循环所有的四位数情况来找到正确的组合；但是我们要注意组合后的数据重复性问题。

 

补充知识：

HashSet类

Java.util.HashSet类实现了Java.util.Set接口

(1)它不允许出现重复元素

(2)不保证集合中的元素是按顺序存储的

(3)允许包含值为null的元素，但最多只能有一个null元素

(4)底层基于hash表实现，放入的对象必须实现hashCode()方法，放入的对象是以hashcode作为标识

 

TreeSet类

Java.util.TreeSet类实现了Java.util.Set接口

(1)它不允许出现重复元素

(2)保证集合中的元素是按升序顺序存储的

(3)不允许包含值为null的元素

(4)底层基于二叉树实现，元素自动排好序

 

Arrays类

能方便的操作数组，提供的所有方法都是静态的：

(1)给数组赋值，使用fill()方法

(2)给数组排序，使用sort()方法，升序排列

(3)通过equals()方法比较数组中的元素是否相等

(4)通过binarySearch()能对排序好的数组进行二分查找

 

第一种解题源码：

 

public class Test004 {
	
	public static void main(String[] args) {
		HashSet<String> set = new HashSet<String>(); //初始化集合
		int counter = 0; //计数变量
		
		for(int i=1000; i<=9999; i++){
			String tempStr = String.valueOf(i);
			char[] tempCharArray = tempStr.toCharArray();
			Arrays.sort(tempCharArray);
			String str = String.valueOf(tempCharArray);
			if(str.equals("1499")){
				set.add(tempStr);
			}
		}
		
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String str = (String) iterator.next();
			if(isPrimtiveNumber(Integer.valueOf(str))){
				counter++;
			}
			
		}
		
		System.out.println("counter=" + counter);
	}
	
	/**
	 * 判断一个数是否是素数
	 * 
	 * @param n
	 * @return 如果n是素数，返回true；如果n不是素数，返回false
	 */
	private static boolean isPrimtiveNumber(int n){
		boolean isPrimitive = true;
		for(int i=2; i<n; i++){
			if(n%i == 0){
				isPrimitive = false;
				break;
			}
		}
		
		return isPrimitive;
	}
	
}

 

 

【结果】

6

 

第二种方式是使用递归思想，源码如下：

 

public class Test005 {
	
	private static int counter;
	private static HashSet<String> set;
	
	public static void main(String[] args) {
		counter = 0;
		set = new HashSet<String>();
		char[] a = {'1','4','9','9'};
		findX(a, 0);
		
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String str = (String) iterator.next();
			if(isPrimtiveNumber(Integer.valueOf(str))){
				counter++;
			}
			
		}
		
		System.out.println(counter);
		
	}
	
	/**
	 * 递归方法遍历找出所有的组合
	 * 
	 * @param b 原始数组
	 * @param index 递归过程中的子数组头指针
	 */
	private static void findX(char[] b, int index){
		if(index >= b.length){
			return;
		}
		
		if(index == b.length-1){
			String str = String.valueOf(b);
			if(isPrimtiveNumber(Integer.valueOf(str))){
				set.add(str);
			}
			return;
		}
		
		for(int i=index; i<b.length; i++){
			//交换位置
			{
				char c = b[index];
				b[index] = b[i];
				b[i] = c;
			}
			set.add(String.valueOf(b));
			findX(b, index+1);
			
			//回溯
			{
				char c = b[index];
				b[index] = b[i];
				b[i] = c;
			}
		}
		
	}
	
	/**
	 * 判断一个数是否是素数
	 * 
	 * @param n
	 * @return 如果n是素数，返回true；如果n不是素数，返回false
	 */
	private static boolean isPrimtiveNumber(int n){
		boolean isPrimitive = true;
		for(int i=2; i<n; i++){
			if(n%i == 0){
				isPrimitive = false;
				break;
			}
		}
		
		return isPrimitive;
	}

}