Java语法笔记（四）：数组

一维数组

数组的定义

数组的定义方式和变量类似

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[] a;
        a = new int[10];                    //将a初始化为一个长度为10的整形数组
        int [] a1 = new int[10], b;         //定义时初始化，同时定义多个
        float[] f = new float[33];
        double[] d = new double[123];
        char[] c = new char[21];

        String[] strs = new String[10];
    }
}

数组的初始化

在定义时如果不进行初始化，则默认元素都为0，String类型则为null

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[] a = {0, 1, 2};
        int[] b = new int[3];
        char[] d = {'a', 'b', 'c'};
    }
}

访问数组元素

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[] a = {0, 1, 2};

        System.out.printf("%d %d %d\n", a[0], a[1], a[2]);

        a[0] = 5;

        System.out.printf("%d", a[0]);
    }
}

输出

0 1 2
5 

练习1：使用数组实现求斐波那契数列的第 N 项

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] f = new int[n + 1];
        f[0] = 0;
        f[1] = 1;
        for (int i = 2; i < n; i ++)
        {
            f[i] = f[i - 1] + f[i - 2];
        }

        System.out.println(f[n]);
    }
}

练习2：输入一个 n，再输入 n 个整数。将这 n 个整数逆序输出

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] q = new int[n];
        for (int i = 0; i < n; i ++)
            q[i] = sc.nextInt();
        for (int i = n - 1; i >= 0; i --)
            System.out.printf("%d ", q[i]);
    }
}

练习3：输入n个数，将这n个数从小到大输出

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] q = new int[n];
        for (int i = 0; i < n; i ++)
            q[i] = sc.nextInt();
        
        for (int i = 0; i < n; i ++)
        {
            for (int j = i + 1; j < n; j ++)
            {
                if (q[i] > q[j])
                {
                    int tmp = q[i];
                    q[i] = q[j];
                    q[j] = tmp;
                }
            }
        }

        for (int i = 0; i < n; i ++)
        {
            System.out.printf("%d ", q[i]);
        }
    }
}

多维数组

多维数组就是数组的数组。

多维数组的定义

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[][] a = new int[3][4];
        int[][][] b = new int[10][20][30];
    }
}

多维数组的初始化

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[][] a = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}};
        for (int i = 0; i < 4; i ++)
            a[0][i] = 0;                    //第一行全变成0

        for (int i = 0; i < 3; i ++)        //输出三行四列数组
        {
            for (int j = 0; j < 4; j ++)
            {
                System.out.printf("%d ", a[i][j]);
            }
            System.out.println();
        }
    }
}

数组的范围遍历

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[][] a = {
            {0, 1, 2, 3},
            {4, 5, 6, 7},
            {8, 9, 10, 11}
        };

        for (int[] row : a)
        {
            for (int x : row)
                System.out.printf("%d ", x);
            System.out.println();
        } 
    }
}

常用api

1. length：返回数组长度，注意不加小括号
2. Arrays.sort()：数组排序
3. Arrays.toString()：将数组转化为字符串
4. Arrays.deepToString()：将多维数组转化为字符串
5. Arrays.fill(int[] a, int val)：填充数组

数组长度

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        int[][] a = {
            {0, 1, 2, 3},
            {4, 5, 6},
            {8, 9, 10, 11, 12}
        };

        System.out.println(a.length);
        
        for (int i = 0; i < 3; i ++)
            System.out.println(a[i].length);
    }
}

输出

3
4
3
5

数组排序、转化为字符串

//先将一维数组排序，后转化成字符串输出
import java.util.Scanner;
import java.util.Arrays;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] q = new int[n];

        for (int i = 0; i < n; i ++)
            q[i] = sc.nextInt();

        Arrays.sort(q);

        System.out.println(Arrays.toString(q));
    }
}

输入

5
2 1 4 5 3

输出

[1, 2, 3, 4, 5]

数组填充

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int[] a = new int[10];

        Arrays.fill(a, -1);

        System.out.println(Arrays.toString(a));
    }
}

输出

[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]

例题

1. 数组替换

   输入一个长度为 10 的整数数组 X[10]，将里面的非正整数全部替换为 1，输出替换完成后的数组

   输入格式

   输入包含 10 个整数，每个整数占一行。

   输出格式

   输出新数组中的所有元素，每个元素占一行。

   输出格式为 X[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。

   数据范围

   −100≤X[i]≤100

   输入样例

   10
   -9
   0
   -4
   -10
   0
   -2
   -7
   7
   4

   输出样例

   X[0] = 10
   X[1] = 1
   X[2] = 1
   X[3] = 1
   X[4] = 1
   X[5] = 1
   X[6] = 1
   X[7] = 1
   X[8] = 7
   X[9] = 4

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int[] q = new int[10];
           for (int i = 0; i < 10; i ++)
               q[i] = sc.nextInt();
   
           for (int i = 0; i < 10; i ++)
           {
               if (q[i] <= 0)
               q[i] = 1;
           }
   
           for (int i = 0; i < 10; i ++)
               System.out.printf("X[%d] = %d\n", i, q[i]);
       }
   }

2. 数组填充

   输入一个整数 V，输出一个长度为 10 的数组 N，数组中的第一个元素为 V，每个后续元素的值都为上一个元素的值的 2 倍。

   例如，如果输入整数为 1，则数组为：1,2,4,8…

   输入格式

   输入一个整数

   输出格式

   输出数组中的所有元素，每个元素占一行。

   输出格式为 N[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。

   数据范围

   1≤V≤50

   输入样例

   1

   输出样例

   N[0] = 1
   N[1] = 2
   N[2] = 4
   N[3] = 8
   N[4] = 16
   N[5] = 32
   N[6] = 64
   N[7] = 128
   N[8] = 256
   N[9] = 512

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int n = sc.nextInt();
           int[] q = new int[10];
   
           for (int i = 0; i < 10; i ++)
           {
               q[i] = n;
               n *= 2;
           }
   
           for (int i = 0; i < 10; i ++)
               System.out.printf("N[%d] = %d\n", i, q[i]);
       }
   }

3. 数组选择

   输入一个长度为 100 的数组 A，请你按顺序输出其中不大于 10 的所有元素。

   输入格式

   输入 100 个数，每个数占一行，表示数组的所有元素的值。

   每个数可能是整数也可能是浮点数。

   输出格式

   按顺序输出数组中的所有不大于 10 的元素，每个元素占一行。

   输出格式为 A[i] = x，其中 i 为元素编号，x 为元素的值。

   注意，所有的 x 均保留一位小数。

   数据范围

   −100≤A[i]≤100

   输入样例

   0
   -5
   63
   -8.5
   ...

   输出样例

   A[0] = 0.0
   A[1] = -5.0
   A[3] = -8.5
   ...

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           double[] a = new double[100];
           for (int i = 0; i < 100; i ++)
               a[i] = sc.nextDouble();
           
           for (int i = 0; i < 100; i++)
           {
               if (a[i] <= 10)
                   System.out.printf("A[%d] = %.1f\n", i, a[i]);
           }
       }
   }

4. 数组中的行

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组中某一行的元素的平均值或元素的和。

   输入格式

   第一行输入整数 L，表示所求的具体行数（行数从 0 开始计数）。

   第二行包含一个大写字母，若为 S，则表示需要求出第 L 行的元素的和，若为 M，则表示需要求出第 L 行的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]

   输出格式

   输出一个数，表示所求的平均数或元素的和的值，保留一位小数

   数据范围

   −100.0≤ M[i][j] ≤100.0

   输入样例

   7
   S
   8.3 -9.4 -5.6 9.9 2.2 3.2 6.9 7.7 -2.9 -6.3 3.9 -1.4
   -0.5 4.3 -0.3 2.3 0.7 -3.1 -6.3 5.7 -7.7 -3.7 9.7 3.8
   5.8 -9.1 3.5 7.0 2.5 -2.3 6.9 2.7 5.8 -4.6 -7.8 4.3
   -1.7 -8.9 -2.6 7.5 -9.6 6.4 -4.7 -8.0 0.6 6.7 -1.8 -0.4
   -9.8 8.9 -3.8 -2.1 5.8 -9.4 1.3 6.3 -1.3 -6.3 -6.6 8.8
   -6.3 -7.2 -6.3 -5.9 6.2 9.3 2.0 -4.3 2.7 3.6 -4.6 8.7
   3.8 7.4 8.7 -2.8 6.0 -9.2 1.9 3.1 -7.2 -6.0 9.7 -8.4
   -9.8 6.6 8.6 2.3 1.1 -2.9 6.6 -1.5 2.1 -5.1 6.4 -7.5
   -0.6 -1.6 9.5 -6.6 3.0 3.4 -7.5 -7.9 3.1 2.0 1.7 -7.6
   -9.0 9.4 6.6 -0.2 1.4 6.5 8.6 2.0 -1.3 0.2 4.0 -2.4
   -7.3 -6.3 -8.6 -7.5 8.5 1.4 -3.3 7.1 0.8 3.3 3.0 0.1
   3.3 9.0 1.7 5.2 -3.7 8.9 3.8 -7.4 -2.8 0.6 -2.4 7.1

   输出样例

   6.9

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int l = sc.nextInt();
           String s = sc.next();
           double[][] a = new double[12][12];
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   a[i][j] = sc.nextDouble();
   
           if (s.equals("S"))
           {
               double sum = 0;
               for (int i = 0; i < 12; i ++)
                   sum += a[l][i];
               System.out.printf("%.1f", sum);
           }
           else
           {
               double sum = 0;
               for (int i = 0; i < 12; i ++)
                   sum += a[l][i];
               double avg = sum / 12;
               System.out.printf("%.1f", avg);
           }
       }
   }

5. 数组的右上半部分

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右上半部分元素的平均值或元素的和。

   右上半部分是指主对角线上方的部分

   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出右上半部分的元素的和，若为 M，则表示需要求出右上半部分的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]

   输出格式

   输出一个数，表示所求的平均数或元素的和的值，保留一位小数

   数据范围

   −100.0≤M[i][j]≤100.0

   输入样例

   M
   -6.5 8.2 0.7 9.0 0.8 -4.3 0.9 -0.0 -7.9 7.1 -1.6 4.6
   -9.4 -9.0 1.5 -9.0 -5.1 -0.5 -2.8 -9.1 8.0 -6.9 -5.5 -6.6
   -6.8 0.3 3.8 6.1 -9.9 -9.3 8.5 8.6 5.0 6.9 -3.6 -3.0
   -0.8 -1.6 -7.3 -6.7 4.4 -9.1 -9.0 1.6 0.3 -6.0 6.0 -0.8
   -0.8 -6.0 -4.9 -3.9 6.4 6.2 -4.2 -0.9 7.9 1.6 -8.2 -9.2
   7.8 -5.8 -5.8 -5.8 7.2 0.5 -7.9 1.2 -6.8 -9.1 0.3 -1.4
   4.3 -7.2 3.5 -6.4 -9.1 -6.0 3.5 -5.1 -5.6 -6.9 -9.1 -2.1
   -7.6 -7.1 0.7 -1.7 5.0 -9.0 1.4 -6.2 7.6 4.8 -7.5 4.0
   -0.2 0.3 -4.2 8.4 0.7 -6.4 -2.7 3.5 -0.9 3.7 0.9 -2.7
   7.1 0.1 8.4 -5.1 -7.9 -0.5 -5.3 -5.7 -4.6 9.6 -8.3 7.0
   9.6 -9.8 3.3 -9.9 -6.8 6.7 3.1 1.2 -9.5 -4.3 -1.7 -9.7
   1.8 5.0 8.3 -0.7 -0.9 3.2 2.5 0.5 7.3 8.3 0.3 0.9

   输出样例

   -1.2

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] a = new double[12][12];
           double sum = 0;
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   a[i][j] = sc.nextDouble();
   
           for (int i = 0; i < 11; i ++)
               for (int j = i + 1; j < 12; j ++)
                   sum += a[i][j];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 66);
       }
   }

6. 数组的左上半部分

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的左上半部分元素的平均值或元素的和。

   左上半部分是指次对角线上方的部分，如下图所示，黄色部分为对角线，绿色部分为左上半部分：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出左上半部分的元素的和，若为 M，则表示需要求出左上半部分的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或元素的和的值，保留一位小数

   数据范围

   −100.0≤M[i][j]≤100.0

   输入样例

   M
   -0.4 -7.7 8.8 1.9 -9.1 -8.8 4.4 -8.8 0.5 -5.8 1.3 -8.0
   -1.7 -4.6 -7.0 4.7 9.6 2.0 8.2 -6.4 2.2 2.3 7.3 -0.4
   -8.1 4.0 -6.9 8.1 6.2 2.5 -0.2 -6.2 -1.5 9.4 -9.8 -3.5
   -2.3 8.4 1.3 1.4 -7.7 1.3 -2.3 -0.1 -5.4 -7.6 2.5 -7.7
   6.2 -1.5 -6.9 -3.9 -7.9 5.1 -8.8 9.0 -7.4 -3.9 -2.7 0.9
   -6.8 0.8 -9.9 9.1 -3.7 -8.4 4.4 9.8 -6.3 -6.4 -3.7 2.8
   -3.8 5.0 -4.6 2.0 4.0 9.2 -8.9 0.5 -3.9 6.5 -4.3 -9.9
   -7.2 6.2 -1.2 4.1 -7.4 -4.6 4.7 -0.4 -2.2 -9.1 0.4 -5.8
   9.1 -6.4 9.2 0.7 10.0 -5.7 -9.7 -4.4 4.7 4.7 4.9 2.1
   -1.2 -6.2 -8.2 7.0 -5.3 4.9 5.5 7.2 3.4 3.2 -0.2 9.9
   -6.9 -6.2 5.1 8.5 7.1 -0.8 -0.7 2.7 -6.0 4.2 -8.2 -9.8
   -3.5 7.7 5.4 2.8 1.6 -1.0 6.1 7.7 -6.5 -8.3 -8.5 9.4

   输出样例

   -0.8

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] a = new double[12][12];
           double sum = 0;
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   a[i][j] = sc.nextDouble();
   
           for (int i = 0; i < 11; i ++)
               for (int j = 0; j < 11 - i; j ++)
                   sum += a[i][j];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 66);
       }
   }

7. 数组的上方区域

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的上方区域元素的平均值或元素的和。

   数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为上方区域：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出上方区域的元素的和，若为 M，则表示需要求出上方区域的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或和的值，保留一位小数。

   输出结果与标准答案据对误差不超过 0.1 即视为正确。

   输入样例

   S
   -4.8 -8.0 -2.9 6.7 -7.0 2.6 6.5 1.7 1.9 5.6 -1.6 -6.3
   -4.3 1.5 8.7 -0.3 5.4 -9.3 4.8 7.0 3.6 -8.3 -1.0 1.3
   -9.9 9.7 -6.3 5.8 2.9 2.9 -7.7 4.9 -0.6 7.2 6.4 7.7
   2.8 -5.8 -0.0 2.2 4.0 7.7 -3.0 -7.5 -3.5 9.7 -4.3 -8.6
   -1.8 -0.1 5.4 0.6 9.9 -3.7 -1.1 0.8 -0.2 -0.0 9.9 4.5
   3.0 -3.9 2.1 -9.7 5.5 9.4 -4.6 3.3 -9.6 5.1 -4.5 1.5
   4.3 -5.4 -7.9 9.2 -7.7 -9.6 -1.5 -1.6 -7.2 2.0 -3.7 -0.7
   8.0 2.8 -4.1 7.1 8.4 -5.6 3.9 -9.7 -1.1 3.0 -8.5 -3.3
   1.7 5.1 0.1 9.2 4.5 9.7 7.2 8.6 8.7 1.1 6.7 0.3
   -3.6 -7.1 -8.9 7.1 -5.9 1.6 -7.4 6.7 3.9 4.3 -2.4 -3.7
   8.9 -6.2 5.0 -8.6 -1.3 -8.8 2.6 8.9 5.5 9.0 -2.2 -4.4
   5.7 3.7 1.8 -2.1 -7.3 -7.9 4.7 6.0 3.3 -2.8 1.4 -6.9

   输出样例

   21.7

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] a = new double[12][12];
           double sum = 0;
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   a[i][j] = sc.nextDouble();
   
           for (int i = 0; i < 5; i ++)
               for (int j = i + 1; j < 11 - i; j ++)
                   sum += a[i][j];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 30);
       }
   }

8. 数组的左方区域

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的左方区域元素的平均值或元素的和。

   数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为左方区域：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出左方区域的元素的和，若为 M，则表示需要求出左方区域的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或和的值，保留一位小数。

   输入样例

   S
   4.7 -3.3 -2.3 4.5 -7.0 8.7 -4.1 -3.0 -7.6 6.3 -6.6 -4.7
   -7.2 9.3 -7.6 9.1 9.2 9.0 5.5 -7.5 -9.3 -1.6 -3.5 -4.2
   0.5 -7.5 -8.3 -9.0 -6.4 3.8 0.1 -3.5 7.9 2.1 2.4 -6.2
   7.0 5.7 -9.0 -5.8 1.6 2.6 -9.2 -6.2 4.6 8.2 -8.3 -1.4
   3.8 -9.9 6.2 -2.5 -3.5 9.4 1.6 7.0 3.3 -0.5 6.7 6.0
   1.6 -3.8 5.0 8.8 4.2 7.7 0.7 7.4 7.9 -5.9 4.4 3.3
   3.7 6.2 6.7 -1.4 6.1 -6.0 8.5 9.1 5.7 -4.2 5.9 -3.5
   5.0 0.3 2.2 -3.6 6.3 -10.0 9.5 -4.7 2.7 8.1 7.5 -8.4
   -5.7 -0.3 -3.7 -3.3 7.7 9.3 -1.3 1.0 0.3 1.9 9.9 9.0
   -7.4 1.3 -9.6 -3.6 2.2 3.4 -3.6 3.5 8.3 0.5 9.7 -6.8
   1.0 -2.7 -1.5 5.4 -6.5 -3.7 5.6 8.0 -9.9 0.1 2.2 7.6
   5.6 4.3 1.5 -0.8 5.8 -5.1 5.5 6.2 -5.8 8.8 -0.6 -2.3

   输出样例

   13.3

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] a = new double[12][12];
           double sum = 0;
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   a[i][j] = sc.nextDouble();
   
           for (int i = 0; i < 5; i ++)
               for (int j = i + 1; j < 11 - i; j ++)
                   sum += a[j][i];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 30);
       }
   }

9. 平方矩阵

   输入整数 N，输出一个 N 阶的回字形二维数组。

   数组的最外层为 1，次外层为 2，以此类推。
   输入格式

   输入包含多行，每行包含一个整数 N。

   当输入行为 N=0 时，表示输入结束，且该行无需作任何处理。

   输出格式

   对于每个输入整数 N，输出一个满足要求的 N 阶二维数组。

   每个数组占 N 行，每行包含 N 个用空格隔开的整数。

   每个数组输出完毕后，输出一个空行。

   输入样例

   1
   2
   3
   4
   5
   0

   输出样例

   1
   
   1 1
   1 1
   
   1 1 1
   1 2 1
   1 1 1
   
   1 1 1 1
   1 2 2 1
   1 2 2 1
   1 1 1 1
   
   1 1 1 1 1
   1 2 2 2 1
   1 2 3 2 1
   1 2 2 2 1
   1 1 1 1 1

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           while(true)
           {
               int n = sc.nextInt();
               if (n == 0)
                   break;
   
               for (int i = 0; i < n; i ++)
               {
                   for (int j = 0; j < n; j ++)
                   {
                       int up = i + 1;
                       int left = j + 1;
                       int down = n - i;
                       int right = n - j;
                       int x = Math.min(Math.min(up, down), Math.min(left, right));
                       System.out.printf("%d ", x);
                   }
                   System.out.println();
               }
               System.out.println();
           }
       }
   }

习题

1. 数组变换

   输入一个长度为 20 的整数数组 N，将整个数组翻转，使得第一个元素成为倒数第一个元素，第二个元素成为倒数第二个元素，…，倒数第二个元素成为第二个元素，倒数第一个元素成为第一个元素。

   输出翻转后的数组。

   输入格式

   输入包含 20 个整数，每个数占一行。

   输出格式

   输出新数组中的所有元素，每个元素占一行。

   输出格式为 N[i] = x，其中 i 为元素编号（从 0 开始），x 为元素的值。

   输入样例

   0
   -5
   ...
   63
   23

   输出样例

   N[0] = 23
   N[1] = 63
   ...
   N[18] = -5
   N[19] = 0

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int[] a = new int[20];
           for (int i = 0; i < 20; i ++)
               a[i] = sc.nextInt();
   
           for (int i = 0; i < 10; i ++)
           {
               int tmp = a[i];
               a[i] = a[19 - i];
               a[19 - i] = tmp;
           }
   
           for (int i = 0; i < 20; i ++)
               System.out.printf("N[%d] = %d\n", i, a[i]);
       }
   }

2. 斐波那契数列

   输入整数 N，求出斐波那契数列中的第 N 项是多少。

   斐波那契数列的第 0 项是 0，第 1 项是 1，从第 2 项开始的每一项都等于前两项之和。

   输入格式

   第一行包含整数 T，表示共有 T 个测试数据。

   接下来 T 行，每行包含一个整数 N。

   输出格式

   每个测试数据输出一个结果，每个结果占一行，

   结果格式为 Fib(N) = x，其中 N 为项数，x 为第 N 项的值。

   输入样例

   3
   0
   4
   2

   输出样例

   Fib(0) = 0
   Fib(4) = 3
   Fib(2) = 1

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           long t = sc.nextLong();
           long[] a = new long[60];
           a[0] = 0;
           a[1] = 1;
           while (t -- > 0)
           {
               int n = sc.nextInt();
               for (int i = 2; i < 60; i ++)
               {
                   a[i] = a[i - 1] + a[i - 2];
               }
               System.out.printf("Fib(%d) = %d\n", n, a[n]);
           }
       }
   }

3. 最小数和它的位置

   输入一个整数 N 和一个长度为 N 的整数数组 X。

   请你找到数组中最小的元素，并输出它的值和下标。

   注意，如果有多个最小值，则返回下标最小的那个。

   输入格式

   第一行包含整数 N。

   第二行包含 N 个用空格隔开的整数 X[i]。

   输出格式

   第一行输出 Minimum value: x，其中 x 为数组元素最小值。

   第二行输出 Position: y，其中 y 为最小值元素的下标（下标从 0 开始计数）。

   输入样例

   10
   1 2 3 4 -5 6 7 8 9 10

   输出样例

   Minimum value: -5
   Position: 4

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int n = sc.nextInt();
           int[] x = new int[1010];
           for (int i = 0; i < n; i ++)
               x[i] = sc.nextInt();
           int min = x[0];
           int k = 0;
   
           for (int i = 1; i < n; i ++)
           {
               if (x[i] < min)
               {
                   min = x[i];
                   k = i;
               }
           }
   
           System.out.printf("Minimum value: %d\n", min);
           System.out.printf("Position: %d", k);
       }
   }

4. 数组中的列

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组中某一列的元素的平均值或元素的和。

   输入格式

   第一行输入整数 C，表示所求的具体列数（列数从 0 开始计数）。

   第二行包含一个大写字母，若为 S，则表示需要求出第 C 列的元素的和，若为 M，则表示需要求出第 C 列的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或元素的和的值，保留一位小数。

   输入样例

   1
   S
   -9.0 -2.4 -3.3 2.4 -9.7 -5.7 -5.3 6.5 -7.3 4.8 -4.1 3.9
   1.6 -0.9 9.2 -7.5 1.0 -8.0 -4.1 -4.0 -0.1 -9.0 8.4 4.9
   -8.2 -0.3 -5.1 -5.6 6.6 0.9 -1.0 -5.4 -2.1 -4.5 -8.7 -1.1
   -4.2 6.5 -8.2 3.6 -4.6 -9.2 -1.7 6.9 -9.0 -9.8 7.7 -3.4
   -8.0 5.7 4.8 0.3 -1.4 2.8 -6.3 9.3 0.3 6.3 1.5 -1.7
   1.7 -0.0 9.7 -6.6 1.3 -2.0 -6.1 2.0 -7.8 -4.7 -9.1 6.0
   -8.2 -1.7 9.4 -1.2 -1.0 -9.0 -7.0 -6.9 -1.6 -6.8 -6.7 1.8
   4.8 1.3 -6.1 -0.6 0.5 -2.9 -6.8 1.5 5.8 3.2 0.0 7.7
   6.3 1.1 4.7 7.3 7.6 5.6 0.9 9.2 1.3 -4.9 7.8 -4.9
   0.5 3.5 -5.0 9.0 8.8 8.7 7.5 7.5 -9.6 -6.9 -1.6 6.9
   7.8 5.6 -6.4 3.6 2.3 0.5 4.1 6.1 8.6 -9.3 2.2 -0.4
   9.9 0.9 6.4 -2.8 -4.2 -7.6 0.6 9.6 3.0 0.9 5.1 4.5

   输出样例

   19.3

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int c = sc.nextInt();
           String s = sc.next();
           double[][] m = new double[12][12];
           double sum = 0;
   
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   m[i][j] = sc.nextDouble();
   
           for (int i = 0; i < 12; i ++)
               sum += m[i][c];
           
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 12);
   
       }
   }

5. 数组的右下半部分

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右下半部分元素的平均值或元素的和。

   右下半部分是指次对角线下方的部分，如下图所示，黄色部分为对角线，绿色部分为右下半部分：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出右下半部分的元素的和，若为 M，则表示需要求出右下半部分的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或和的值，保留一位小数。

   输入样例

   S
   9.7 -4.9 6.1 -6.1 -9.6 1.0 -3.2 0.6 3.2 -9.8 4.9 1.2
   -2.8 -5.3 2.8 -1.9 -5.4 7.5 -2.0 5.7 2.3 5.3 -7.5 8.9
   6.0 4.3 3.8 -6.7 8.1 -0.5 7.8 -2.2 -1.0 4.0 -4.9 -9.4
   5.4 3.7 -6.5 -3.9 -3.3 4.1 -2.5 -4.7 8.2 1.4 1.8 4.7
   2.4 9.0 -4.3 9.6 8.6 -6.1 -7.4 8.6 5.6 0.5 -0.4 5.2
   -5.2 2.9 -5.6 4.0 -0.2 3.8 -4.1 -1.6 -3.8 -3.1 -1.1 3.3
   -9.4 -1.4 0.6 6.5 -4.3 -8.3 6.1 2.9 -5.2 2.5 9.8 -7.7
   -2.9 -3.6 7.9 -5.8 -4.7 8.2 -6.2 1.0 7.4 -1.0 -4.4 -4.5
   0.1 9.5 4.9 1.5 0.8 -8.2 0.4 9.5 -0.8 -0.9 9.7 -2.1
   0.1 -7.6 7.8 -6.9 5.5 1.4 4.0 7.8 1.0 -1.2 9.7 -1.9
   -4.6 2.3 -5.5 8.2 -4.8 -3.7 5.4 0.2 -2.4 -0.8 7.4 0.0
   -0.1 8.2 0.8 -3.5 -7.6 -0.5 5.6 8.4 -8.6 0.9 9.0 -7.5

   输出样例

   53.0

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] m = new double[12][12];
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   m[i][j] = sc.nextDouble();
           double sum = 0;
   
           for (int i = 1; i <= 11; i ++)
               for (int j = 12 - i; j <= 11; j ++)
                   sum += m[i][j];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 66);
       }
   }

6. 数组的左下半部分

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的左下半部分元素的平均值或元素的和。

   左下半部分是指主对角线下方的部分，如下图所示，黄色部分为对角线，绿色部分为左下半部分：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出左下半部分的元素的和，若为 M，则表示需要求出左下半部分的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或和的值，保留一位小数。
   输入样例

   S
   8.7 5.6 -2.0 -2.1 -7.9 -9.0 -6.4 1.7 2.9 -2.3 8.4 4.0
   -7.3 -2.1 0.6 -9.8 9.6 5.6 -1.3 -3.8 -9.3 -8.0 -2.0 2.9
   -4.9 -0.5 -5.5 -0.2 -4.4 -6.1 7.6 6.9 -8.0 6.8 9.1 -8.5
   -1.3 5.5 4.6 6.6 8.1 7.9 -9.3 9.6 4.6 0.9 -3.5 -4.3
   -7.0 -1.2 7.0 7.1 -5.7 7.8 -2.3 4.3 0.2 -0.4 -6.6 7.6
   -3.2 -5.4 -4.7 4.7 3.6 8.8 5.1 -3.1 -2.9 2.8 -4.3 -1.4
   -1.8 -3.3 -5.6 1.8 8.3 -0.5 2.0 -3.9 -1.0 -8.6 8.0 -3.3
   -2.5 -9.8 9.2 -0.8 -9.4 -0.5 1.6 1.5 3.4 -0.1 7.0 -6.2
   -1.0 4.9 2.2 -8.7 -0.9 4.8 2.3 2.0 -3.2 -7.5 -4.0 9.9
   -1.1 -2.9 8.7 3.6 7.4 7.8 10.0 -9.0 1.6 8.3 6.3 -5.8
   -9.9 0.6 2.0 -3.8 -6.3 0.6 7.3 3.8 -7.1 9.5 2.2 1.3
   -2.8 -9.1 7.1 -0.2 0.6 -6.5 1.1 -0.1 -3.6 4.0 -5.4 1.1

   输出样例

   -2.8

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] m = new double[12][12];
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   m[i][j] = sc.nextDouble();
           double sum = 0;
   
           for (int i = 1; i <= 11; i ++)
               for (int j = 0; j <= i - 1; j ++)
                   sum += m[i][j];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 66);
       }
   }

7. 数组的下方区域

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的下方区域元素的平均值或元素的和。

   数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为下方区域：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出下方区域的元素的和，若为 M，则表示需要求出下方区域的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或和的值，保留一位小数。

   输入样例

   S
   -6.0 0.7 -8.4 -5.7 -4.1 7.6 9.5 -9.7 4.1 0.6 -6.5 -4.9
   6.6 4.9 -3.1 5.3 0.3 -4.5 3.9 -1.5 6.6 7.0 5.1 2.5
   -8.5 1.8 -2.7 0.1 -4.9 -7.2 4.3 6.0 -1.4 2.7 -3.0 2.0
   4.8 -7.0 -1.3 0.8 1.0 4.5 -1.1 -2.9 -3.9 -3.9 -8.9 5.8
   -2.1 -9.6 5.1 0.2 1.0 -1.7 6.4 4.1 2.8 -6.9 2.4 9.3
   -6.0 -9.1 -7.0 -7.0 7.8 5.1 6.9 -7.6 0.4 -7.2 5.5 6.0
   -1.9 5.5 1.9 -8.5 -5.3 2.3 -9.3 2.0 -0.2 1.2 5.6 -1.8
   8.2 2.3 3.5 1.4 4.0 -5.1 -6.9 -2.8 1.7 -7.0 7.8 1.8
   -6.0 -4.1 -4.6 -9.4 -4.9 -4.1 4.2 6.3 -2.8 8.7 8.1 -0.9
   8.8 -6.5 -4.3 6.1 -6.2 -3.9 -7.0 7.3 5.0 -0.9 -0.0 5.6
   -2.4 1.4 8.5 -2.2 0.9 5.3 3.6 8.8 -8.1 3.0 -3.1 6.5
   -3.8 -6.4 2.3 4.2 -9.8 -0.3 -9.9 -7.4 3.5 1.5 -0.2 7.0

   输出样例

   -11.9

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] m = new double[12][12];
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   m[i][j] = sc.nextDouble();
           double sum = 0;
   
           for (int i = 7; i <= 11; i ++)
               for (int j = 12 - i; j <= i - 1; j ++)
                   sum += m[i][j];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 30);
       }
   }

8. 数组的右方区域

   输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右方区域元素的平均值或元素的和。

   数组的两条对角线将数组分为了上下左右四个部分，如下图所示，黄色部分为对角线，绿色部分为右方区域：
   

   输入格式

   第一行输入一个大写字母，若为 S，则表示需要求出右方区域的元素的和，若为 M，则表示需要求出右方区域的元素的平均值。

   接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i+1 行的第 j+1 个数表示数组元素 M[i][j]。

   输出格式

   输出一个数，表示所求的平均数或和的值，保留一位小数。

   输入样例

   S
   2.4 7.8 9.4 -5.6 6.9 -4.9 4.8 0.8 3.6 1.7 -1.4 9.7
   -6.8 -3.7 -2.0 -4.9 -4.5 -5.3 6.1 7.5 -4.3 5.9 -9.5 9.7
   -6.5 -0.4 1.6 3.7 -4.4 -3.3 1.9 7.7 -1.4 4.5 7.4 -3.0
   -1.2 0.4 9.8 9.8 -4.3 -1.3 -1.6 0.5 2.8 -4.0 8.5 3.9
   0.2 -2.0 -6.4 -9.8 3.7 -2.0 1.7 -3.6 -3.4 2.4 -1.2 -3.9
   -8.3 5.8 -1.0 -4.4 1.0 -2.4 2.8 -4.6 2.1 8.7 -6.8 -8.3
   6.3 -6.8 -7.0 9.3 -7.7 -1.7 8.2 -6.5 -1.8 6.7 8.2 4.4
   0.4 8.6 -1.2 8.6 -4.6 1.8 9.6 1.6 2.0 -1.0 3.9 -9.2
   7.5 -3.1 6.2 -4.5 -3.0 2.5 -7.7 2.9 0.3 3.3 -2.7 3.4
   -5.0 3.0 -0.0 4.3 9.5 -0.0 -9.9 -8.6 -0.9 -5.5 7.7 6.5
   4.9 -9.6 -2.9 8.5 2.0 -9.9 -4.9 -1.5 -2.4 -7.6 1.7 8.5
   -6.4 6.8 -3.7 -4.7 0.2 5.8 -5.4 0.6 7.0 -4.2 -7.5 -2.4

   输出样例

   40.9

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String s = sc.next();
           double[][] m = new double[12][12];
           for (int i = 0; i < 12; i ++)
               for (int j = 0; j < 12; j ++)
                   m[i][j] = sc.nextDouble();
           double sum = 0;
   
           for (int i = 7; i <= 11; i ++)
               for (int j = 12 - i; j <= i - 1; j ++)
                   sum += m[j][i];
   
           if (s.equals("S"))
               System.out.printf("%.1f", sum);
           else
               System.out.printf("%.1f", sum / 30);
       }
   }

9. 平方矩阵 II

   输入整数 N，输出一个 N 阶的二维数组。

   数组的形式参照样例。

   输入格式

   输入包含多行，每行包含一个整数 N。

   当输入行为 N=0 时，表示输入结束，且该行无需作任何处理。

   输出格式

   对于每个输入整数 N，输出一个满足要求的 N 阶二维数组。

   每个数组占 N 行，每行包含 N 个用空格隔开的整数。

   每个数组输出完毕后，输出一个空行。

   输入样例

   1
   2
   3
   4
   5
   0

   输出样例

   1
   
   1 2
   2 1
   
   1 2 3
   2 1 2
   3 2 1
   
   1 2 3 4
   2 1 2 3
   3 2 1 2
   4 3 2 1
   
   1 2 3 4 5
   2 1 2 3 4
   3 2 1 2 3
   4 3 2 1 2
   5 4 3 2 1

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           while (true)
           {
               int n = sc.nextInt();
               if (n == 0)
                   break;
   
               for (int i = 0; i < n; i ++)
               {
                   for (int j = 0; j < n; j ++)
                       System.out.printf("%d ", Math.abs(i - j) + 1);
                   
                   System.out.println();
               }
               System.out.println();
           }
           
       }
   }

10. 平方矩阵 III

    输入整数 N，输出一个 N 阶的二维数组 M。

    这个 N 阶二维数组满足 M[i][j]=2i+j。

    具体形式可参考样例。

    输入格式

    输入包含多行，每行包含一个整数 N。

    当输入行为 N=0 时，表示输入结束，且该行无需作任何处理。

    输出格式

    对于每个输入整数 N，输出一个满足要求的 N 阶二维数组。

    每个数组占 N 行，每行包含 N 个用空格隔开的整数。

    每个数组输出完毕后，输出一个空行。

    输入样例

    1
    2
    3
    4
    5
    0

    输出样例

    1
    
    1 2
    2 4
    
    1 2 4
    2 4 8
    4 8 16
    
    1 2 4 8
    2 4 8 16
    4 8 16 32
    8 16 32 64
    
    1 2 4 8 16
    2 4 8 16 32
    4 8 16 32 64
    8 16 32 64 128
    16 32 64 128 256

    解

    import java.util.Scanner;
    
    public class Main
    {
        public static void main(String[] args)
        {
            Scanner sc = new Scanner(System.in);
            while (true)
            {
                int n = sc.nextInt();
                if (n == 0) break;
                int[][] a = new int[n][n];
                a[0][0] = 1;
    
                for (int i = 1; i < n; i ++)
                    a[0][i] = a[0][i - 1] * 2;
    
                for (int i = 1; i < n; i ++)
                    for (int j = 0; j < n; j ++)    
                        a[i][j] = a[i - 1][j] * 2;
    
                for (int i = 0; i < n; i ++)
                {
                    for (int j = 0; j < n; j ++)
                        System.out.printf("%d ", a[i][j]);
                    System.out.println();
                }
                
                System.out.println();
            }
        }
    }

11. 蛇形矩阵

    输入两个整数 n 和 m，输出一个 n 行 m 列的矩阵，将数字 1 到 n×m 按照回字蛇形填充至矩阵中。

    具体矩阵形式可参考样例。

    输入格式

    输入共一行，包含两个整数 n 和 m。

    输出格式

    输出满足要求的矩阵。

    矩阵占 n 行，每行包含 m 个空格隔开的整数。

    输入样例

    3 3

    输出样例

    1 2 3
    8 9 4
    7 6 5

    解

    import java.util.Scanner;
    
    public class Main
    {
        public static void main(String[] args)
        {
            Scanner sc= new Scanner(System.in);
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[][] res = new int[n][m];
            int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
            int x = 0, y = 0, d = 1;
    
            for (int i = 1; i <= n * m; i ++)
            {
                res[x][y] = i;
                int a = x + dx[d], b = y + dy[d];
                if (a < 0 || a >= n || b < 0 || b >= m || res[a][b] > 0)
                {
                    d = (d + 1) % 4;
                    a = x + dx[d];
                    b = y + dy[d];
                }
                x = a;
                y = b;
            }
    
            for (int[] row : res)
            {
                for (int val : row)
                {
                    System.out.printf("%d ", val);
                }
                System.out.println();
            }
        }
    }