1. 字符串最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开。
知识点 字符串,循环
运行时间限制 0M
内存限制 0
输入
一行字符串，长度小于128。
输出
整数N，最后一个单词的长度。
样例输入 hello world
样例输出 5

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String tmpStr =  sc.nextLine();
            String[] arr = tmpStr.split(" ");
            System.out.println(arr[arr.length - 1].length());
        }
        sc.close();
    }
}

2.合唱队

计算最少出列多少位同学，使得剩下的同学排成合唱队形
说明：
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足存在i（1<=i<=K）使得Ti<T2<......<Ti-1<Ti>Ti+1>......>TK。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
知识点 循环
运行时间限制 0M
内存限制 0
输入
整数N
一行整数，空格隔开，N位同学身高
输出
最少需要几位同学出列
样例输入 8 186 186 150 200 160 130 197 200
样例输出 4

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            int[] arr = new int[n];
            for(int i = 0;i < n;i++){
                arr[i] = sc.nextInt();
            }
            
            int[] inc = new int[n];
            inc[0] = 1;
            for(int i = 1;i < n;i ++){
                inc[i] = 1;
                for(int j = 0;j < i;j ++){
                    if(arr[j] < arr[i] && inc[j] + 1 > inc[i]){
                        inc[i] = inc[j] + 1;
                    }
                }
            }
            
            int[] des = new int[n];
            des[n - 1] = 1;
            for(int i = n -2;i >=0;i --){
                des[i] = 1;
                for(int j = n - 1;j > i;j --){
                    if(arr[j] < arr[i] && des[j] + 1 > des[i]){
                        des[i] = des[j] + 1;
                    }
                }
            }
            
            int max = 0;
            for(int i = 0;i < n;i ++){
                if(inc[i] + des[i] - 1> max){
                    max = inc[i] + des[i] - 1;
                }
            }
            
            System.out.println(n - max);
        }
        sc.close();
    }
}

3.图片整理

Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。
知识点 字符串
运行时间限制 0M
内存限制 0
输入
Lily使用的图片包括"A"到"Z"、"a"到"z"、"0"到"9"。输入字母或数字个数不超过1024。
输出
Lily的所有图片按照从小到大的顺序输出
样例输入 Ihave1nose2hands10fingers
样例输出 0112Iaadeeefghhinnnorsssv

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String str =  sc.nextLine();
            char[] chs = str.toCharArray();
            Arrays.sort(chs);
            System.out.println(chs);
        }
        sc.close();
    }
}

4.名字的漂亮度

给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
知识点 字符串
运行时间限制 0M
内存限制 0
输入
整数N，后续N个名字
N个字符串，每个表示一个名字
输出
每个名称可能的最大漂亮程度
样例输入 2 zhangsan lisi
样例输出 192 101

import java.util.Scanner;
import java.util.Arrays;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextInt()){
            int cnt = Integer.parseInt(sc.nextLine());
            int[] nums = new int[cnt];
            for(int j= 0;j < cnt;j++){
            String str = sc.nextLine().toUpperCase();
            int[] ints = new int[26];
            for(int i = 0;i < str.length();i++){
                ints[str.charAt(i) - 'A'] ++;
            }
            Arrays.sort(ints);
            int result = 0;
            for(int i = 0;i < 26;i++)
                result += (i+1)*ints[i];
            nums[j] = result;
            }
            for(int i = 0;i < cnt;i++)
                System.out.println(nums[i]);
        }
        sc.close();
    }
}

5.（练习用）挑7

输出7有关数字的个数，包括7的倍数，还有包含7的数字（如17，27，37...70，71，72，73...）的个数
知识点 循环
运行时间限制 0M
内存限制 0
输入
一个正整数N。(N不大于30000)
输出
不大于N的与7有关的数字个数，例如输入20，与7有关的数字包括7,14,17.
样例输入 20
样例输出 3

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int N = sc.nextInt();
            int sum = 0;
            for(int i = 1;i <= N;i ++){
                if(i % 7 == 0 || String.valueOf(i).toString().contains("7")) {
                    sum ++;
                }
            }
            System.out.println(sum);
        }
        sc.close();
    }
}

6.字符串加解密

题目描述
1、对输入的字符串进行加解密，并输出。
2加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；
当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；
其他字符不做变化。
3、解密方法为加密的逆过程。
接口描述：
实现接口，每个接口实现1个基本操作：
void Encrypt (char aucPassword[], char aucResult[])：在该函数中实现字符串加密并输出
说明：
1、字符串以\0结尾。
2、字符串最长100个字符。
int unEncrypt (char result[], char password[])：在该函数中实现字符串解密并输出
说明：
1、字符串以\0结尾。
2、字符串最长100个字符。
知识点 字符串
运行时间限制 10M
内存限制 128
输入
输入说明
输入一串要加密的密码
输入一串加过密的密码
输出
输出说明
输出加密后的字符
输出解密后的字符
样例输入 abcdefg BCDEFGH
样例输出 BCDEFGH abcdefg

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str1 = sc.next();
            String str2 = sc.next();

            char aucPassword[] = str1.toCharArray();
            char aucResult[] = new char[aucPassword.length];
            Encrypt(aucPassword, aucResult);
            System.out.println(aucResult);

            char result[] = str2.toCharArray();
            char password[] = new char[result.length];
            unEncrypt(result, password);
            System.out.println(password);
        }
        sc.close();

    }

    public static void Encrypt(char aucPassword[], char aucResult[]) {
        for (int i = 0; i < aucPassword.length; i++) {
            char c = aucPassword[i];
            if (c >= 'a' & c <= 'z') {
                aucResult[i] = (char) ((c + 1 - 'a') % 26 + 'A');
            }
            if (c >= 'A' & c <= 'Z') {
                aucResult[i] = (char) ((c + 1 - 'A') % 26 + 'a');
            }
            if (c >= '0' & c <= '9') {
                aucResult[i] = (char) ((c + 1 - '0') % 10 + '0');
            }
        }
    }

    public static int unEncrypt(char result[], char password[]) {
        for (int i = 0; i < result.length; i++) {
            char c = result[i];
            if (c >= 'a' & c <= 'z') {
                password[i] = (char) ((26 + c - 1 - 'a') % 26 + 'A');
            }
            if (c >= 'A' & c <= 'Z') {
                password[i] = (char) ((26 + c - 1 - 'A') % 26 + 'a');
            }
            if (c >= '0' & c <= '9') {
                password[i] = (char) ((10 + c - 1 - '0') % 10 + '0');
            }
        }
        return 0;
    }
}

7.蛇形矩阵

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
样例输入
5
样例输出
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
接口说明
原型
void GetResult(int Num, char * pResult);
输入参数：
int Num：输入的正整数N
输出参数：
int * pResult：指向存放蛇形矩阵的字符串指针
指针指向的内存区域保证有效
返回值：
void
知识点 数组
运行时间限制 10M
内存限制 128
输入
输入正整数N（N不大于100）
输出
输出一个N行的蛇形矩阵。
样例输入 4
样例输出 1 3 6 10 2 5 9 4 8 7

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int sum = n * (n + 1) / 2;
            int rowStart = 1;
            for (int i = 1; i <= n; i++) {
                rowStart = 1 + i * (i - 1) / 2;
                System.out.print(rowStart);
                int tmp = 1 + i;
                rowStart += tmp;
                while (rowStart <= sum) {
                    System.out.print(" " + rowStart);
                    tmp++;
                    rowStart += tmp;
                }
                System.out.println();
            }
        }
    }
}

8.字符串加密

有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，其余几个丢弃。现在，修改过的那个单词死于字母表的下面，如下所示：
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T R A I L B Z E S C D F G H J K M N O P Q U V W X Y
上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙，Attack AT DAWN(黎明时攻击)就会被加密为Tpptad TP ITVH。
请实现下述接口，通过指定的密匙和明文得到密文。
详细描述：
接口说明
原型：
voidencrypt(char * key,char * data,char * encrypt);
输入参数：
char * key：密匙
char * data：明文
输出参数：
char * encrypt：密文
返回值：
void
知识点 字符串
运行时间限制 10M
内存限制 128
输入
先输入key和要加密的字符串
输出
返回加密后的字符串
样例输入 nihao ni
样例输出 le

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String key = sc.nextLine();
            String data = sc.nextLine();
            char[] result = encrypt(key, data);
            System.out.println(result);
        }
    }

    public static char[] encrypt(String key, String data) {
        key = key.toUpperCase();
        String keyDic = "";
        for (int i = 0; i < key.length(); i++) {
            char c = key.charAt(i);
            if (!keyDic.contains(String.valueOf(c)))
                keyDic += c;
        }
        for (int i = 0; i < 26; i++) {
            char c = (char) ('A' + i);
            if (!keyDic.contains(String.valueOf(c)))
                keyDic += c;
        }
        char[] result = data.toCharArray();
        for (int i = 0; i < data.length(); i++) {
            char c = data.charAt(i);
            if (c >= 'A' && c <= 'Z')
                result[i] = (char) (keyDic.charAt(c - 'A'));
            if (c >= 'a' && c <= 'z')
                result[i] = (char) (keyDic.charAt(c - 'a') - 'A' + 'a');
        }
        return result;
    }
}

9. 公共字串计算

题目标题：
计算两个字符串的最大公共字串的长度，字符不区分大小写
详细描述：
接口说明
原型：
int getCommonStrLength(char * pFirstStr, char * pSecondStr);
输入参数：
char * pFirstStr //第一个字符串
char * pSecondStr//第二个字符串
知识点 字符串,查找
运行时间限制 10M
内存限制 128
输入
输入两个字符串
输出
输出一个整数
样例输入 asdfas werasdfaswer
样例输出 6

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str1 = sc.next();
            String str2 = sc.next();
            int len = str1.length();
            int result = 0;
            for (int i = 0; i < len; i++) {
                for (int j = 0; j <= i; j++) {
                    String subStr = str1.substring(j, j + len - i);
                    if (str2.contains(subStr)) {
                        result = len - i;
                        break;
                    }
                }
                if (result > 0)
                    break;
            }
            System.out.println(result);
        }
        sc.close();
    }
}

10. 多线程

问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]
接口说明：
void init(); //初始化函数
void Release(); //资源释放函数
unsignedint__stdcall ThreadFun1(PVOID pM) ; //线程函数1，传入一个int类型的指针[取值范围：1 – 250，测试用例保证]，用于初始化输出A次数，资源需要线程释放
unsignedint__stdcall ThreadFun2(PVOID pM) ;//线程函数2，无参数传入
unsignedint__stdcall ThreadFun3(PVOID pM) ;//线程函数3，无参数传入
Unsigned int __stdcall ThreadFunc4(PVOID pM);//线程函数4，无参数传入
char g_write[1032]; //线程1,2,3,4按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
知识点 字符串,循环,链表,队列,栈,查找,搜索,排序,树,图,数组,函数,指针,枚举,位运算,结构体,联合体,文件操作,递归
运行时间限制 10M
内存限制 128
输入
输入一个int整数
输出
输出多个ABCD
样例输入 10
样例输出 ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD

import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            long start = System.currentTimeMillis();
            int n = sc.nextInt();
            for (int i = 0; i < n; i++) {
                // System.out.print("ABCD");
                for (int j = 0; j < 4; j++) {
                    Thread t = new MyThread((char) ('A' + j));
                    t.start();
                    t.join();
                }
            }
            System.out.println();
            long end = System.currentTimeMillis();
            System.out.println(end - start);
        }
    }
}

class MyThread extends Thread {
    private char c;

    public MyThread(char c) {
        this.c = c;
    }

    @Override
    public void run() {
        System.out.print(c);
    }
}