1、两个数之和

  1. import java.io.*;
  2. import java.util.*;
  4. public class Solution {
  6.     public static void main(String[] args) {
  7.         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
  8.         Scanner scanner = new Scanner(System.in);
  9.         int c;
  10.         int a = scanner.nextInt();
  11.         int b = scanner.nextInt();
  12.         scanner.close();
  13.         c=twoSum(a,b);
  14.         System.out.println(c);
  17.     }
  18.     public static int twoSum(int a,int b){
  19.         int c;
  20.         c = a+b;
  21.         return c;
  22.     }
  23. }

2、一个数组中所有元素之和

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'simpleArraySum' function below.
  17.      *
  18.      * The function is expected to return an INTEGER.
  19.      * The function accepts INTEGER_ARRAY ar as parameter.
  20.      */
  22.     public static int simpleArraySum(List<Integer> ar) {
  23.     // Write your code here
  24.         int result = 0;
  25.         int num;
  26.         num = ar.size() - 1;
  27.         while(num >= 0){
  28.             result = result + ar.get(num);
  29.             num--;
  30.         }
  31.         return result;
  33.     }
  35. }
  37. public class Solution {
  38.     public static void main(String[] args) throws IOException {
  39.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  40.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
  42.         int arCount = Integer.parseInt(bufferedReader.readLine().trim());
  44.         List<Integer> ar = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
  45.             .map(Integer::parseInt)
  46.             .collect(toList());
  48.         int result = Result.simpleArraySum(ar);
  50.         bufferedWriter.write(String.valueOf(result));
  51.         bufferedWriter.newLine();
  53.         bufferedReader.close();
  54.         bufferedWriter.close();
  55.     }
  56. }

3、一个数组中所有元素之和（元素为大整数）

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'aVeryBigSum' function below.
  17.      *
  18.      * The function is expected to return a LONG_INTEGER.
  19.      * The function accepts LONG_INTEGER_ARRAY ar as parameter.
  20.      */
  22.     public static long aVeryBigSum(List<Long> ar) {
  23.     // Write your code here
  24.         int num;
  25.         num=ar.size()-1;
  26.         long result = 0;
  27.         while(num>=0){
  28.             result = result + ar.get(num);
  29.             num--;
  30.         }
  31.         return result;
  33.     }
  34. }
  36. public class Solution {
  37.     public static void main(String[] args) throws IOException {
  38.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  39.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
  41.         int arCount = Integer.parseInt(bufferedReader.readLine().trim());
  43.         List<Long> ar = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
  44.             .map(Long::parseLong)
  45.             .collect(toList());
  47.         long result = Result.aVeryBigSum(ar);
  49.         bufferedWriter.write(String.valueOf(result));
  50.         bufferedWriter.newLine();
  52.         bufferedReader.close();
  53.         bufferedWriter.close();
  54.     }
  55. }

4、一个数组两条对角线之差取绝对值

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'diagonalDifference' function below.
  17.      *
  18.      * The function is expected to return an INTEGER.
  19.      * The function accepts 2D_INTEGER_ARRAY arr as parameter.
  20.      */
  22.     public static int diagonalDifference(List<List<Integer>> arr) {
  23.     // Write your code here
  24.         int num = arr.size()-1;
  25.         int n = num;
  26.         int dia1 = 0;
  27.         int dia2 = 0;
  28.         int result;
  29.         int i,j;
  30.         while(num>=0){
  31.             i = n-num;
  32.             j = num;
  34.             List<Integer> term = arr.get(i);
  35.             dia1 = dia1 + term.get(i);
  36.             dia2 = dia2 + term.get(j);
  37.             num--;
  38.         }
  40.         result = dia1 - dia2;
  41.         if(result<0){
  42.             result = result * (-1);
  43.         }
  45.         return result;
  46.     }
  48. }
  50. public class Solution {
  51.     public static void main(String[] args) throws IOException {
  52.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  53.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
  55.         int n = Integer.parseInt(bufferedReader.readLine().trim());
  57.         List<List<Integer>> arr = new ArrayList<>();
  59.         IntStream.range(0, n).forEach(i -> {
  60.             try {
  61.                 arr.add(
  62.                     Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
  63.                         .map(Integer::parseInt)
  64.                         .collect(toList())
  65.                 );
  66.             } catch (IOException ex) {
  67.                 throw new RuntimeException(ex);
  68.             }
  69.         });
  71.         int result = Result.diagonalDifference(arr);
  73.         bufferedWriter.write(String.valueOf(result));
  74.         bufferedWriter.newLine();
  76.         bufferedReader.close();
  77.         bufferedWriter.close();
  78.     }
  79. }

5、一个数组中正，负，零的比例计算

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'plusMinus' function below.
  17.      *
  18.      * The function accepts INTEGER_ARRAY arr as parameter.
  19.      */
  21.     public static void plusMinus(List<Integer> arr) {
  22.     // Write your code here
  23.         int num;
  24.         int pos = 0, fu = 0,zero = 0;
  25.         double a,b,c;
  26.         num = arr.size() - 1;
  27.         int n = num + 1;
  28.         while(num >= 0){
  29.             if(arr.get(num) > 0){
  30.                 pos = pos + 1;
  31.             }else if (arr.get(num) == 0){
  32.                 zero = zero + 1;
  33.             }else {
  34.                 fu = fu + 1;
  35.             }
  36.             num--;
  37.         }
  39.         a =(float) pos / n;
  40.         b =(float) fu / n;
  41.         c = (float) zero / n;
  42.         String s1 = String.format("%.6f", a);
  43.         String s2 = String.format("%.6f", b);
  44.         String s3 = String.format("%.6f", c);
  45.         System.out.println(s1);
  46.         System.out.println(s2);
  47.         System.out.println(s3);
  48.     }
  50. }
  52. public class Solution {
  53.     public static void main(String[] args) throws IOException {
  54.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  56.         int n = Integer.parseInt(bufferedReader.readLine().trim());
  58.         List<Integer> arr = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
  59.             .map(Integer::parseInt)
  60.             .collect(toList());
  62.         Result.plusMinus(arr);
  64.         bufferedReader.close();
  65.     }
  66. }

6、给定正整数n，打印右对齐上三角

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'staircase' function below.
  17.      *
  18.      * The function accepts INTEGER n as parameter.
  19.      */
  21.     public static void staircase(int n) {
  22.     // Write your code here
  23.         int i = 1,j = n;
  24.         while(j>0){
  25.             for (int k = n; k > 0; k--) {
  26.                 if (k > i){
  27.                     System.out.print(" ");
  28.                 }else{
  29.                     System.out.print("#");
  30.                 }
  31.                 if (k == 1){
  32.                     System.out.println("");
  33.                 }
  34.             }
  35.             j--;
  36.             i++;
  37.         }
  38.     }
  40. }
  42. public class Solution {
  43.     public static void main(String[] args) throws IOException {
  44.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  46.         int n = Integer.parseInt(bufferedReader.readLine().trim());
  48.         Result.staircase(n);
  50.         bufferedReader.close();
  51.     }
  52. }

7、给定5个元素数组，求其中4个元素的最大之和与最小之和

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'miniMaxSum' function below.
  17.      *
  18.      * The function accepts INTEGER_ARRAY arr as parameter.
  19.      */
  21.     public static void miniMaxSum(List<Integer> arr) {
  22.     // Write your code here
  23.         int num;
  24.         int min = arr.get(0);
  25.         int max = 0;
  26.         int j = 0,k = 0;
  27.         num = arr.size();
  28.         for (int i = 0; i < num; i++) {
  29.             if (min > arr.get(i)){
  30.                 min = arr.get(i);
  31.                 j = i;
  32.             }
  33.             if (max < arr.get(i)){
  34.                 max = arr.get(i);
  35.                 k =i;
  36.             }
  37.         }
  38.         long sum1 = 0;
  39.         long sum2 = 0;
  41.         for (int i = 0; i < num; i++) {
  42.             if (i != j){
  43.                 sum1 = sum1 + arr.get(i);
  44.             }
  46.             if(i != k){
  47.                 sum2 = sum2 + arr.get(i);
  48.             }
  50.         }
  51.         /*System.out.println(j);
  52.         System.out.println(min);
  53.         System.out.println(k);
  54.         System.out.println(max);
  55.         */
  57.         System.out.print(sum2 + " " + sum1);
  58.     }
  60. }
  62. public class Solution {
  63.     public static void main(String[] args) throws IOException {
  64.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  66.         List<Integer> arr = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
  67.             .map(Integer::parseInt)
  68.             .collect(toList());
  70.         Result.miniMaxSum(arr);
  72.         bufferedReader.close();
  73.     }
  74. }

8、一个数组中最大数值的个数

  1. import java.io.*;
  2. import java.math.*;
  3. import java.security.*;
  4. import java.text.*;
  5. import java.util.*;
  6. import java.util.concurrent.*;
  7. import java.util.function.*;
  8. import java.util.regex.*;
  9. import java.util.stream.*;
  10. import static java.util.stream.Collectors.joining;
  11. import static java.util.stream.Collectors.toList;
  13. class Result {
  15.     /*
  16.      * Complete the 'birthdayCakeCandles' function below.
  17.      *
  18.      * The function is expected to return an INTEGER.
  19.      * The function accepts INTEGER_ARRAY candles as parameter.
  20.      */
  22.     public static int birthdayCakeCandles(List<Integer> candles) {
  23.     // Write your code here
  24.         int num;
  25.         long max = 0;
  26.         int result = 0;
  27.         num = candles.size();
  28.         for (int i = 0; i < num; i++) {
  29.             if (max < candles.get(i)){
  30.                 max = candles.get(i);
  31.             }
  32.         }
  33.         for (int i = 0; i < num; i++) {
  34.             if (candles.get(i)==max){
  35.                 result = result + 1;
  36.             }
  37.         }
  39.         return  result;
  40.     }
  42. }
  44. public class Solution {
  45.     public static void main(String[] args) throws IOException {
  46.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  47.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
  49.         int candlesCount = Integer.parseInt(bufferedReader.readLine().trim());
  51.         List<Integer> candles = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
  52.             .map(Integer::parseInt)
  53.             .collect(toList());
  55.         int result = Result.birthdayCakeCandles(candles);
  57.         bufferedWriter.write(String.valueOf(result));
  58.         bufferedWriter.newLine();
  60.         bufferedReader.close();
  61.         bufferedWriter.close();
  62.     }
  63. }