java面试一个小时,遇到5个面试题,要求一个小时,结果花了一天

5个问题

问题1:使用for循环、while循环和递归写出3个函数来计算给定数列的总和。

问题2:编写一个交错合并列表元素的函数。例如：给定的两个列表为[a，B，C]和[1，2，3]，函数返回[a，1，B，2，C，3]。

问题3:编写一个计算前100位斐波那契数的函数。根据定义，斐波那契序列的前两位数字是0和1，随后的每个数字是前两个数字的和。例如，前10位斐波那契数为：0，1，1，2，3，5，8，13，21，34。

问题4:编写一个能将给定非负整数列表中的数字排列成最大数字的函数。例如，给定[50，2，1,9]，最大数字为95021。

问题5:编写一个在1，2，…，9(顺序不能变)数字之间插入+或-或什么都不插入，使得计算结果总是100的程序，并输出所有的可能性。

例如：1 + 2 + 34–5 + 67–8 + 9 = 100。

class="java" name="code">

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.List;

import java.util.Optional;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.function.Supplier;

import java.util.stream.Stream;

public class One2Five {

public void one() {

int[] arr = { 1, 2, 4, 3, 0, 1, 2, 3 };

int sum = 0;

for (int i : arr) {

sum += i;

}

System.out.println("sum=" + sum);

sum = 0;

int i = 0;

while (i < arr.length) {

sum += arr[i++];

}

System.out.println("sum=" + sum);

sum = 0;

sum = sum(arr, 0);

System.out.println("sum=" + sum);

}

private int sum(int[] arr, int i) {

if (i == arr.length)

return 0;

return arr[i] + sum(arr, i + 1);

}

public void two() {

int[] b = { 0, 2, 4, 6, 8 };

int[] a = { 1, 3, 5, 7, 9 };

int[] c = new int[a.length + b.length];

int bx = 0;

int ax = 0;

boolean f = true;

boolean bof = false;

boolean aof = false;

for (int i = 0; i < c.length; i++) {

if (f && !bof) {

if (bx < b.length) {

c[i] = b[bx++];

} else

bof = true;

f = false;

} else if (!aof) {

if (ax < a.length) {

c[i] = a[ax++];

} else

aof = true;

f = true;

}

}

for (int i : c) {

System.out.print(i + ",");

}

}

public long fboi(int n) {

if (n == 1)

return 0;

if (n == 2)

return 1;

long r = fboi(n - 1) + fboi(n - 2);

return r;

}

public void three() {

long all = fboi(10);

System.out.println(all);

}

public static Stream range(final Integer start, Integer length, Integer step, List except) {

Supplier seed = new Supplier() {

private Integer next = start;

@Override

public Integer get() {

Integer _next = next;

next += step;

return _next;

}

};

return Stream.generate(seed).limit(length).filter(new Predicate() {

@Override

public boolean test(Integer t) {

if (except == null)

return true;

if (except.contains(t))

return false;

return true;

}

});

}

List list = new ArrayList();

AtomicInteger count = new AtomicInteger(0);

List> WholeArrangementList = new ArrayList<>();

public void WholeArrangement(int N) {

Stream range = range(0, N, 1, list);

range.forEach(new Consumer() {

@Override

public void accept(Integer t) {

list.add(t);

WholeArrangement(N);

list.remove(list.size() - 1);

}

});

if (list.size() == N) {

count.incrementAndGet();

List arrangement = new ArrayList(list);

WholeArrangementList.add(arrangement);

System.out.println(Arrays.toString(list.toArray()));

}

}

public void four() {

Integer[] arr = { 89, 12, 43, 23, 1, 8 };

WholeArrangement(arr.length);

Stream sorted = WholeArrangementList.stream().map(new Function, String>() {

@Override

public String apply(List t) {

StringBuffer sf = new StringBuffer();

for (Integer idx : t) {

sf.append(arr[idx]);

}

return sf.toString();

}

}).sorted(Comparator.reverseOrder());

sorted.onClose(new Runnable() {

@Override

public void run() {

Optional findFirst = sorted.findFirst();

System.out.println(findFirst.get());

}

});

Object[] array = sorted.toArray();

Stream.of(array).forEach(new Consumer() {

@Override

public void accept(Object t) {

System.out.println(t);

}

});

System.out.println("___________________________________________________max");

Optional findFirst = Stream.of(array).findFirst();

System.out.println(findFirst.get());

}

char[] operator = { ' ', '+', '-' };

int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

List operatorList = new ArrayList();

private int joinNumCalc() {

int joinNum = 0;

char preOperate = 'S';// 模拟个开始符

int index = operatorList.size() - 1;

int count = 1;

if (operatorList.size() <= 1)

return 0;

if (operatorList.get(index) == ' ')

return 0;

for (int i = index - 1; i >= 0; i--) {

if (operatorList.get(i) == ' ') {

count++;

} else {

preOperate = operatorList.get(i);

break;

}

}

if (preOperate == 'S') {

count = count - 1;

}

for (int i = index - count; i < index; i++) {

joinNum = joinNum * 10 + nums[i];

}

switch (preOperate) {

case '+':

return joinNum;

case '-':

return -joinNum;

case 'S':

return joinNum;

default:

break;

}

return 0;

}

public void exp_calc(int value) {

if (operatorList.size() == nums.length) {

count.incrementAndGet();

operatorList.add('E');// 加一个结束符

value = value + joinNumCalc();

operatorList.remove(operatorList.size() - 1);

if (value == 100) {

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

Character operate = operatorList.get(i);

switch (operate) {

case '+':

case '-':

if (i == 0 && operate == '+') {

} else {

System.out.print(operate);

}

System.out.print(nums[i]);

break;

case ' ':

System.out.print(nums[i]);

default:

break;

}

}

System.out.println();

// System.out.println("value = " + value + "\t" +

// Arrays.toString(operatorList.toArray(new Character[0])));

}

return;

}

for (int i = 0; i < operator.length; i++) {

if (operatorList.size() == 0 && operator[i] == ' ')

continue;

operatorList.add(operator[i]);

int valueAdd = value + joinNumCalc();

exp_calc(valueAdd);

operatorList.remove(operatorList.size() - 1);

}

}

public void five() {

exp_calc(0);

System.out.println(count);

}

public static void main(String[] args) {

One2Five five = new One2Five();

five.one();

five.two();

five.three();

five.four();

five.five();

}

}