华为笔试题

Question

用java语言编写程序，每位选手需要回答10个问题，越后面越有难度，答对的，当前得到的分数翻倍，答错的则扣掉与题号相同的分数，每位同学必须答题，不答题按错误处理。

Answer 1

或许你的描述有些问题，没觉得有什么难点的地方，也没有感觉到涉及到结构算法的地方。
至于你2楼的补充，这个确实有一点难度，我感觉应该是一种枚举所有可能组合的方式
按照递归的方式来解决。
void show(int level,int score,String s){//层数,得分,记录答题的对错
if(level==0){
if(score==10){
System.out.println(s);//输出该钟可能
}
}else{
level--;
//先判断，如果score为负数也就不用进行下面的递归了
//答对的可能
//这里先做一个判断，如果score*10/2的余数不为0的话下面的这个递归就不用做了
show(level,score/2,"1"+s);
//打错的可能
show(level,score+level-1,"0"+s);
}
}
大体上思路就是这样的，暂时就没时间，就先不写了

Answer 2

菜鸟来试试： 2的10次方 1024种情况 不考虑得分重复（貌似重复也没关系）计算出1024个得分结果，级0、1字符串，放入hashmap, 在拿X分 就hashmap里字符串，不知道这样可不可以。

Answer 3

这个笨办法能列出所有分数和组合，没有过滤负数
int n=10;
int[] ap=new int[n];
int[] aa=new int[n];
for(int i=0,p=0;;i++){
ap[p++]=i;
    aa[ap[p-1]]=1;
    String s="";
    int k=10;
    for(int j=0;j<n;j++){
     k=aa[j]==0?(k-j-1):2*k;
     s+=aa[j];
    }
System.out.println(s+","+k);
    if(i==n-1){
        if(p==1){
            break;
        }
        aa[ap[--p]]=0;
        aa[ap[--p]]=0;
        i=ap[p];
    }
}
题拿来做面试应该是看个人的思路的，当场解出来感觉难道略大

Answer 4

import java.util.Arrays;public class defen {
public static void main(String[] args) {
System.out.println(defen(10, new boolean[] { true, false, true, true,
true, false, true, false, false, true }, 0));
reDefen(10, 518, 10, new Integer[10]);
} public static int defen(int point, boolean[] quesSqu, int currQues) {
if (currQues == quesSqu.length) {
return point;
} else {
if (quesSqu[currQues] == true) {
System.out.println(point);
return defen(point * 2, quesSqu, ++currQues);
} else {
System.out.println(point);
return defen(point - (currQues + 1), quesSqu, ++currQues);
}
}
} public static void reDefen(int point, int currPoi, int currQus,
Integer[] winOrLoss) {
// System.out.println(Arrays.toString(winOrLoss)+" "+currPoi);
if (currQus == 0 && currPoi == point && winOrLoss[currQus] != null) {
System.out.println(Arrays.toString(winOrLoss));
} else if (currQus == 0) {
return;
} else {
if (currPoi % 2 == 0) {
winOrLoss[currQus - 1] = 1;
reDefen(point, currPoi / 2, currQus - 1, winOrLoss);
}
winOrLoss[currQus - 1] = 0;
reDefen(point, currPoi + currQus, currQus - 1, winOrLoss); }
return;
}
}
一个方法是算十次以后的分数的
第二个方法是算根据分数来算10次的情况的

Answer 5

package com.voviv.common.util;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;public class huaweiTest {
public static void main(String args[]) {
while (true) {
BufferedReader sin;
String s = null;
try {
sin = new BufferedReader(
new InputStreamReader(System.in, "GBK"));
s = sin.readLine();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (s != null && !"".equals(s) && isNumberic(s)) {
System.out.println(getScores(Integer.parseInt(s)));
}
}
} public static List<String> getScores(int s) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 1024; i++) {
int score = 10;
String stringi = printBits(i); for (int n = 1; n <= 10; n++) {
if (stringi.charAt(n - 1) == '0')
score = score - n;
else
score = score * 2;
}
if (score == s) {
// System.out.println(stringi+":"+score);
list.add(stringi);
}
}
return list;
}/*
 * 把小于1024的int型数字转换成10位的二进制字符串
 */
public static String printBits(int n) {
StringBuffer result = new StringBuffer();
if (n == 0)
result.insert(0, 0);
int temp = n;
while (n != 0) {
temp = n % 2;
n = n / 2;
result.insert(0, temp);
}
String stringi = result.toString(); int len = stringi.length();
if (len < 10) {
for (int j = 0; j < (10 - len); j++) {
stringi = "0" + stringi;
}
}
return stringi;
}
/*
 * 判断字符串是否为数字
 */
public static boolean isNumberic(String str) { if (str == null) {
return false;
}
int sz = str.length();
for (int i = 0; i < sz; i++) {
if (Character.isDigit(str.charAt(i)) == false) {
return false;
}
}
return true;
}
}

Answer 6

假设最后的结果是：01001101001，则分数是 -1*1+2*2+(-3)*3+...+20*10,等等，这不正是我们大学学的矩阵乘法吗？好，列公式：{x1,x2,x3,x4,x5,x6,x7,x7,x8,x9,x10}x{{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}}=X,然后通过矩阵的除法求出左边的矩阵。

Answer 7

public static void judgeAndPrint(int[] arr, int score){
int tmp = 10;
for(int i = 0; i < arr.length; ++i){
if(arr[i] == 0){
tmp = tmp - (i + 1);
}else{
tmp = tmp * 2;
}
}
if(tmp == score){
for(int i = 0; i < arr.length; ++i){
System.out.print(arr[i] + "  ");
}
System.out.println();
}

}

public static void answerQuestions(int[] arr, int sub, int score){
if(sub >= arr.length){
return;
}
arr[sub] = 0;
judgeAndPrint(arr, score);
answerQuestions(arr, sub+1, score);
arr[sub] = 1;
judgeAndPrint(arr, score);
answerQuestions(arr, sub+1, score);
} public static void main(String[] args) {
int[] arr = new int[10];
//最终得分
int score = 5;
answerQuestions(arr, 0, score);
}来个递归的

Answer 8

package concurrency;public class Test
{
private static int SIZE = 56;
private int[] scores = new int[SIZE];
private String[] results = new String[SIZE]; public Test()
{
init();
} private void init()
{
for (int i = 0; i < SIZE; i++)
{
results[i] = "";
} StringBuilder sb = new StringBuilder();
int score = 0;
for (int a = 1; a >= 0; a -= 1)
for (int b = 2; b >= 0; b -= 2)
for (int c = 3; c >= 0; c -= 3)
for (int d = 4; d >= 0; d -= 4)
for (int e = 5; e >= 0; e -= 5)
for (int f = 6; f >= 0; f -= 6)
for (int g = 7; g >= 0; g -= 7)
for (int h = 8; h >= 0; h -= 8)
for (int i = 9; i >= 0; i -= 9)
for (int j = 10; j >= 0; j -= 10)
{
sb.append(a).append(b / 2)
.append(c / 3)
.append(d / 4)
.append(e / 5)
.append(f / 6)
.append(g / 7)
.append(h / 8)
.append(i / 9)
.append(j / 10);
score += a + b + c + d + e + f
+ g + h + i + j;
scores[score]++;
results[score] += sb.toString();
sb.delete(0, sb.length());
score = 0;
}
} public void printResult(int score)
{
if (score < 0 || score > 55)
{
System.out.println("the score is invalid");
return;
} int resultNum = scores[score];
if (resultNum <= 0)
{
System.out.println("no answer can get this score : " + score);
return;
} StringBuffer sb = new StringBuffer();
for (int i = 0; i < resultNum; i++)
{
sb.append("result_").append(i).append(" is : ")
.append(results[score].substring(i * 10, (i + 1) * 10))
.append("\n");
}
System.out.println(sb.toString());
} public static void main(String[] args)
{
Test t = new Test();
t.printResult(43);
}
}
简单测试了下，没什么问题，附上截图；

Answer 9

思路就是，直接计算出所有可能，用一个长度为56的int数组来存储答案个数，用长度为56的string数组来存储答案。
两个数组的下标刚好是分数的分布。