1.字符串最后一个单词的长度
计算字符串最后一个单词的长度，单词以空格隔开。
输入描述:
一行字符串，非空，长度小于5000。
输出描述:
整数N，最后一个单词的长度。
示例1
输入
hello world
输出
5
import java.util.Scanner; /** * 计算字符串最后一个单词的长度，单词以空格隔开。 * */ public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); while (scanner.hasNext()) { String s = scanner.nextLine(); String[] words = s.split(" "); System.out.println(words[words.length-1].length()); } } }
2.计算字符个数
写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:
第一行输入一个有字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述:
输出输入字符串中含有该字符的个数。
示例1
输入
ABCDEF A
输出
1
import java.util.Scanner; /** * 接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。 * */ public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s = input.next().toUpperCase(); char c = input.next().toUpperCase().charAt(0); int count = getNum(s, c); System.out.println(count); } /*public static int getNum(String s, char c) { char[] arr = s.toCharArray(); int count = 0; for (char i : arr) { if (i == c) count++; } return count; }*/ public static int getNum(String s, char c) { int count = 0; for (int i = 0; i < s.length(); i++) { if (c == s.charAt(i)) count++; } return count; } }
3.去重和排序
对一组数据完成去重与排序的工作，注意第一个数字为数据的个数。
import java.util.Scanner; import java.util.Set; import java.util.TreeSet; /** * 对一组数据完成去重与排序的工作 * */ public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { int num = input.nextInt(); Set<Integer> set = new TreeSet<>(); for (int i = 0; i < num; i++) { set.add(input.nextInt()); } for (Integer i : set) { System.out.print(i + " "); } System.out.println(); } } }
4.字符串分割与补零
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述:
连续输入字符串(输入2次,每个字符串长度小于100)
输出描述:
输出到长度为8的新字符串数组
示例1
输入
abc 123456789
输出
abc00000 12345678 90000000
import java.util.Scanner; /** * •连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； * •长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 */ public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNextLine()) { String s = input.nextLine(); splitString(s); System.out.println(); } } public static void splitString(String s) { while (s.length() >= 8) { System.out.print(s.substring(0, 8)+" "); s = s.substring(8); } if (s.length() < 8 && s.length() > 0) { s = s + "0000000"; System.out.print(s.substring(0, 8)); } } }
5.十六进制转换为十进制
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入 ）
输入描述:
输入一个十六进制的数值字符串。
输出描述:
输出该数值的十进制字符串。
示例1
输入
0xA
输出
10
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String s = input.nextLine(); /* char[] arr = s.toCharArray(); int result = 0; int index = 0; for (int i = arr.length - 1; i > 1; i--) { int num = conversion(arr[i]); result += num * Math.pow(16, index++); } System.out.println(result);*/ System.out.println(conversion(s.substring(2))); } input.close(); }public static int conversion(String s) { int n = 0; int count = 0; int temp = 0; char ch; while (count < s.length()) { ch = s.charAt(s.length() - count - 1); if (ch >= '0' && ch <= '9') { temp = ch - '0'; } else if (ch >= 'A' && ch <= 'Z') { temp = ch - 'A' + 10; } else if (ch >= 'a' && ch <= 'z') { temp = ch - 'a' + 10; } else { break; } n += temp * Math.pow(16, count); count++; } return n; } }
6.质数因子
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（如180的质因子为2 2 3 3 5 ）
最后一个数后面也要有空格
输入描述:
输入一个long型整数
输出描述:
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
示例1
输入
180
输出
2 2 3 3 5
import java.util.Scanner; /** * 功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）最后一个数后面也要有空格 */ public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); Long number = input.nextLong(); if (number < 2) { input.close(); return; } isPrimeFactors(number); input.close(); } public static void isPrimeFactors(Long number) { while (number != 1) { for (int i = 2; i <= number; i++) { if (number % i == 0) { number = number / i; System.out.print(i + " "); break; } } } } }
7.四舍五入
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
输入描述:
输入一个正浮点数值
输出描述:
输出该数值的近似整数值
示例1
输入
5.5
输出
6
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); double number = input.nextDouble(); int res = round(number); System.out.println(res); input.close(); } public static int round(double number) { int res = (int) number; return (number - res) >= 0.5 ? res + 1 : res; } }
8.对表索引相同的记录进行合并
数据表记录包含表索引和数值（int范围的整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
输入描述:
先输入键值对的个数
然后输入成对的index和value值，以空格隔开
输出描述:
输出合并后的键值对（多行）
示例1
输入
4 0 1 0 2 1 2 3 4
输出
0 3 1 2 3 4
import java.util.Scanner; import java.util.TreeMap; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int num = Integer.parseInt(input.nextLine()); TreeMap<Integer, Integer> map = new TreeMap<>(); for (int i = 0; i < num; i++) { String s = input.nextLine(); getResult(s, map); } for (Integer key : map.keySet()) { System.out.println(key + " " + map.get(key)); } } public static void getResult(String s, TreeMap<Integer, Integer> map) { String[] arr = s.split(" "); int key = Integer.parseInt(arr[0]); int value = Integer.parseInt(arr[1]); if (map.containsKey(key)) { value += map.get(key); map.put(key, value); } else { map.put(key, value); } } }
9.提取不重复的整数
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例1
输入
9876673
输出
37689
import java.util.LinkedHashSet; import java.util.Scanner; public class T09提取不重复的整数 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s = input.nextLine(); LinkedHashSet<Character> set = new LinkedHashSet<>(); for (int i = s.length() - 1; i >= 0; i--) { char ch = s.charAt(i); set.add(ch); } for (Character ch : set) { System.out.print(ch); } input.close(); } }
10.统计字符个数
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
示例1
输入
abc
输出
3
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s = input.nextLine(); int count = 0; int[] arr = new int[128]; for (int i = 0; i < s.length(); i++) { if (arr[s.charAt(i)] == 0) { arr[s.charAt(i)]++; } } for (int i = 0; i < arr.length; i++) { if (arr[i] != 0) { count++; } } System.out.println(count); } }
11.按照字典的顺序排列字符串
给定n个字符串，请对n个字符串按照字典序排列。
输入描述:
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述:
数据输出n行，输出结果为按照字典序排列的字符串。
示例1
输入
9 cap to cat card two too up boat boot
输出
boat boot cap card cat to too two up
import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int num = Integer.parseInt(input.nextLine()); ArrayList<String> list = new ArrayList<>(); for (int i = 0; i < num; i++) { String s = input.nextLine(); list.add(s); } Collections.sort(list); for (String s : list) { System.out.println(s); } input.close(); } }
12.密码验证合格程序
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG
示例1
输入
021Abc9000 021Abc9Abc1 021ABC9000 021$bc9000
输出
OK NG NG OK
import java.util.Scanner; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String str = input.nextLine(); String res = isPassword(str); System.out.println(res); } } public static String isPassword(String str) { //1.判断长度 if (str == null || str.length() < 9) { return "NG"; } int count = 0; //2.判断是否含有三种以上字符 /*Pattern p1 = Pattern.compile("[a-z]"); Matcher m1 = p1.matcher(str); if (m1.find()) count++; Pattern p2 = Pattern.compile("[A-Z]"); Matcher m2 = p2.matcher(str); if (m2.find()) count++; Pattern p3 = Pattern.compile("[0-9]"); Matcher m3 = p3.matcher(str); if (m3.find()) count++; Pattern p4 = Pattern.compile("[^a-zA-Z0-9]"); Matcher m4 = p4.matcher(str); if (m4.find()) count++;*/ if (Pattern.matches(".*[a-z]+.*", str)) //+表达式至少出现1次，相当于 {1,} count++; if (Pattern.matches(".*[A-Z]+.*", str)) //*表达式至少出现0次，表达式不出现或出现任意次，相当于 {0,} count++; if (Pattern.matches(".*[0-9]+.*", str)) //.小数点可以匹配任意一个字符(除了换行符) count++; if (Pattern.matches(".*[^a-zA-Z0-9]+.*", str)) count++; if (count < 3) { return "NG"; } else { return isHasSubString(str); } } private static String isHasSubString(String str) { for (int i = 0; i < str.length() - 3; i++) { String str1 = str.substring(i, i + 3); String str2 = str.substring(i + 3); if (str2.contains(str1)) return "NG"; } return "OK"; } }
13.密码转换
大家都知道手机上的字母： 1–1， abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，
声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。
输入描述:
输入包括多个测试数据。输入是一个明文，密码长度不超过100个字符，输入直到文件结尾
输出描述:
输出渊子真正的密文
示例1
输入
YUANzhi1987
输出
zvbo9441987
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String str = input.nextLine(); char[] arr = str.toCharArray(); for (int i = 0; i < arr.length; i++) { char num = arr[i]; if (num >= '0' && num <= '9') { continue; } else if ("abc".contains(num + "")) { arr[i] = '2'; } else if ("def".contains(num + "")) { arr[i] = '3'; } else if ("ghi".contains(num + "")) { arr[i] = '4'; } else if ("jkl".contains(num + "")) { arr[i] = '5'; } else if ("mno".contains(num + "")) { arr[i] = '6'; } else if ("pqrs".contains(num + "")) { arr[i] = '7'; } else if ("tuv".contains(num + "")) { arr[i] = '8'; } else if ("wxyz".contains(num + "")) { arr[i] = '9'; } else if (num>='A' && num<='Y') { arr[i] = (char) (num + 33); } else if (num =='Z') { arr[i] = 'a'; } else{ System.out.println("your password is error!"); return; } } for (char c : arr) { System.out.print(c); } } } }
14.删除出现次数最少的字符
实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
注意每个输入文件有多组输入，即多个字符串用回车隔开
输入描述:
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述:
删除字符串中出现次数最少的字符后的字符串。
示例1
输入
abcdd
输出
dd
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Scanner; import java.util.TreeMap; public class Main { /*public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String s = input.nextLine(); Map<Character, Integer> map = new TreeMap<>(); for (int i = 0; i < s.length(); i++) { char key = s.charAt(i); if (map.containsKey(key)) { map.put(key, map.get(key) + 1); } else { map.put(key, 1); } } List<Map.Entry<Character, Integer>> list = new ArrayList<>(map.entrySet()); Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() { @Override public int compare(Entry<Character, Integer> o1, Entry<Character, Integer> o2) { return o1.getValue() - o2.getValue(); } }); String newS = s.replace(list.get(0).getKey() + "", ""); for (int i = 1; i < list.size(); i++) { if (list.get(0).getValue() == list.get(i).getValue()) { newS = newS.replace(list.get(i).getKey() + "", ""); }else { break; } } System.out.println(newS); } input.close(); }*/ public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String str = input.nextLine(); int[] count = new int[26]; char[] chs = str.toCharArray(); int min = Integer.MAX_VALUE; for (int i = 0; i < chs.length; i++) { count[chs[i] - 'a']++; min = min > count[chs[i] - 'a'] ? count[chs[i] - 'a'] : min; } for (int i = 0; i < count.length; i++) { if (count[i] == min) { str = str.replaceAll(String.valueOf((char) (i + 'a')), ""); } } System.out.println(str); } input.close(); } }
15.蛇形矩阵
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
样例输入
5
样例输出
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { int N = Integer.parseInt(input.nextLine()); int[][] m = new int[N][N]; m[0][0] = 1; //核心思想，后一项与前一项的关系 System.out.print(m[0][0] + " "); for (int i = 0; i < N - 1; i++) { m[i + 1][0] = m[i][0] + i + 1; for (int j = 0; j < N - 1 - i; j++) { m[i][j + 1] = m[i][j] + j + i + 2; System.out.print(m[i][j + 1] + " "); } System.out.print(" " + m[i + 1][0] + " "); } System.out.println(); //注意在每个测试用例后添加换行 } input.close(); } }
16.顺时针打印矩阵
package nowcode; /** * 顺时针打印矩阵 * 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字， * 例如，如果输入如下4 X 4矩阵： * 1 2 3 4 * 5 6 7 8 * 9 10 11 12 * 13 14 15 16 * 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10. */ public class T22printMatrixInCircle { public static void main(String[] args) { int[][] m = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 } }; int rows = m.length; int cols = m[0].length; int start = 0; while (cols > 2 * start && rows > 2 * start) { pringMatrixInCircle(m, rows, cols, start); start++; } } public static void pringMatrixInCircle(int[][] m, int rows, int cols, int start) { //1.从左到右打印 for (int j = start; j < cols - start; j++) { System.out.print(m[start][j] + " "); } //2.从上到下 for (int i = start + 1; i < rows - start; i++) { System.out.print(m[i][cols - start - 1] + " "); } //3.从右到左 for (int j = cols - start - 2; j >= start; j--) { System.out.print(m[rows - start - 1][j] + " "); } //4.从下到上 for (int i = rows - start - 2; i > start; i--) { System.out.print(m[i][start] + " "); } } }
17.字符串加密
package nowcode; import java.util.LinkedHashSet; import java.util.Scanner; import java.util.Set; /** * 有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如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。 通过指定的密匙和明文得到密文。 输入描述: 先输入key和要加密的字符串 输出描述: 返回加密后的字符串 示例1 输入 nihao ni 输出 le */ public class T23字符串加密 { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s1 = "abcdefghijklmnopqrstuvwxyz"; while (input.hasNext()) { StringBuffer sb = new StringBuffer(s1); String str = input.nextLine(); String data = input.nextLine(); String disStr = getDistinctString(str); // System.out.println(disStr); String key = completion(sb, disStr); // System.out.println(key); String result = getPlainText(key, data); System.out.println(result); } } /** * 字符串去重 */ public static String getDistinctString(String s) { Set<Character> set = new LinkedHashSet<>(); for (int i = 0; i < s.length(); i++) { set.add(s.charAt(i)); } String res = ""; for (Character ch : set) { res += ch; } return res; } /** * 字符串补齐 * @param sb：标准字符串 * @param str：去重之后的字符串 * @return */ public static String completion(StringBuffer sb, String str) { //int index = 0; for (int i = 0; i < str.length(); i++) { char ch = str.charAt(i); sb.deleteCharAt(sb.indexOf(ch + "")); //sb.insert(index++, ch); } return str + sb.toString(); } /** * 得到明文 * @param key：密钥 * @param data：加密的数据 * @return */ public static String getPlainText(String key, String data) { String res = ""; for (int i = 0; i < data.length(); i++) { char ch = data.charAt(i); if (Character.isLowerCase(ch)) { res += key.charAt(ch - 'a'); } else if (Character.isUpperCase(ch)) { res += (char) (key.charAt(ch - 'A') - 32); } else { System.out.println("wrong"); return null; } } return res; } }
18.最长递增子序列
import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String str = input.nextLine(); String[] arr = str.split(" "); int[] nums = new int[arr.length]; for (int i = 0; i < nums.length; i++) { nums[i] = Integer.parseInt(arr[i]); } int res = getMaxLengthOfSubsequence(nums); System.out.println(res); } input.close(); } //获得最长子序列 public static int getMaxLengthOfSubsequence(int[] nums) { int n = nums.length; int[] ls = new int[n]; int res = 1; for (int i = 0; i < n; i++) {//填充ls int maxValue = 1; ls[i] = 1; for (int j = 0; j < i; j++) { ///遍历所有的A if (nums[i] > nums[j]) { maxValue = max(maxValue, ls[j] + 1); } ls[i] = maxValue; } } int index = 0; //最长子序列末尾出现的位置 for (int i = 0; i < n; i++) { //查找最大的子序列 if (ls[i] > res) { res = ls[i]; index = i; } } int count = res; //从后往前找子序列 int[] arrRes = new int[count]; arrRes[--count] = nums[index]; for (int i = index; i >= 0; i--) { if (nums[i] < nums[index] && ls[i] == ls[index] - 1) { arrRes[--count] = nums[i]; index = i; } } System.out.println(Arrays.toString(arrRes)); return res; } public static int max(int a, int b) { return a > b ? a : b; } }
19.合唱队
package nowcode2; import java.util.Arrays; import java.util.Scanner; /** * 计算最少出列多少位同学，使得剩下的同学排成合唱队形 说明： N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。 合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足存在i（1<=i<=K）使得T1<T2<......<Ti-1<Ti>Ti+1>......>TK。 你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。 输入描述: 整数N 输出描述: 最少需要几位同学出列 示例1 输入 8 186 186 150 200 160 130 197 200 输出 4 */ public class T25合唱队 { public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { int num = Integer.parseInt(input.nextLine()); String str = input.nextLine(); String[] snum = str.split(" "); int[] nums = new int[num]; for (int i = 0; i < num; i++) { nums[i] = Integer.parseInt(snum[i]); } int[] l1 = new int[num]; int[] l2 = new int[num]; int res = getMaxLenOfSubsequence(nums, l1, l2, num); System.out.println(res); } input.close(); } public static int getMaxLenOfSubsequence(int[] nums, int[] l1, int[] l2, int num) { // 核心思想：动态规划 li = max(lj) +1,其中 0 <= j <i。 for (int i = 0; i < num; i++) {//由左向右遍历 l1[i] = 1; for (int j = 0; j < i; j++) { if (nums[i] > nums[j] && l1[i] < l1[j] + 1) { l1[i] = l1[j] + 1; } } } for (int i = num - 1; i >= 0; i--) { //从右向左遍历 l2[i] = 1; for (int j = i + 1; j < num; j++) { if (nums[i] > nums[j] && l2[i] < l2[j] + 1) { l2[i] = l2[j] + 1; } } } int res = 0; for (int i = 0; i < num; i++) { if (res < l1[i] + l2[i] - 1) { res = l1[i] + l2[i] - 1; } } return num - res; } }
20.数据分类处理
输入描述:
一组输入整数序列I和一组规则整数序列R，I和R序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0~0xFFFFFFFF，序列个数不限
输出描述:
从R依次中取出R<i>，对I进行处理，找到满足条件的I<j>：
I<j>整数对应的数字需要连续包含R<i>对应的数字。比如R<i>为23，I<j>为231，那么I<j>包含了R<i>，条件满足 。
按R<i>从小到大的顺序:
(1)先输出R<i>；
(2)再输出满足条件的I<j>的个数；
(3)然后输出满足条件的I<j>在I序列中的位置索引(从0开始)；
(4)最后再输出I<j>。
附加条件：
(1)R<i>需要从小到大排序。相同的R<i>只需要输出索引小的以及满足条件的I<j>，索引大的需要过滤掉
(2)如果没有满足条件的I<j>，对应的R<i>不用输出
(3)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
序列I：15,123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123（第一个15表明后续有15个整数）
序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）
输出：30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123,6,7,1,456,2,786,4,46,8,665,9,453456,11,456,12,786
说明：
30—-后续有30个整数
3—-从小到大排序，第一个R<i>为0，但没有满足条件的I<j>，不输出0，而下一个R<i>是3
6— 存在6个包含3的I<j>
0— 123所在的原序号为0
123— 123包含3，满足条件
示例1
输入
15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123 5 6 3 6 3 0
输出
30 3 6 0 123 3 453 7 3 9 453456 13 453 14 123 6 7 1 456 2 786 4 46 8 665 9 453456 11 456 12 786
import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.Scanner; import java.util.Set; import java.util.TreeSet; public class Main { /* public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String I = input.nextLine(); String[] sarrI = I.substring(I.indexOf(" ") + 1).split(" "); String R = input.nextLine(); String[] sarrR = R.substring(R.indexOf(" ") + 1).split(" "); int[] arrR = new int[sarrR.length]; for (int i = 0; i < sarrR.length; i++) { arrR[i] = Integer.parseInt(sarrR[i]); } // System.out.println(Arrays.toString(sarrI)); // System.out.println(Arrays.toString(arrR)); ArrayList<String> listR = sortAndDistinct(arrR); // System.out.println(Arrays.toString(arrR)); ArrayList<Integer> listRes = new ArrayList(); // System.out.println(listR); for (int i = 0; i < listR.size(); i++) { listRes.add(Integer.parseInt(listR.get(i))); ArrayList<String> listNums = new ArrayList<>(); ArrayList<Integer> listIndexs = new ArrayList<>(); for (int j = 0; j < sarrI.length; j++) { if (sarrI[j].contains(listR.get(i))) { listNums.add(sarrI[j]); listIndexs.add(j); } } if(listNums.size()== 0) { listRes.remove(listRes.size()-1); continue; } listRes.add(listNums.size()); for(int k = 0; k< listNums.size();k++) { listRes.add(listIndexs.get(k)); listRes.add(Integer.parseInt(listNums.get(k))); } } System.out.print(listRes.size()+" "); for (Integer val :listRes ) { System.out.print(val + " "); } } input.close(); } public static ArrayList<String> sortAndDistinct(int[] arr) { Arrays.sort(arr); LinkedHashSet<Integer> set = new LinkedHashSet<>(); for (int i = 0; i < arr.length; i++) { set.add(arr[i]); } ArrayList<String> list = new ArrayList<>(); for (Integer i : set) { list.add(String.valueOf(i)); } return list; }*/ public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String strI = input.nextLine(); String strR = input.nextLine(); String res = fun(strI, strR); System.out.println(res); } input.close(); } public static String fun(String strI, String strR) { String[] arrI = strI.split(" "); String[] arrR = strR.split(" "); Set<Integer> setR = new TreeSet<>(); //有序的无重复数字可以用TreeSet for (int i = 1; i < arrR.length; i++) { setR.add(Integer.parseInt(arrR[i])); } StringBuffer result = new StringBuffer(); for (int rdata : setR) { int num = 0; StringBuffer sb = new StringBuffer(); for (int i = 1; i < arrI.length; i++) { if (arrI[i].contains(String.valueOf(rdata))) { num++; sb.append((i - 1) + " "); sb.append(arrI[i] + " "); } } if (num != 0) { result.append(rdata + " "); result.append(num + " "); result.append(sb); } } int all_num = result.toString().split(" ").length; result.insert(0, (all_num) + " "); return result.toString(); } }
21.字符串排序
package nowcode2; import java.util.Arrays; import java.util.Scanner; /** * 题目描述 编写一个程序，将输入字符串中的字符按如下规则排序。 规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。 如，输入： Type 输出： epTy 规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。 如，输入： BabA 输出： aABb 规则 3 ：非英文字母的其它字符保持原来的位置。 如，输入： By?e 输出： Be?y 输入描述: 输入字符串 输出描述: 输出字符串 示例1 输入 A Famous Saying: Much Ado About Nothing (2012/8). 输出 A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8). */ public class T27字符串排序 { /*public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String str = input.nextLine(); char[] data = str.toCharArray(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < data.length; i++) { char ch = data[i]; if (Character.isLetter(ch)) { sb.append(ch); } } char[] sarr = sb.toString().toCharArray(); getSortString(sarr); int index = 0; for (int i = 0; i < data.length; i++) { if (Character.isLetter(data[i])) { System.out.print(sarr[index++]); } else { System.out.print(data[i]); } } System.out.println(); } input.close(); } public static void getSortString(char[] sarr) { char temp = '*'; for (int i = 0; i < sarr.length - 1; i++) { for (int j = sarr.length - 1; j > i; j--) { if (Character.toUpperCase(sarr[j - 1]) > Character.toUpperCase(sarr[j])) { //前面的字母比后面的字母小 temp = sarr[j - 1]; sarr[j - 1] = sarr[j]; sarr[j] = temp; } } } }*/ public static void main(String[] args) { Scanner input = new Scanner(System.in); while (input.hasNext()) { String str = input.nextLine(); // char[] arr = str.toCharArray(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < 26; i++) { char ch = (char) (i + 'A'); for (int j = 0; j < str.length(); j++) { if (ch == str.charAt(j) || ch == str.charAt(j) - 32) { sb.append(str.charAt(j)); } } } for (int i = 0; i < str.length(); i++) { if (!Character.isLetter(str.charAt(i))) { sb.insert(i, str.charAt(i)); } } System.out.println(sb.toString()); } input.close(); } }
22.查找兄弟单词
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class T28FindBrotherWords { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String s = null; while ((s = br.readLine()) != null) { String[] vals = s.split(" "); if (vals.length < 4) continue; int num = Integer.parseInt(vals[0]); if (num > 1000) continue; String key = vals[num + 1]; int index = Integer.parseInt(vals[num + 2]); List<String> list = new ArrayList<String>(); for (int i = 1; i <= num; i++) { if (isBrothStr(vals[i], key)) { list.add(vals[i]); } } Collections.sort(list); System.out.println(list.size()); if (list.size() >= index) System.out.println(list.get(index - 1)); } } public static boolean isBrothStr(String source, String dest) { if (source.equals(dest) || source.length() != dest.length()) return false; for (int i = 'a'; i <= 'z'; i++) { char ch = (char) i; if (getCharSize(source, ch) != getCharSize(dest, ch)) return false; } return true; /*List<Character> list1 = new ArrayList<>(); List<Character> list2 = new ArrayList<>(); for (int i = 0; i < source.length(); i++) { list1.add(source.charAt(i)); list2.add(dest.charAt(i)); } System.out.println("list1:" + list1); System.out.println("list2:" + list2); return list1.containsAll(list2); // containsAll方法不能比较两个list是否相等， //反例：list1:[a, b, c, b]和list2:[a, c, a, b]也是true */ } public static int getCharSize(String source, char ch) { int count = 0; for (int i = 0; i < source.length(); i++) if (source.charAt(i) == ch) count++; return count; } }
23.字符串加密
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Arrays; /** * 题目描述 1、对输入的字符串进行加解密，并输出。 2加密方法为： 当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a； 当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0； 其他字符不做变化。 3、解密方法为加密的逆过程。 说明： 1、字符串以结尾。 2、字符串最长100个字符。 说明： 1、字符串以结尾。 2、字符串最长100个字符。 输入描述: 输入说明 输入一串要加密的密码 输入一串加过密的密码 输出描述: 输出说明 输出加密后的字符 输出解密后的字符 示例1 输入 abcdefg BCDEFGH 输出 BCDEFGH abcdefg */ public class T30StringEncrption { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String str = ""; while ((str = br.readLine()) != null) { String s1 = str; String s2 = br.readLine(); String res1 = encrption(s1); System.out.println(res1); String res2 = decrption(s2); System.out.println(res2); } } public static String encrption(String s) { char[] arr = s.toCharArray(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < arr.length; i++) { if (arr[i] >= 'a' && arr[i] < 'z') { sb.append((char) (arr[i] - 31)); } else if (arr[i] == 'z') { sb.append('A'); } else if (arr[i] >= 'A' && arr[i] < 'Z') { sb.append((char) (arr[i] + 33)); } else if (arr[i] == 'Z') { sb.append('a'); } else if (arr[i] >= '0' && arr[i] < '9') { sb.append((char) (arr[i] + 1)); } else if (arr[i] == '9') { sb.append('0'); } } return sb.toString(); } public static String decrption(String s) { char[] arr = s.toCharArray(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < arr.length; i++) { if (arr[i] > 'a' && arr[i] <= 'z') { sb.append((char) (arr[i] - 33)); } else if (arr[i] == 'a') { sb.append('Z'); } else if (arr[i] > 'A' && arr[i] <= 'Z') { sb.append((char) (arr[i] + 31)); } else if (arr[i] == 'A') { sb.append('z'); } else if (arr[i] > '0' && arr[i] <= '9') { sb.append((char) (arr[i] - 1)); } else if (arr[i] == '0') { sb.append('9'); } } return sb.toString(); } }
24.字符串加密
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Arrays; /** * 题目描述 1、对输入的字符串进行加解密，并输出。 2加密方法为： 当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a； 当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0； 其他字符不做变化。 3、解密方法为加密的逆过程。 说明： 1、字符串以结尾。 2、字符串最长100个字符。 说明： 1、字符串以结尾。 2、字符串最长100个字符。 输入描述: 输入说明 输入一串要加密的密码 输入一串加过密的密码 输出描述: 输出说明 输出加密后的字符 输出解密后的字符 示例1 输入 abcdefg BCDEFGH 输出 BCDEFGH abcdefg */ public class T30StringEncrption { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String str = ""; while ((str = br.readLine()) != null) { String s1 = str; String s2 = br.readLine(); String res1 = encrption(s1); System.out.println(res1); String res2 = decrption(s2); System.out.println(res2); } } public static String encrption(String s) { char[] arr = s.toCharArray(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < arr.length; i++) { if (arr[i] >= 'a' && arr[i] < 'z') { sb.append((char) (arr[i] - 31)); } else if (arr[i] == 'z') { sb.append('A'); } else if (arr[i] >= 'A' && arr[i] < 'Z') { sb.append((char) (arr[i] + 33)); } else if (arr[i] == 'Z') { sb.append('a'); } else if (arr[i] >= '0' && arr[i] < '9') { sb.append((char) (arr[i] + 1)); } else if (arr[i] == '9') { sb.append('0'); } } return sb.toString(); } public static String decrption(String s) { char[] arr = s.toCharArray(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < arr.length; i++) { if (arr[i] > 'a' && arr[i] <= 'z') { sb.append((char) (arr[i] - 33)); } else if (arr[i] == 'a') { sb.append('Z'); } else if (arr[i] > 'A' && arr[i] <= 'Z') { sb.append((char) (arr[i] + 31)); } else if (arr[i] == 'A') { sb.append('z'); } else if (arr[i] > '0' && arr[i] <= '9') { sb.append((char) (arr[i] - 1)); } else if (arr[i] == '0') { sb.append('9'); } } return sb.toString(); } }
25.小球弹落
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** * 假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？ 输入描述: 输入起始高度，int型 输出描述: 分别输出第5次落地时，共经过多少米第5次反弹多高 示例1 输入 1 输出 2.875 0.03125 */ public class T39BallRebounce { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { double h = Double.parseDouble(str); double sum = h; h = h / 2; int times = 5; for (int i = 1; i < times; i++) { sum += h * 2; h = h / 2; } System.out.println(String.format("%.0f", sum)); System.out.println(String.format("%.2f", h)); } } }
26.砝码称重
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** * 题目描述 现有一组砝码，重量互不相等，分别为m1,m2,m3…mn； 每种砝码对应的数量为x1,x2,x3...xn。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。 注： 称重重量包括0 方法原型：public static int fama(int n, int[] weight, int[] nums) 输入描述: 输入包含多组测试数据。 对于每组测试数据： 第一行：n --- 砝码数(范围[1,10]) 第二行：m1 m2 m3 ... mn --- 每个砝码的重量(范围[1,2000]) 第三行：x1 x2 x3 .... xn --- 每个砝码的数量(范围[1,6]) 输出描述: 利用给定的砝码可以称出的不同的重量数 示例1 输入 2 1 2 2 1 输出 5 */ public class T41砝码 { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { int n = Integer.parseInt(str); int[] weight = new int[n]; int[] nums = new int[n]; String[] sarrw = bf.readLine().split(" "); String[] sarrn = bf.readLine().split(" "); for (int i = 0; i < n; i++) { weight[i] = Integer.parseInt(sarrw[i]); nums[i] = Integer.parseInt(sarrn[i]); } System.out.println(fama(n, weight, nums)); } } private static int fama(int n, int[] weight, int[] nums) { // TODO Auto-generated method stub int maxWeight = 0; //所有砝码能够表示的最大重量 for (int i = 0; i < n; i++) {//砝码的种类数 maxWeight = maxWeight + nums[i] * weight[i]; } boolean[] wflag = new boolean[maxWeight + 1]; wflag[0] = true;//默认重量为0也是可以表示的 wflag[maxWeight] = true; for (int i = 0; i < n; i++) {//砝码的种类数 for (int j = 0; j < nums[i]; j++) {//每种砝码的个数 for (int k = maxWeight; k >= weight[i]; k--) {//每种砝码的单个重量 if (wflag[k - weight[i]]) { wflag[k] = true; } } } } int count = 0; for (boolean b : wflag) { if (b) count++; } return count; } }
27.走迷宫
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Arrays; import tool.*; /** * 题目描述 定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。 Input 一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。 Output 左上角到右下角的最短路径，格式如样例所示。 输入描述: 输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。 输出描述: 左上角到右下角的最短路径，格式如样例所示。 示例1 输入 5 5 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 输出 (0,0) (1,0) (2,0) (2,1) (2,2) (2,3) (2,4) (3,4) (4,4) */ public class T42走迷宫 { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { String[] sarr = str.split(" "); int N = Integer.parseInt(sarr[0]); int M = Integer.parseInt(sarr[1]); //System.out.println(N + " " + M); int[][] matrix = new int[N][M]; for (int i = 0; i < N; i++) { String[] arr1 = bf.readLine().split(" "); for (int j = 0; j < M; j++) { matrix[i][j] = Integer.parseInt(arr1[j]); } } //Tookit.printArray(matrix); findShortestPath(matrix); } } public static void findShortestPath(int[][] maza) { //不考虑多解情况，迷宫只有一条通道 //可以横着走或者竖着走 int row = 0; int col = 0; while (row < maza.length) { while (col < maza[0].length) { if (maza[row][col] == 0) { printPath(row, col); col++;//右 } else {//下 col--; row++; } } row++; if (col == maza[0].length) col--;//左 } } public static void printPath(int i, int j) { System.out.println("(" + i + "," + j + ")"); } }
28.数独
问题描述：数独（Sudoku）是一款大众喜爱的数字逻辑游戏。玩家需要根据9X9盘面上的已知数字，推算出所有剩余空格的数字，并且满足每一行、每一列、每一个粗线宫内的数字均含1-9，并且不重复。
输入：
包含已知数字的9X9盘面数组[空缺位以数字0表示]
输出：
完整的9X9盘面数组
输入描述:
包含已知数字的9X9盘面数组[空缺位以数字0表示]
输出描述:
完整的9X9盘面数组
示例1
输入
0 9 2 4 8 1 7 6 3 4 1 3 7 6 2 9 8 5 8 6 7 3 5 9 4 1 2 6 2 4 1 9 5 3 7 8 7 5 9 8 4 3 1 2 6 1 3 8 6 2 7 5 9 4 2 7 1 5 3 8 6 4 9 3 8 6 9 1 4 2 5 7 0 4 5 2 7 6 8 3 1
输出
5 9 2 4 8 1 7 6 3 4 1 3 7 6 2 9 8 5 8 6 7 3 5 9 4 1 2 6 2 4 1 9 5 3 7 8 7 5 9 8 4 3 1 2 6 1 3 8 6 2 7 5 9 4 2 7 1 5 3 8 6 4 9 3 8 6 9 1 4 2 5 7 9 4 5 2 7 6 8 3 1
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.HashSet; import tool.*; public class T43数独 { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { int[][] matrix = new int[9][9]; String[] sarr = str.split(" "); for (int j = 0; j < 9; j++) { matrix[0][j] = Integer.parseInt(sarr[j]); } for (int i = 1; i < 9; i++) { String[] temp = bf.readLine().split(" "); for (int j = 0; j < 9; j++) { matrix[i][j] = Integer.parseInt(temp[j]); } } solveSudoku(matrix); Tookit.printArray(matrix); } bf.close(); } static int solveSudoku(int[][] board) { int depth = 0; for (int i[] : board) for (int j : i) if (j == 0) depth++; return dfs(board, depth); } static int dfs(int[][] board, int depth) { if (depth == 0) return 0; for (int i = 0; i < board.length; i++) { for (int j = 0; j < board[0].length; j++) { if (board[i][j] == 0) { if (board[6][0] == 2 && board[6][1] == 1 && board[6][2] == 3) board[6][2] = 5; for (int k = 1; k <= 10; k++) { if (k == 10) return depth; board[i][j] = k; if (!isValid(board, i, j)) board[i][j] = 0; else { depth--; depth = dfs(board, depth); if (depth == 0) return depth; depth++; board[i][j] = 0; } } } } } return depth; } static boolean isValid(int[][] board, int row, int col) { boolean[] check = new boolean[10]; for (int i = 0; i < check.length; i++) check[i] = true; for (int i = 0; i < board[0].length; i++) { if (check[board[row][i]]) check[board[row][i]] = false; else if (board[row][i] != 0) return false; } for (int i = 0; i < check.length; i++) check[i] = true; for (int i = 0; i < board.length; i++) { if (check[board[i][col]]) check[board[i][col]] = false; else if (board[i][col] != 0) return false; } for (int i = 0; i < check.length; i++) check[i] = true; int rowTemp = (row / 3) * 3; int colTemp = (col / 3) * 3; for (int k = 0; k < 9; k++) { row = rowTemp + k / 3; col = colTemp + k % 3; if (check[board[row][col]]) check[board[row][col]] = false; else if (board[row][col] != 0) return false; } return true; } }
29.括号匹配
package nowcode2; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.HashMap; import java.util.Map; import java.util.Stack; /** * 给定一个字符串，其中的字符只包含三种括号：花括号{ }、中括号[ ]、圆括号( )，即它仅由 “( ) [ ] { }” 这六个字符组成。 * 设计算法，判断该字符串是否有效，即字符串中括号是否匹配。括号匹配要求括号必须以正确的顺序配对，如 “{ [ ] ( ) }” * 或 “[ ( { } [ ] ) ]”或 “{brace*&^[square(round)]end}”等为正确的格式，而 “[ ( ] )” 或 “{ [ ( ) }” 或 “( { } ] )” * 或“{brace*&^[square(round])end}”均为不正确的格式。 */ public class T44括号匹配 { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { boolean res = bracketCheck(str); System.out.println(res); } } private static boolean bracketCheck(String s) { Map<Character, Character> bracketMap = new HashMap<>(); bracketMap.put('}', '{'); bracketMap.put(')', '('); bracketMap.put(']', '['); String bracketLeft = "{(["; String bracketRight = "}])"; Stack<Character> stack = new Stack<>(); for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); //如果是左括号 if (bracketLeft.contains(c + "")) { stack.add(c);//入栈 //如果是右括号 } else if (bracketRight.contains(c + "")) { //stack不为空，并且括号匹配成功 if (stack.size() > 0 && (stack.peek() == bracketMap.get(c))) { stack.pop();//出栈 } else { return false; } } } return stack.size() == 0;//如果栈为空，则匹配上了 } }
30.计算器之加减乘除运算
输入描述:
输入一个算术表达式
输出描述:
得到计算结果
示例1
输入
3+2*{1+2*[-4/(8-6)+7]}
输出
25
package nowcode3; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Stack; public class T45计算器之加减乘除运算 { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { str = format(str); System.out.println(getResult(str)); } } /** * 进行四则运行 * * @param s 输入一个算术表达式 * @return 表达式结果 */ public static int getResult(String s) { // 操作符栈 Stack<Character> optchars = new Stack<>(); // 操作数栈 Stack<Integer> optdata = new Stack<>(); int index = 0; while (index < s.length()) { char c = s.charAt(index); // 如果是数字 if (c >= '0' && c <= '9') { // 计算数字的值,可能会存在两位及以上的数字 int opd = 0; while (index < s.length() && s.charAt(index) >= '0' && s.charAt(index) <= '9') { opd = opd * 10 + (s.charAt(index) - '0'); //将字符转化成数字 index++; } optdata.add(opd); //将数字加入到操作数栈中 } // 如果是操作符 else { // 如果是左括号 if (c == '(' || c == '[' || c == '{') { optchars.add(c); //将左括号字符加入到操作符栈中 } // 如果是右括号 else if (c == ')' || c == ']' || c == '}') { //要同时保证optchars.peek()操作符顶端的符号不能是'('或'['或'{',防止在有些数字的输入形式是(3)+2，此处的3不能计算 while (!optchars.isEmpty() && optchars.peek() != '(' && optchars.peek() != '[' && optchars.peek() != '{') { calculate(optchars, optdata);//计算左右括号内的两个数据的运算 } optchars.pop(); // } // 如果是乘或者除 else if (c == '*' || c == '/') { //虽然操作符是乘除，但是还要保证前面的操作符栈中不能含有括号，如果含有括号，则不能进行运算 while (!optchars.isEmpty() && (optchars.peek() == '*' || optchars.peek() == '/')) { calculate(optchars, optdata); } // 操作符入栈 optchars.add(c); } else if (c == '+' || c == '-') { while (!optchars.isEmpty() && (optchars.peek() == '*' || optchars.peek() == '/' || optchars.peek() == '+' || optchars.peek() == '-')) { calculate(optchars, optdata); } // 操作符入栈 optchars.add(c); } // 处理下一个字符 index++; } } while (!optchars.isEmpty()) { calculate(optchars, optdata); } return optdata.pop(); } /** * 求值操作，取optchars的最后一个操作符，optdata中的最后两个操作数 * @param optchars 操作符栈 * @param optdata 操作数栈 */ public static void calculate(Stack<Character> optchars, Stack<Integer> optdata) { // 取操作数栈中的最后一个操作符 char opt = optchars.pop(); // 取操作数 int v2 = optdata.pop(); int v1 = optdata.pop(); // 计算 int v = calculateTowData(v1, v2, opt); optdata.add(v); } /** * 将算术表达式归整，-5*3整理成0-5*3 * @param s 算术表达式 * @return 归整后的表达式 */ public static String format(String s) { // 去掉空格 String t = s.replaceAll("(\s)+", ""); int index = 0; // 对所有的减号进行处理 while ((index = t.indexOf('-', index)) >= 0) {//String.indexOf(String str，int index) //从index的地方开始找，返回第一次出现的索引 if (index == 0) {// 第一个字符是负号，要规格形式要加上0 t = '0' + t; } // 如果不是第一个字符 else { char c = t.charAt(index - 1);//负号前面的一个字符 // 负号前面有括号，需要在前面加0 if (c == '(' || c == '[' || c == '{') { t = t.substring(0, index) + '0' + t.substring(index); } } index++; } return t; } /** * 计算 d1 operator d2，operator是加减乘除 * * @param d1 操作数1 * @param d2 操作数2 * @param operator 操作符 * @return 结果 */ public static int calculateTowData(int d1, int d2, char operator) { switch (operator) { case '+': return d1 + d2; case '-': return d1 - d2; case '*': return d1 * d2; case '/': return d1 / d2; default: // do nothing } return 0; } }
31.名字的漂亮度
给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
输入描述:
整数N，后续N个名字
输出描述:
每个名称可能的最大漂亮程度
示例1
输入
2 zhangsan lisi
输出
192 101
package nowcode3; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import tool.*; public class T46计算名字的漂亮度 { /*public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { int N = Integer.parseInt(str); for (int i = 0; i < N; i++) { String name = bf.readLine(); int res = getNameBeautyDegree(name); System.out.println(res); } } } public static int getNameBeautyDegree(String name) { HashMap<Character, Integer> map = new HashMap<>(); for (int i = 0; i < name.length(); i++) { char c = name.charAt(i); if (!map.containsKey(c)) { map.put(c, 1); } else { map.put(c, map.get(c) + 1); } } List<Map.Entry<Character, Integer>> list = new ArrayList<Map.Entry<Character, Integer>>(map.entrySet()); Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() { @Override public int compare(Entry<Character, Integer> o1, Entry<Character, Integer> o2) { return o2.getValue().compareTo(o1.getValue()); } }); int res = 0; int num = 26; for (Entry<Character, Integer> entry : list) { res += entry.getValue() * num--; } return res; }*/ public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { int N = Integer.parseInt(str); for (int i = 0; i < N; i++) { String name = bf.readLine(); int res = getNameBeautyDegree(name); System.out.println(res); } } } public static int getNameBeautyDegree(String s) { int res = 0; int n = 26; int[] arr = new int[n]; for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (arr[c - 'a'] != 0) { arr[c - 'a']++; } else { arr[c - 'a'] = 1; } } Arrays.sort(arr); for (int i = arr.length - 1; i >= 0; i--) { if (arr[i] > 0) { res += arr[i] * n--; } } return res; } }
32.计算字符串的距离
package nowcode3; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class T48计算字符串的距离 { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str1 = null; while ((str1 = bf.readLine()) != null) { String str2 = bf.readLine(); int res = getEditDistance(str1, str2); System.out.println(res); } } public static int getEditDistance(String s1, String s2) { int len1 = s1.length(); int len2 = s2.length(); if (len1 == 0 || len2 == 0) return Math.max(len1, len2); int[][] dp = new int[len1 + 1][len2 + 1]; for (int i = 0; i <= len1; i++) { dp[i][0] = i; } for (int j = 0; j <= len2; j++) { dp[0][j] = j; } for (int i = 1; i <= len1; i++) { for (int j = 1; j <= len2; j++) { if (s1.charAt(i-1) == s2.charAt(j-1)) { dp[i][j] = dp[i - 1][j - 1]; } else { dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1; } } } return dp[len1][len2]; } //三个数中的最小值 public static int min(int a, int b, int c) { int temp = a < b ? a : b; return temp < c ? temp : c; } }
33.对应编码
package nowcode3; import java.io.BufferedReader; import java.io.InputStreamReader; public class T50对应编码 { public static void main(String[] args) throws Exception { String[] S = { "Faint signals, barely perceptible", "Very weak signals", "Weak signals", "Fair signals", "Fairly good signals", "Good signals", "Moderately strong signals", "Strong signals", "Extremely strong signals" }; String[] R = { "unreadable", "barely readable, occasional words distinguishable", "readable with considerable difficulty", "readable with practically no difficulty", "perfectly readable" }; BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String str = null; while ((str = bf.readLine()) != null) { int r = Integer.parseInt(str.charAt(0) + ""); int s = Integer.parseInt(str.charAt(1) + ""); System.out.println(S[s - 1] +", "+ R[r - 1]+"."); } } }
34.两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例：
给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]
package leecode; import java.util.HashMap; import com.sun.org.apache.regexp.internal.recompile; import tool.Tookit; public class TowSum { // 方法1：暴力法，两层for循环 /*public static int[] getTowSum(int[] nums, int target) { for (int i = 0; i < nums.length; i++) { for (int j = i + 1; j < nums.length; j++) { if (nums[i] + nums[j] == target) { return new int[] { i, j }; } } } throw new IllegalArgumentException("No two sum solution"); }*/ // 方法2：使用HashMap快速查找 public static int[] getTowSum(int[] nums, int target) { HashMap<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < nums.length; i++) { int competent = target - nums[i]; if (map.containsKey(competent)) { return new int[] { map.get(competent), i }; } map.put(nums[i], i); } throw new IllegalArgumentException("No two sum solution"); } public static void main(String[] args) { int[] nums = { 2, 7, 11, 15 }; int target = 9; int[] res = getTowSum(nums, target); Tookit.printArray(res); } }
35.两数字相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807
package leecode; class ListNode { int val; ListNode next; public ListNode(int x) { this.val = x; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append(this.val).append("->"); ListNode node = this; while (node.next != null) { node = node.next; sb.append(node.val); if (node.next != null) { sb.append("->"); } } return sb.toString(); } } public class AddTowNumbers { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode dummyHead = new ListNode(0);// 头节点 ListNode p1 = l1, p2 = l2; ListNode current = dummyHead; int carry = 0; while (p1 != null || p2 != null) { int x1 = (p1 != null) ? p1.val : 0; int x2 = (p2 != null) ? p2.val : 0; int sum = carry + x1 + x2; carry = sum / 10; current.next = new ListNode(sum % 10); current = current.next; if (p1 != null) p1 = p1.next; if (p2 != null) p2 = p2.next; } if (carry > 0) { current.next = new ListNode(carry); } return dummyHead.next; } public static void main(String[] args) { /* int[] num1 = new int[] { 2, 4, 3 }; int[] num2 = new int[] { 5, 6, 4 }; ListNode l1 = new ListNode(0); ListNode node = l1; for (int i = 0; i < num1.length; i++) { node.val = num1[i]; if (i < num1.length - 1) { node.next = new ListNode(0); node = node.next; } } System.out.println(l1); ListNode n2 = new ListNode(0); node = n2; for (int i = 0; i < num2.length; i++) { node.val = num2[i]; if (i < num2.length - 1) { node.next = new ListNode(0); node = node.next; } } System.out.println(n2);*/ ListNode l1 = new ListNode(2); ListNode node2 = new ListNode(4); ListNode node3 = new ListNode(3); l1.next = node2; node2.next = node3; System.out.println(l1); ListNode l2 = new ListNode(5); ListNode node5 = new ListNode(6); ListNode node6 = new ListNode(4); l2.next = node5; node5.next = node6; System.out.println(l2); ListNode res = new AddTowNumbers().addTwoNumbers(l1, l2); System.out.println(res); } }
36.无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb" 输出: 1 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew" 输出: 3 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
package leecode; import java.util.HashMap; import java.util.HashSet; import java.util.Set; public class T03_LengthOfLongestSubstring { /** * 方法1：暴力法 *//* public int lengthOfLongestSubstring(String s) { int n = s.length(); int ans = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) {// s的所有子串 if (allUnique(s, i, j)) { ans = Math.max(ans, j - i); } } } return ans; } // 检查子串中是否包含相同的元素 public boolean allUnique(String s, int start, int end) { Set<Character> set = new HashSet<>(); for (int i = start; i < end; i++) { Character ch = s.charAt(i); if (set.contains(ch)) return false; set.add(ch); } return true; } */ /** * 方法2 *//* public int lengthOfLongestSubstring(String s) { int n = s.length(); Set<Character> set = new HashSet<>(); int ans = 0, i = 0, j = 0; while (i < n && j < n) { // try to extend the range [i, j] if (!set.contains(s.charAt(j))) { set.add(s.charAt(j++)); ans = Math.max(ans, j - i); } else { set.remove(s.charAt(i++)); } } return ans; }*/ /** * 方法3 */ public int lengthOfLongestSubstring(String s) { int n = s.length(), ans = 0, i = 0; HashMap<Character, Integer> map = new HashMap<>(); for (int j = 0; j < n; j++) { if (map.containsKey(s.charAt(j))) { i = Math.max(map.get(s.charAt(j)), i); } ans = Math.max(ans, j - i + 1); map.put(s.charAt(j), j + 1); } return ans; } public static void main(String[] args) { T03_LengthOfLongestSubstring s = new T03_LengthOfLongestSubstring(); System.out.println(s.lengthOfLongestSubstring("bbbbb")); System.out.println(s.lengthOfLongestSubstring("abcabcbb")); System.out.println(s.lengthOfLongestSubstring("pwwkew")); } }
支付宝扫一扫
微信扫一扫
.png)
最新评论