笔试训练(1)

1)下列与队列结构有关联的是:

A:函数的递归调用

B:数组元素的引用

C:多重循环的执行

D:先到先服务的作业调度

2)下列选项中，那些是interface合法的方法定义？

A:public void main(String args[]);

B:private int getNums();

C:boolean setFlag(Boolean[] tests);

D:public float get(int x)；

3)下列那些类实现了Collection接口？

A:HashMap   B:ArrayList   C:Vector  D:Iterator

4)abstract的子类必须实现其父类的所有抽象方法

5)1GB的准确值是:

A:1024*1024Bytes

B:1024KB

C:1024MB

D:1000*1000MB

6)以下java语法保留不能作为类名和方法名使用的是

A:default

B:int

C:implements

D:throws

1题:解析:解析:队列是一种先进先出的数据结构，A选项，函数的递归调用是在栈上面，B，C和选项没有什么关系，D:满足先进先出

2题:解析:默认是public abstract类型的，选A，C，D

3题:解析:选择BC，因为Collection实现了Iterator接口

4题:如果说抽象类的子类是一个普通类，那么这个类必须重写抽象类所有抽象方法，如果说子类不是抽象类，那么可以不实现

5题:bit  byte kb mb gb tb pb

1bit=8byte

1kb=1024byte

1mb=1024kb

所以说选C

6题:ABCD都不可以的，JAVA中的所有关键字都不可以作为类名和变量

笔试题第一题:

题干:A，B，C是三个好朋友，每一个人手里面都有一些糖果，虽然我们不知道他们每一个人手里面具体有多少糖果，但是我们知道一下的信息:

1)A-B，B-C，A+B，B+C这四个数值，每一个字母代表每一个人所拥有的糖果数，现在我们需要通过这四个数值计算出每个人手里面有多少糖果

2)这里面最多保证有一组A，B，C满足条件:

思路:假设我们现在输入了四组数据Y1，Y2，Y3，Y4

Y1=A-B

Y2=B-C

Y3=A+B

Y4=B+C

1)我们先通过第一个表达式和第三个表达式把A和B都计算出来:

A=(Y1+Y3)/2;

B=(Y3-Y1)/2;

2)我们可以通过第二个表达式和第四个表达式把B和C都计算出来:

B=(Y2+Y4)/2;

C=(Y4-Y2)/2;

3)我们两次计算的结果的值相等的时候，表明我们进行输入的值是有效的

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
       Scanner scanner=new Scanner(System.in);
       while(scanner.hasNext()){
         int Y1=scanner.nextInt();
         int Y2=scanner.nextInt();
         int Y3=scanner.nextInt();
         int Y4=scanner.nextInt();
         int A=(Y1+Y3)/2;
         int B1=(Y3-Y1)/2;
         int C=(Y4-Y2)/2;
         int B2=(Y2+Y4)/2;
            if(B1==B2){
              System.out.println(A+" "+B1+" "+C);
             }else{
                 System.out.println("No");
             }
          }
        }
    }

笔试题第二题: 进制转换_牛客题霸_牛客网

思路:

1)假设我们要将123转化成10进制数

123%10=3，123/10=12；

12%10=2，12/10=1；

1%10=1，1/10=1；

咱们上面的每一个取模一个数，取余一个数，每一次取模的结果都用stringBuilder来进行拼接，最后在将stringBuilder进行逆置即可

2)现在我们将7转化成2进制数:

7%2=1，7/2=3；

3%2=1，3/2=1；

1%2=1，1/2=0；

3)所以说我们将任何一个数字m转化成对应的n进制数，都是先进行取模，在继续进行相除，直到最后相处的结果是0

现在我们不进行考虑16进制数:

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){//进行循环输入
            int m=scanner.nextInt();
            int n=scanner.nextInt();
            process(m,n);
        }
    }
    public static void process(int m,int n){
        StringBuilder stringBuilder=new StringBuilder();
        if(m==0){
            System.out.println(0);
            return;
        }//对0字符要进行特殊处理
        int flag=1;//如果说输入的数是负数,那么直接按照一个标志位来进行计算
        if(m<0){
            flag=-1;
            m=-m;
        }
        int index=-1;
        while(m!=0){
            String str=String.valueOf(m%n);//考虑16进制的时候,可以考虑数组的下标
            stringBuilder.append(str);
            m=m/n;
        }
        int result=Integer.parseInt(stringBuilder.reverse().toString());
        System.out.println(result*flag);
    }
}

现在说如果我们进行考虑16进制数:

我们用一个字符串或者是数组来进行存储1-16位的进制数字

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
            int m=scanner.nextInt();
            int n=scanner.nextInt();
            process(m,n);
        }
    }
    public static void process(int m,int n){
        String string="0123456789ABCDEF";
        StringBuilder stringBuilder=new StringBuilder();
        if(m==0){
            System.out.println(m);
            return;
        }
        String flag="";
        if(m<0){
            flag="-";
            m=-m;
        }
        int index=-1;
        while(m!=0){
            String str=String.valueOf(string.charAt(m%n));
            stringBuilder.append(str);
            m=m/n;
        }
        stringBuilder.append(flag);
        String str=stringBuilder.reverse().toString();
        System.out.println(str);

    }
}