java编程强化练习(四)

2023-12-18 09:46:10

1.最长连续升序整数序列

【问题描述】

输入一组无序的整数(整数都大于等于0),编程求出其中最长的连续升序子序列(该序列中后一个整数比前一个整数多1,序列的长度是指序列中整数的个数,长度应大于等于2)。例如输入13个整数:3520 0 3 89 56 88 3521 9 90 1 99 2 87,其中连续升序子序列有3个:3520 3521,0 1 2 3和87 88 89 90,长度分别为2、4、4,所以后两个子序列都是最长的连续升序子序列。

【输入形式】

先从标准输入读入整数的个数(大于等于1,小于等于100),然后在下一行输入这些整数,各整数之间以一个空格分隔。

【输出形式】

先向标准输出输出最长连续升序子序列的长度,然后从下一行开始按升序分行输出最长连续升序子序列,各整数之间以一个空格分隔,每行最后一个整数后也要有一个空格。

若没有连续升序子序列,直接输出数字0。

【样例输入】

13

3520 0 3 89 56 88 3521 9 90 1 99 2 87

【样例输出】

4

0 1 2 3?

87 88 89 90?

【样例说明】

输入的整数个数为13,其中最长连续升序子序列的长度为4,有两个最长连续升序子序列,分别按升序分行输出。

【评分标准】该程序要求输出最长连续升序子序列。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class LongestAscendingSequence {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] numbers = new int[n];
        for (int i = 0; i < n; i++) {
            numbers[i] = scanner.nextInt();
        }
        scanner.close();

        Arrays.sort(numbers); // 对输入数据进行排序

        ArrayList<ArrayList<Integer>> allSequences = new ArrayList<>();
        ArrayList<Integer> currentSequence = new ArrayList<>();
        int maxLength = 0;

        for (int i = 0; i < n - 1; i++) {
            if (numbers[i + 1] - numbers[i] == 1) {
                if (currentSequence.isEmpty()) {
                    currentSequence.add(numbers[i]);
                }
                currentSequence.add(numbers[i + 1]);
            } else {
                if (currentSequence.size() > maxLength) {
                    allSequences.clear();
                    allSequences.add(new ArrayList<>(currentSequence));
                    maxLength = currentSequence.size();
                } else if (currentSequence.size() == maxLength) {
                    allSequences.add(new ArrayList<>(currentSequence));
                }
                currentSequence.clear();
            }
        }

        if (currentSequence.size() > maxLength) {
            allSequences.clear();
            allSequences.add(new ArrayList<>(currentSequence));
            maxLength = currentSequence.size();
        } else if (currentSequence.size() == maxLength) {
            allSequences.add(new ArrayList<>(currentSequence));
        }

        if (maxLength >= 2) {
            System.out.println(maxLength);
            for (ArrayList<Integer> sequence : allSequences) {
                for (int num : sequence) {
                    System.out.print(num + " ");
                }
                System.out.println();
            }
        } else if (maxLength == 1) {
            System.out.println("2"); // 如果只有两个连续的整数,输出长度为2
            for (ArrayList<Integer> sequence : allSequences) {
                for (int num : sequence) {
                    System.out.print(num + " ");
                }
                System.out.println();
            }
        } else {
            System.out.println("0");
        }
    }
}

2.整数出现次数

【问题描述】

输入一组无序的整数,编程输出其中出现次数最多的整数及其出现次数。

【输入形式】

先从标准输入读入整数的个数(大于等于1,小于等于100),然后在下一行输入这些整数,各整数之间以一个空格分隔。

【输出形式】

在标准输出上输出出现次数最多的整数及其出现次数,两者以一个空格分隔;若出现次数最多的整数有多个,则按照整数升序分行输出。

【样例输入】

10

0 -50 0 632 5813 -50 9 -50 0 632

【样例输出】

-50 3

0 3

【样例说明】

输入了10个整数,其中出现次数最多的是-50和0,都是出现3次。

【评分标准】该程序要求输出出现次数最多的整数和出现次数。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeSet;

public class MostFrequentInteger {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        scanner.close();

        Map<Integer, Integer> countMap = new HashMap<>();

        for (int num : arr) {
            if (countMap.containsKey(num)) {
                countMap.put(num, countMap.get(num) + 1);
            } else {
                countMap.put(num, 1);
            }
        }

        int maxCount = 0;
        TreeSet<Integer> maxCountNumbers = new TreeSet<>();

        for (int num : countMap.keySet()) {
            int count = countMap.get(num);
            if (count > maxCount) {
                maxCount = count;
                maxCountNumbers.clear();
                maxCountNumbers.add(num);
            } else if (count == maxCount) {
                maxCountNumbers.add(num);
            }
        }

        for (int num : maxCountNumbers) {
            System.out.println(num + " " + maxCount);
        }
    }
}

3.消除游戏

【问题描述】

消除类游戏是深受大众欢迎的一种游戏,游戏在一个包含有n行m列的游戏棋盘上进行,棋盘的每一行每一列的方格上放着一个有颜色的棋子,当一行或一列上有连续三个或更多的相同颜色的棋子时,这些棋子都被消除。当有多处可以被消除时,这些地方的棋子将同时被消除。

现在给定一个n行m列的棋盘,棋盘中的每一个方格上有一个棋子(用数字1-9表示各种颜色的棋子),请给出经过消除后的棋盘。

请注意:一个棋子可能在某一行和某一列同时被消除。

【输入形式】

从标准输入读取数据,第一行包含两个整数n和m,分别表示棋盘的行数和列数(行数和列数都大于等于3,小于等于9),以一个空格分隔这两个整数。

接下来输入n行,每行m个整数,用一个空格分隔各个整数,这些整数分别表示每一个方格中棋子的颜色(大于等于1,小于等于9)。

【输出形式】

向标准输出上输出n行,每行m个整数,相邻整数之间以一个空格分隔,表示经过消除后的棋盘。如果一个方格中的棋子被消除,则对应的方格输出数字0,否则输出代表原棋子颜色的整数。每行最后一个整数后也要有一个空格。

【样例1输入】

4 5

2 2 3 1 2

3 4 5 1 4

2 3 2 1 3

2 2 2 4 4

【样例1输出】

2 2 3 0 2?

3 4 5 0 4?

2 3 2 0 3?

0 0 0 4 4?

【样例1说明】

棋盘中第4列的1和第4行的2可以被消除,其它方格中的棋子均被保留。

【样例2输入】

4 5

2 2 3 1 2

3 1 1 1 1

2 3 2 1 3

2 2 3 3 3

【样例2输出】

2 2 3 0 2?

3 0 0 0 0?

2 3 2 0 3?

2 2 0 0 0?

【样例2说明】

棋盘中第4列的1,第二行的1和第4行的3可以被消除,其它方格中的棋子均被保留。

【评分标准】该程序要求输出消除后的棋盘状态。

import java.util.Scanner;

public class EliminationGame{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] board = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                board[i][j] = scanner.nextInt();
            }
        }
        scanner.close();
        eliminate(board, n, m);
        printBoard(board, n, m);
    }

    public static void eliminate(int[][] board, int n, int m) {
        boolean[][] eliminated = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int color = board[i][j];

                if (color != 0) {

                    int count = 1;
                    for (int k = j + 1; k < m && board[i][k] == color; k++) {
                        count++;
                    }
                    if (count >= 3) {
                        for (int k = j; k < j + count; k++) {
                            eliminated[i][k] = true;
                        }
                    }

                    count = 1;
                    for (int k = i + 1; k < n && board[k][j] == color; k++) {
                        count++;
                    }
                    if (count >= 3) {
                        for (int k = i; k < i + count; k++) {
                            eliminated[k][j] = true;
                        }
                    }
                }
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (eliminated[i][j]) {
                    board[i][j] = 0;
                }
            }
        }
    }

    public static void printBoard(int[][] board, int n, int m) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(board[i][j]);
                if (j < m - 1) {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

4.小数分数转换

【问题描述】

从标准输入中输入一个小数,编写程序将其转换成相应的分数显示,即转换为几又几分之几。
要求:
1、输入的小数包括整数部分、小数点和小数部分;整数部分和小数部分最多有7位数字;整数部分可以为0,若整数部分大于等于1,则其最高位不为0;小数部分的末尾数字不为零。
2、输出的分数应为最简分数,由三个数字组成:第一个数字代表整数部分(若分数小于1,则为0,否则输出的整数的最高位不为0),第二个数字代表分子,第三个数字代表分母,分子比分母小且不能再约分。

【输入形式】

从标准输入中输入一个小数后打回车。

【输出形式】

将三个整数输出到标准输出,并且分别以一个空格分隔,最后一个整数后没有空格,有回车换行。

【样例1输入】

0.35

【样例1输出】

0 7 20

【样例2输入】

1050.0144

【样例2输出】

1050 9 625

【样例说明】

样例1中输入的小数为0.35,整数部分为0,小数部分转换为分数为35/100,约分成最简分数为7/20。
样例2中输入的小数为1050.0144,整数部分为1050,小数部分转换为分数为144/10000,约分成最简分数为9/625。


【评分标准】该题要求编程实现小数到分数的转换。

import java.util.Scanner;

public class DecimalToFraction {


    public static int gcd(int a, int b) {
        int t = 0;
        if(a < b){
            t = a;
            a = b;
            b = t;
        }
        int c = a % b;
        if(c == 0){
            return b;
        }
        else{
            return gcd(b, c);
        }
    }


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);

        String number;
        int decimal;
        int a, b,c;
        int g;

        number = in.next();

        String[] array = new String[2];
        array = number.split("\\.");
        a = Integer.parseInt(array[0]);
        decimal = Integer.parseInt(array[1]);
//		System.out.println(decimal);

        int length = array[1].length();
        b = decimal;
        c = (int)Math.pow(10, length);
//		System.out.println(b);
//		System.out.println(c);
        g = gcd(b,c);
        System.out.println(a + " " + b/g +" " + c/g);

    }

}

5.最大数
【输入形式】从键盘输入三个整数,以空格间隔
【输出形式】输出最大的一个整数
【样例输入】1 2 3回车
【样例输出】3
【样例说明】
【评分标准】10

import java.util.Scanner;

public class MaxNumber {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num1 = scanner.nextInt();
        int num2 = scanner.nextInt();
        int num3 = scanner.nextInt();
        scanner.close();

        int max = Math.max(num1, Math.max(num2, num3));

        System.out.println(max);
    }
}

6.?程序结构抽取

【问题描述】

有一种比较两程序是否相似的方法:将程序中控制结构信息按出现次序抽取出来形成一个控制流串,然后依据两个程序的控制流串来计算两个程序的相似度。

编写一程序,抽取一个C程序的控制流串。要求只考虑if, else, for, while, switch, case等控制流关键字,其它控制流不被考虑。被处理的C程序满足:
1. 能够通过C编译;
2.?一行可能有多条语句;
3. 注释、字符串常量及其它标识符中不含控制流关键字串;

【输入形式】

要处理的C程序保存在当前目录下,文件名为:in.c。

【输出形式】

按出现的先后顺序将控制流关键字串输出到当前目录下的out.txt文件中,各关键字串之间没有任何分隔符。若没有控制流关键字,则将No answer输出到文件中。

【样例输入1】

假设当前目录下in.c的内容为:
#include <stdio.h>
int main()
{
??? int n,a,c1,c2,i;
??? scanf("%d",&n);
??? c1=c2=0;
??? for ( i=0; i<n; i++ )
??? {
??????? scanf("%d",&a);
??????? if ( a>=0 )
?????????? c1++;
??????? else
?????????? c2++;
??? }
??? printf("%d %d",&c1,&c2);
}

【样例输出1】

在当前目录下将创建out.txt文件,其内容应为:
forifelse

【样例输入2】

假如当前目录下in.c源程序风格不太好,内容如下:
#include <stdio.h>
main()
{
int a,b,max,min;
scanf("%d%d",&a,&b);
if(a>b){max=a;min=b;}else if(a<b){max=b;min=a;}else{max=min=a;}
printf("%d %d",max,min);
}

【样例输出2】

在当前目录下将创建out.txt文件,其内容应为:
ifelseifelse

【样例说明】

样例1中源程序只包含for、if、else三个控制流关键字,因此按照出现顺序将这三个关键字输出到文件out.txt中;样例2中控制流关键字出现顺序为:if、else、if、else,故将这四个关键字输出到out.txt中。

算法提示:从in.c中读取标识符时,可将除字母、数字、下划线之外的其它字符作为标识符的分隔符。

【评分标准】

该题要求按顺序输出控制流关键字,共有5个测试点。


import java.io.*;
import java.util.regex.*;

public class ControlFlowExtractor {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("in.c");
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            FileWriter fileWriter = new FileWriter("out.txt");

            String line;
            String controlFlowString = "";
            boolean insideComment = false;

            Pattern controlFlowPattern = Pattern.compile("\\b(if|else|for|while|switch|case)\\b");

            while ((line = bufferedReader.readLine()) != null) {
                line = line.trim();

                if (line.startsWith("/*")) {
                    insideComment = true;
                }

                if (line.endsWith("*/")) {
                    insideComment = false;
                }

                if (!insideComment) {
                    Matcher matcher = controlFlowPattern.matcher(line);
                    while (matcher.find()) {
                        controlFlowString += matcher.group();
                    }
                }
            }

            if (!controlFlowString.isEmpty()) {
                fileWriter.write(controlFlowString);
            } else {
                fileWriter.write("No answer");
            }

            bufferedReader.close();
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7.单词索引编排

【问题描述】

打开一英文文章(保存在一个现有文件in.txt中),为该文件生成词汇表(存到另一个文件out.txt中),要求词汇表中的单词以字典序由小到大存放(只由连续字母组成,且全为小写字母,不重复)。
假设:
1、该文章有可能没有经过排版,格式有可能杂乱无章,也有可能没有写完整。
2、文章中的单词个数不超过1000个,每个单词的长度不超过50个字母。

【输入形式】

保存英文文章的文件in.txt位于当前目录下。

【输出形式】

将生成的词汇表以字典序由小到大输出到当前目录下的文件out.txt中,每个单词单独占一行。

【样例输入1】

假设文件in.txt内容为:

There are two versions of the international standards for C.
The first version was ratified in 1989 by the American National
Standards Institue (ANSI) C standard committee.It is often
referred as ANSI C or C89. The secand C standard was completed
in 1999. This standard is commonly referred to as C99. C99 is a
milestone in C's evolution into a viable programming language
for numerical and scientific computing.

【样例输出1】
文件out.txt中的词汇表应为:

a
american
and
ansi
are
as
by
c
committee
commonly
completed
computing
evolution
first
for
in
institue
international
into
is
it
language
milestone
national
numerical
of
often
or
programming
ratified
referred
s
scientific
secand
standard
standards
the
there
this
to
two
version
versions
viable
was

【样例输入2】

假设文件in.txt内容为:

There are two versions of the international standards for

【样例输出2】
文件out.txt中的词汇表应为:

are
for
international
of
standards
the
there
two
versions

【样例说明】

将in.txt中出现的所有由字母组成的单词(出现的单个字母也作为单词)全部转换成小写后,按照字典序输出到文件out.txt中(每个单词独占一行,重复出现的只输出一次)。
注意:样例2中in.txt文件内容还不完整,单词for后没有任何字符。

【评分标准】本题要求为指定的文件编写单词索引。

import java.io.*;
import java.util.*;

public class WordIndexer  {

    public static void main(String[] args) {
        try {

            BufferedReader reader = new BufferedReader(new FileReader("in.txt"));
            String line;
            StringBuilder content = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                content.append(line).append(" ");
            }
            reader.close();


            String[] words = content.toString().toLowerCase().split("\\P{L}+");


            Set<String> uniqueWords = new TreeSet<>(Arrays.asList(words));


            BufferedWriter writer = new BufferedWriter(new FileWriter("out.txt"));
            for (String word : uniqueWords) {
                writer.write(word);
                writer.newLine();
            }
            writer.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8.单词检查

【问题描述】

已知有一个正确单词索引表(保存在当前目录下的文件index.txt中,且全为小写字母,按照字典序由小到大排列,每个单词独占一行),编写程序利用该单词表对某一英文文章(保存在当前目录下的另一个文件in.txt中)进行单词正确性检查,若该英文文章中出现的单词(只有连续字母组成)没有出现在单词索引文件中(检查时大小写无关),则将该出错的单词(其中的字母全部转换为小写)输出到当前目录下的另一文件error.txt中,每个单词独占一行,并且以字典序由小到大的顺序输出。
假设:
1、in.txt中的文章有可能没有经过排版,格式有可能杂乱无章,也有可能没有写完整。
2、index.txt中的单词个数不超过1000个,每个单词的长度不超过50个字母。
3、若出错的单词多次出现,则多次输出。

【输入形式】

保存单词索引表的文件index.txt和保存英文文章的文件in.txt都位于当前目录下。

【输出形式】

将出错的单词以字典序由小到大的顺序输出到当前目录下的文件error.txt中,每个单词单独占一行,多次出错的单词多次输出。若没有出现错误单词,则什么也不输出。

【样例输入1】

假设文件in.txt内容为:

There are two verrsions of the international standards for C.
Thee first version was ratified in 1989 by the American National
Standards Institue (ANS1) C standard committee.It is often
referred as ANS1 C or C89. The secand C standard was completed
in 1999. This standard is comonly referred to as C99. C99 is a
milestone in C's evolution into a viable programing languga
for numerical and scientific computing.

文件index.txt中的单词索引表内容为:

a
american
and
ansi
are
as
by
c
committee
commonly
completed
computing
evolution
first
for
in
institue
international
into
is
it
language
milestone
national
numerical
of
often
or
programming
ratified
referred
s
scientific
secand
standard
standards
the
there
this
to
two
version
versions
viable
was

【样例输出1】

文件error.txt中出错的单词应为:

ans
ans
comonly
languga
programing
thee
verrsions

【样例1说明】

用index.txt中的单词索引表对in.txt中出现的每一个单词进行检查,检查时大小写无关,所以第一个单词There出现在索引表中,不是错误单词;单词verrsions没有出现在索引表中,拼写错误,所以作为出错单词输出;单词ANSI拼写成了ANS1,将其中字母都转换为小写后输出,并且多次出现,多次输出;其他出错单词类似。错误单词输出按照字典序由小到大输出到error.txt文件中。

【样例输入2】

假设文件in.txt内容为:

There are two versions of the international standard fo

文件index.txt中的单词索引表内容为:

are
for
international
of
standards
the
there
two
versions

【样例输出2】

文件error.txt中出错的单词应为:

fo
standard

【样例2说明】

文件in.txt中的单词standard没有出现在索引表文件index.txt中,所以作为错误单词输出。
注意:样例2中in.txt文件内容还不完整,最后的单词fo后没有任何字符,fo也没有出现在索引表中,所以也作为错误单词输出。

【评分标准】本题要求对文章的单词进行检查。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class WordChecker {
    public static void main(String[] args) {
        String indexFile = "index.txt";
        String inputFile = "in.txt";
        String outputFile = "error.txt";

        List<String> indexWords = readIndexWords(indexFile);
        Set<String> indexSet = new HashSet<>(indexWords);
        List<String> errorWords = findErrorWords(inputFile, indexSet);
        writeErrorWords(outputFile, errorWords);
    }

    private static List<String> readIndexWords(String indexFile) {
        List<String> indexWords = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(indexFile))) {
            String line;
            while ((line = reader.readLine()) != null) {
                indexWords.add(line.toLowerCase());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return indexWords;
    }

    private static List<String> findErrorWords(String inputFile, Set<String> indexSet) {
        List<String> errorWords = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(inputFile))) {
            String line;
            while ((line = reader.readLine()) != null) {
                String[] words = line.split("[^a-zA-Z]+"); // Split by non-alphabet characters
                for (String word : words) {
                    if (!word.isEmpty() && !indexSet.contains(word.toLowerCase())) {
                        errorWords.add(word.toLowerCase());
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        Collections.sort(errorWords); // Sort error words in alphabetical order
        return errorWords;
    }

    private static void writeErrorWords(String outputFile, List<String> errorWords) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) {
            for (String word : errorWords) {
                writer.write(word);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文章来源:https://blog.csdn.net/m0_75017568/article/details/135053020
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。