完美世界java笔试题_2016完美世界招聘笔试题———互联网Java开发

国庆之后一直忙于很多事，今天翻得原来的笔试题，做了一些放在这里，望对有需要的能有所帮助。

选择题第17题详解：

第1题答案：

我用的四个字母做的测试，可以改为3个。。

package test;

public class test {

public static void main(String args[]) {

char ch[]={'a','b','c','d'};

permutation(ch);

}

static void permutation(char [] ch){

if(ch==null) return;

permutation(ch,0);

}

static void permutation(char[] ch,int begin){

if(begin==ch.length)

System.out.println(ch);

char temp;

for(int i=begin;i

temp=ch[i];

ch[i]=ch[begin];

ch[begin]=temp;

permutation(ch, begin+1);

temp=ch[i];

ch[i]=ch[begin];

ch[begin]=temp;

}

}

}

输出：

acdb

adcb

adbc

bacd

badc

bcad

bcda

bdca

bdac

cbad

cbda

cabd

cadb

cdab

cdba

dbca

dbac

dcba

dcab

dacb

dabc

第2题答案：

package test;

import java.util.ArrayList;

import java.util.List;

public class test {

public static void main(String[] args) {

// 求素数

List primes = getPrimes(1000);

// 输出结果

for (int i = 0; i < primes.size(); i++) {

Integer prime = primes.get(i);

System.out.printf("%6d", prime);

if (i % 9 == 8) {

System.out.println();

}

}

}

/**

* 求 n 以内的所有素数

*

* @param n 范围

*

* @return n 以内的所有素数

*/

private static List getPrimes(int n) {

List result = new ArrayList();

result.add(2);

for (int i = 3; i <= n; i += 2) {

if (!divisible(i, result)) {

result.add(i);

}

}

return result;

}

/**

* 判断 n 是否能被整除

*

* @param n 要判断的数字

* @param primes 包含素数的列表

*

* @return 如果 n 能被 primes 中任何一个整除，则返回 true。

*/

private static boolean divisible(int n, List primes) {

for (Integer prime : primes) {

if (n % prime == 0) {

return true;

}

}

return false;

}

}

运用的一个质数的特性就是：如果一个数是质数，那么一定不会被小于它的质数整除，反过来如果小于这个数的所有质数都不能整除它，那么这个数也就是质数。

第3题答案：

package test;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Random;

public class test {

public static void main(String[] args) {

new test();

}

public test() {

// map 记录每个图片的概率

Map prizeMap = new HashMap();

// a,b,c的概率和也可以不为1，它对自动把概率值当比例值去运行。

prizeMap.put("1", 0.5);

prizeMap.put("2", 0.3);

prizeMap.put("3", 0.1);

prizeMap.put("4", 0.95);

prizeMap.put("5", 0.05);

// 返回的s就是按照上面的概率参数的。

String s = getRandomPrize(prizeMap);

System.out.println(s);

}

/**

* 按照概率集合参数随机对象

* @param map

* @return

*/

private static String getRandomPrize(Map map) {

Double total = 0.0;

Map tempMap = new LinkedHashMap(); // 使用有序的map集合以保证key值是递增的

Iterator> it = map.entrySet().iterator();

while (it.hasNext()) {

Map.Entry entry = (Map.Entry) it.next();

total += entry.getValue();

tempMap.put(total, entry.getKey());

}

Double index = new Random().nextDouble()*total;

Iterator> tempIt = tempMap.entrySet().iterator();

while (tempIt.hasNext()) {

Entry next = tempIt.next();

if (index < next.getKey()) {

return next.getValue();

}

}

return "never appear...";

}

}