用户注册



邮箱：

密码：

用户登录


邮箱：

密码：
记住登录一个月忘记密码？

发表随想


还能输入：200字
云代码 - java代码库

5个问题

2017-09-07 作者： 低调的小飞举报

[java]代码库

view sourceprint?
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;
 
/*
 * 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。
 *
 */
 
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<Integer> range(final Integer start, Integer length, Integer step, List<Integer> except) {
        Supplier<Integer> seed = new Supplier<Integer>() {
 
            private Integer next = start;
 
            @Override
            public Integer get() {
                Integer _next = next;
                next += step;
                return _next;
            }
        };
        return Stream.generate(seed).limit(length).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer t) {
                if (except == null)
                    return true;
                if (except.contains(t))
                    return false;
                return true;
            }
        });
    }
 
    List<Integer> list = new ArrayList<Integer>();
    AtomicInteger count = new AtomicInteger(0);
    List<List<Integer>> WholeArrangementList = new ArrayList<>();
 
    public void WholeArrangement(int N) {
        Stream<Integer> range = range(0, N, 1, list);
        range.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer t) {
                list.add(t);
                WholeArrangement(N);
                list.remove(list.size() - 1);
            }
        });
        if (list.size() == N) {
            count.incrementAndGet();
            List<Integer> arrangement = new ArrayList<Integer>(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<String> sorted = WholeArrangementList.stream().map(new Function<List<Integer>, String>() {
            @Override
            public String apply(List<Integer> 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<String> findFirst = sorted.findFirst();
                System.out.println(findFirst.get());
            }
        });
 
        Object[] array = sorted.toArray();
        Stream.of(array).forEach(new Consumer<Object>() {
            @Override
            public void accept(Object t) {
                System.out.println(t);
            }
        });
 
        System.out.println("___________________________________________________max");
        Optional<Object> findFirst = Stream.of(array).findFirst();
        System.out.println(findFirst.get());
    }
 
     
    char[] operator = { ' ', '+', '-' };
    int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    List<Character> operatorList = new ArrayList<Character>();
 
    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();
    }
 
}


网友评论    (发表评论)


发表评论：

评论须知：

  • 1、评论每次加2分，每天上限为30；
  • 2、请文明用语，共同创建干净的技术交流环境；
  • 3、若被发现提交非法信息，评论将会被删除，并且给予扣分处理，严重者给予封号处理；
  • 4、请勿发布广告信息或其他无关评论，否则将会删除评论并扣分，严重者给予封号处理。


扫码下载

加载中，请稍后...

输入口令后可复制整站源码

加载中，请稍后...