Code666 (代码贴、代码片段)

[Java] 5个问题 →→→→→进入此内容的聊天室

来自 , 2019-11-12, 写在 Java, 查看 131 次.
URL http://www.code666.cn/view/a1afc58c
  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. import java.util.Optional;
  6. import java.util.concurrent.atomic.AtomicInteger;
  7. import java.util.function.Consumer;
  8. import java.util.function.Function;
  9. import java.util.function.Predicate;
  10. import java.util.function.Supplier;
  11. import java.util.stream.Stream;
  12.  
  13. /*
  14.  * 5个问题
  15. 问题1:使用for循环、while循环和递归写出3个函数来计算给定数列的总和。
  16. 问题2:编写一个交错合并列表元素的函数。例如：给定的两个列表为[a，B，C]和[1，2，3]，函数返回[a，1，B，2，C，3]。
  17. 问题3:编写一个计算前100位斐波那契数的函数。根据定义，斐波那契序列的前两位数字是0和1，随后的每个数字是前两个数字的和。例如，前10位斐波那契数为：0，1，1，2，3，5，8，13，21，34。
  18. 问题4:编写一个能将给定非负整数列表中的数字排列成最大数字的函数。例如，给定[50，2，1,9]，最大数字为95021。
  19. 问题5:编写一个在1，2，…，9（顺序不能变）数字之间插入+或-或什么都不插入，使得计算结果总是100的程序，并输出所有的可能性。
  20. 例如：1 + 2 + 34–5 + 67–8 + 9 = 100。
  21.  *
  22.  */
  23.  
  24. public class One2Five {
  25.  
  26.         public void one() {
  27.                 int[] arr = { 1, 2, 4, 3, 0, 1, 2, 3 };
  28.                 int sum = 0;
  29.                 for (int i : arr) {
  30.                         sum += i;
  31.                 }
  32.                 System.out.println("sum=" + sum);
  33.                 sum = 0;
  34.                 int i = 0;
  35.                 while (i < arr.length) {
  36.                         sum += arr[i++];
  37.                 }
  38.                 System.out.println("sum=" + sum);
  39.                 sum = 0;
  40.                 sum = sum(arr, 0);
  41.                 System.out.println("sum=" + sum);
  42.         }
  43.  
  44.         private int sum(int[] arr, int i) {
  45.                 if (i == arr.length)
  46.                         return 0;
  47.                 return arr[i] + sum(arr, i + 1);
  48.         }
  49.  
  50.         public void two() {
  51.                 int[] b = { 0, 2, 4, 6, 8 };
  52.                 int[] a = { 1, 3, 5, 7, 9 };
  53.                 int[] c = new int[a.length + b.length];
  54.  
  55.                 int bx = 0;
  56.                 int ax = 0;
  57.                 boolean f = true;
  58.  
  59.                 boolean bof = false;
  60.                 boolean aof = false;
  61.                 for (int i = 0; i < c.length; i++) {
  62.                         if (f && !bof) {
  63.                                 if (bx < b.length) {
  64.                                         c[i] = b[bx++];
  65.                                 } else
  66.                                         bof = true;
  67.                                 f = false;
  68.                         } else if (!aof) {
  69.                                 if (ax < a.length) {
  70.                                         c[i] = a[ax++];
  71.                                 } else
  72.                                         aof = true;
  73.                                 f = true;
  74.                         }
  75.                 }
  76.  
  77.                 for (int i : c) {
  78.                         System.out.print(i + ",");
  79.                 }
  80.         }
  81.  
  82.         public long fboi(int n) {
  83.                 if (n == 1)
  84.                         return 0;
  85.                 if (n == 2)
  86.                         return 1;
  87.                 long r = fboi(n - 1) + fboi(n - 2);
  88.                 return r;
  89.         }
  90.  
  91.         public void three() {
  92.                 long all = fboi(10);
  93.                 System.out.println(all);
  94.         }
  95.  
  96.         public static Stream<Integer> range(final Integer start, Integer length, Integer step, List<Integer> except) {
  97.                 Supplier<Integer> seed = new Supplier<Integer>() {
  98.  
  99.                         private Integer next = start;
  100.  
  101.                         @Override
  102.                         public Integer get() {
  103.                                 Integer _next = next;
  104.                                 next += step;
  105.                                 return _next;
  106.                         }
  107.                 };
  108.                 return Stream.generate(seed).limit(length).filter(new Predicate<Integer>() {
  109.                         @Override
  110.                         public boolean test(Integer t) {
  111.                                 if (except == null)
  112.                                         return true;
  113.                                 if (except.contains(t))
  114.                                         return false;
  115.                                 return true;
  116.                         }
  117.                 });
  118.         }
  119.  
  120.         List<Integer> list = new ArrayList<Integer>();
  121.         AtomicInteger count = new AtomicInteger(0);
  122.         List<List<Integer>> WholeArrangementList = new ArrayList<>();
  123.  
  124.         public void WholeArrangement(int N) {
  125.                 Stream<Integer> range = range(0, N, 1, list);
  126.                 range.forEach(new Consumer<Integer>() {
  127.                         @Override
  128.                         public void accept(Integer t) {
  129.                                 list.add(t);
  130.                                 WholeArrangement(N);
  131.                                 list.remove(list.size() - 1);
  132.                         }
  133.                 });
  134.                 if (list.size() == N) {
  135.                         count.incrementAndGet();
  136.                         List<Integer> arrangement = new ArrayList<Integer>(list);
  137.                         WholeArrangementList.add(arrangement);
  138.                         System.out.println(Arrays.toString(list.toArray()));
  139.                 }
  140.         }
  141.  
  142.         public void four() {
  143.                 Integer[] arr = { 89, 12, 43, 23, 1, 8 };
  144.                 WholeArrangement(arr.length);
  145.  
  146.                 Stream<String> sorted = WholeArrangementList.stream().map(new Function<List<Integer>, String>() {
  147.                         @Override
  148.                         public String apply(List<Integer> t) {
  149.                                 StringBuffer sf = new StringBuffer();
  150.                                 for (Integer idx : t) {
  151.                                         sf.append(arr[idx]);
  152.                                 }
  153.                                 return sf.toString();
  154.                         }
  155.                 }).sorted(Comparator.reverseOrder());
  156.                 sorted.onClose(new Runnable() {
  157.                         @Override
  158.                         public void run() {
  159.                                 Optional<String> findFirst = sorted.findFirst();
  160.                                 System.out.println(findFirst.get());
  161.                         }
  162.                 });
  163.  
  164.                 Object[] array = sorted.toArray();
  165.                 Stream.of(array).forEach(new Consumer<Object>() {
  166.                         @Override
  167.                         public void accept(Object t) {
  168.                                 System.out.println(t);
  169.                         }
  170.                 });
  171.  
  172.                 System.out.println("___________________________________________________max");
  173.                 Optional<Object> findFirst = Stream.of(array).findFirst();
  174.                 System.out.println(findFirst.get());
  175.         }
  176.  
  177.        
  178.         char[] operator = { ' ', '+', '-' };
  179.         int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  180.         List<Character> operatorList = new ArrayList<Character>();
  181.  
  182.         private int joinNumCalc() {
  183.                 int joinNum = 0;
  184.                 char preOperate = 'S';// 模拟个开始符
  185.                 int index = operatorList.size() - 1;
  186.                 int count = 1;
  187.  
  188.                 if (operatorList.size() <= 1)
  189.                         return 0;
  190.                 if (operatorList.get(index) == ' ')
  191.                         return 0;
  192.  
  193.                 for (int i = index - 1; i >= 0; i--) {
  194.                         if (operatorList.get(i) == ' ') {
  195.                                 count++;
  196.                         } else {
  197.                                 preOperate = operatorList.get(i);
  198.                                 break;
  199.                         }
  200.                 }
  201.                 if (preOperate == 'S') {
  202.                         count = count - 1;
  203.                 }
  204.                 for (int i = index - count; i < index; i++) {
  205.                         joinNum = joinNum * 10 + nums[i];
  206.                 }
  207.  
  208.                 switch (preOperate) {
  209.                 case '+':
  210.                         return joinNum;
  211.                 case '-':
  212.                         return -joinNum;
  213.                 case 'S':
  214.                         return joinNum;
  215.                 default:
  216.                         break;
  217.                 }
  218.                 return 0;
  219.         }
  220.  
  221.         public void exp_calc(int value) {
  222.                 if (operatorList.size() == nums.length) {
  223.                         count.incrementAndGet();
  224.                         operatorList.add('E');// 加一个结束符
  225.                         value = value + joinNumCalc();
  226.                         operatorList.remove(operatorList.size() - 1);
  227.                         if (value == 100) {
  228.                                 for (int i = 0; i < operatorList.size(); i++) {
  229.                                         Character operate = operatorList.get(i);
  230.                                         switch (operate) {
  231.                                         case '+':
  232.  
  233.                                         case '-':
  234.                                                 if (i == 0 && operate == '+') {
  235.                                                 } else {
  236.                                                         System.out.print(operate);
  237.                                                 }
  238.                                                 System.out.print(nums[i]);
  239.                                                 break;
  240.                                         case ' ':
  241.                                                 System.out.print(nums[i]);
  242.                                         default:
  243.                                                 break;
  244.                                         }
  245.                                 }
  246.                                 System.out.println();
  247.                                 // System.out.println("value = " + value + "\t" +
  248.                                 // Arrays.toString(operatorList.toArray(new Character[0])));
  249.                         }
  250.  
  251.                         return;
  252.                 }
  253.                 for (int i = 0; i < operator.length; i++) {
  254.                         if (operatorList.size() == 0 && operator[i] == ' ')
  255.                                 continue;
  256.                         operatorList.add(operator[i]);
  257.                         int valueAdd = value + joinNumCalc();
  258.                         exp_calc(valueAdd);
  259.                         operatorList.remove(operatorList.size() - 1);
  260.                 }
  261.         }
  262.  
  263.         public void five() {
  264.                 exp_calc(0);
  265.                 System.out.println(count);
  266.         }
  267.  
  268.         public static void main(String[] args) {
  269.                 One2Five five = new One2Five();
  270.                 five.one();
  271.                 five.two();
  272.                 five.three();
  273.                 five.four();
  274.                 five.five();
  275.         }
  276.  
  277. }
  278.  

回复 "5个问题"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666