一、合并表记录
题目描述
数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
输入描述:
先输入键值对的个数，然后输入成对的index和value值，以空格隔开
输出描述:
输出合并后的键值对（多行）
输入 输出
4 0 3
0 1 1 2
0 2 3 4
1 2
3 4
import java.util.Map;
import java.util.Scanner;
import java.util.SortedMap;
import java.util.TreeMap;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int a = sc.nextInt();
SortedMap<Integer,Integer> map = new TreeMap<Integer,Integer>();
for(int i = 0; i < a; i++){
int s = sc.nextInt();
int value = sc.nextInt();
if(map.containsKey(s)){
map.put(s,map.get(s) + value);
}else{
map.put(s,value);
}
}
for(Integer key : map.keySet()){
System.out.println(key + " " + map.get(key));
}
}
}
}相关知识点：
- TreeMap实现了SortedMap接口，TreeMap输出是排序后的键值对
- 红黑树
- for强制循环
其他好的代码链接：https://www.nowcoder.com/profile/875348/codeBookDetail?submissionId=1502420
二、提取不重复的整数
题目描述：
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
输入 输出
9876673 37689
import java.util.Scanner;
public class notContainRepetitionNum {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
//int转string
String str = String.valueOf(num);
//定义一个int数组
int[] num1 = new int[str.length()];
//将String写入int数组
for(int i = 0; i < str.length(); i++) {
num1[i] = Integer.parseInt(String.valueOf(str.charAt(i)));
}
//判断是否有重复元素
int t = 0;
int[] temp = new int[str.length()];
for(int j = 0; j < str.length(); j++) {
boolean isTrue = true;
for(int k = j+1; k < str.length(); k++) {
if(num1[j] == num1[k]) {
isTrue = false;
break;
}
}
//无重复元素则存进数组
if(isTrue) {
temp[t] = num1[j];
t++;
}
}
//数组转String
String str1 = "";
for(int a = 0; a < t; a++) {
str1 = str1 + temp[a];
}
StringBuffer str2 = new StringBuffer(str1).reverse();
System.out.println(str2);
}
}
相关知识点：
1.int和String类型转换及字符串和数组转换
2.去重
3.反转reverse()其他好的代码：
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
while(in.hasNext()){
String str=in.next();
String a=str.substring(str.length()-1);
for(int i=str.length()-2;i>=0;i--){
if(!a.contains(str.substring(i,i+1)))
a+=str.substring(i,i+1);
}
System.out.println(a);
}
}
}
三、字符个数统计
题目描述：
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。
输入描述：
输入N个字符，字符在ACSII码范围内。
输出描述：
输出范围在(0~127)字符的个数。
输入：aasdf
输出：4
import java.util.HashSet;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String c = sc.nextLine();
String [] c1 = new String[c.length()];
//String字符串转String数组
for(int i = 0; i < c.length(); i++){
c1[i] = String.valueOf(c.charAt(i));
}
//set集合去重
HashSet<String> set = new HashSet<>();
for(int j = 0; j < c.length(); j++){
set.add(c1[j]);
}
//输出长度
System.out.println(set.size());
//输出数组
for(String string : set){
System.out.println(string);
}
}
}
}
相关知识点：
1.String转换为String数组
2.set集合去重，set.size()计算数组长度
四、数字颠倒
题目描述：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String num = sc.nextLine();
StringBuffer sb = new StringBuffer(num).reverse();
System.out.println(sb);
}
}
}相关知识点：
1.字符串反转用StringBuffer().reverse()
五、句子逆序
题目描述：
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
接口说明
/**
* 反转句子
*
* @param sentence 原句子
* @return 反转后的句子
*/
public String reverse(String sentence);
输入描述:
将一个英文语句以单词为单位逆序排放。 I am a boy
输出描述：
得到逆序的句子 boy a am I
题目要求代码：
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String line = sc.nextLine();
System.out.print(reverse(line));
}
}
public static String reverse(String sen){
String[] line2 = sen.split(" ");
StringBuffer sb = new StringBuffer();
for(int i = line2.length-1; i > 0; i--) {
sb.append(line2[i]);
sb.append(" ");
}
sb.append(line2[0]);
String s = sb.toString();
return s;
}
}更简单的代码：
import java.util.Arrays;
import java.util.Scanner;
public class sentenceReversedOrder {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String line = sc.nextLine();
String[] line2 = line.split(" ");
for(int i = line2.length-1; i >= 0; i--){
System.out.print(line2[i]+" ");
}
}
}
}
相关知识点：
1.split按空格进行分割
2.字符数组转为字符串：String[] ——> StringBuffer ——> toString()
六、字串的连接最长路径查找
题目描述：
给定n个字符串，请对n个字符串按照字典序排列。
输入描述：
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串
输入： 输出：
9
cap boat
to boot
cat cap
card card
two cat
too to
up too
boat two
boot up
用Arrays.sort排序：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class findLongestPath {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int num = sc.nextInt();
String[] s = new String[num];
for(int i = 0; i < num; i++){
s[i] = sc.next();
}
Arrays.sort(s,String.CASE_INSENSITIVE_ORDER);
for(int j = 0; j < num; j++){
System.out.println(s[j]);
}
}
}
}
用ArrayList结合Collections.sort排序：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class findLongestPath {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
int num = sc.nextInt();
List<String> ls = new ArrayList<String>();
for(int i = 0; i < num; i++) {
ls.add(sc.next());
}
Collections.sort(ls,String.CASE_INSENSITIVE_ORDER);
for(String st : ls) {
System.out.println(st);
}
}
}
}相关知识点：
1.Arrays.sort排序，注意区分大小写
2.利用ArrayList存储数组，用Collections.sort()排序
七、int型正整数在内存中存储时1的个数
题目描述：
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
输入描述：
输入一个整数（int类型） 5
输出描述：
这个数转换成2进制后，输出1的个数 2
利用char数组解答
import java.util.Scanner;
public class decToBinary {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
int num = sc.nextInt();
String s = Integer.toBinaryString(num);
char[] s1 = s.toCharArray();
int t =0;
for(int i = 0; i < s1.length; i++) {
if(s1[i] - '0' == 1) {
t += 1;
}
}
System.out.println(t);
}
}
}利用charAt解答
import java.util.Scanner;
public class decToBinary {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
int num = sc.nextInt();
String s = Integer.toBinaryString(num);
int t =0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) == '1') {
t += 1;
}
}
System.out.println(t);
}
}
}相关知识点：
1.十进制转二进制Integer.toBinaryString
2.String转char数组
3.charAt()用法
八、购物单
题目描述：
王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
| 主件 | 附件 |
| 电脑 | 打印机，扫描仪 |
| 书柜 | 图书 |
| 书桌 | 台灯，文具 |
| 工作椅 | 无 |
如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。
设第 j 件物品的价格为 v[j] ，重要度为 w[j] ，共选中了 k 件物品，编号依次为 j 1 ， j 2 ，……， j k ，则所求的总和为：
v[j 1 ]*w[j 1 ]+v[j 2 ]*w[j 2 ]+ … +v[j k ]*w[j k ] 。（其中 * 为乘号）
请你帮助王强设计一个满足要求的购物单。
输入描述：
输入的第 1 行，为两个正整数，用一个空格隔开：N m
（其中 N （ <32000 ）表示总钱数， m （ <60 ）为希望购买物品的个数。）
从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q
（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）
输出描述：
输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（ <200000 ）
输入：
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
输出：
2200
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int sum_money = 0;
int num = 0;
sum_money=sc.nextInt();
num=sc.nextInt();
int price[]=new int[num+1];
int val[]=new int[num+1];
int[] q = new int[num+1];
for (int i = 1; i <= num; i++) {
price[i]=sc.nextInt();
val[i]=sc.nextInt()*price[i];
q[i]=sc.nextInt();
}
int[][] dp=new int[num+1][sum_money+1];
/*
* 初始值java默认赋值为0,其中dp[0][0...sum_money]为0,从dp[1][0...sum_money]
计算第1行,代表第一件物品
dp[i][sum_money] ： 前i个物体放入容量为sum_money的背包的最大价值；
dp[i-1][sum_money] ： 前i-1个物体放入容量为sum_money的背包的最大价值；
dp[i-1][sum_money-price[i]] ： 前i-1个物体放入容量为sum_money-price[i]的背包的最大价值；
dp[i][sum_money]=Math.max{dp[i-1][sum_money-price[i]]+val[i] , dp[i-1][sum_money]}
*/
for (int i = 1; i <=num; i++) {
for (int j = 1; j <= sum_money; j++) {
if(q[i]==0)
{
if(price[i]<=j){
dp[i][j]=Math.max(dp[i-1][j], dp[i-1][j-price[i]]+val[i]);
}
}
if(q[i]>0)
{
if(price[i]+price[q[i]]<=j){
dp[i][j]=Math.max(dp[i-1][j], dp[i-1][j-price[i]-price[q[i]]]+val[i]+val[q[i]]);
}
}
}
}
System.out.println(dp[num][sum_money]);
}
}相关知识点：
1.动态规划：01背包
九、坐标移动
题目描述：
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，*并将最终输入结果输出到输出文件里面。
输入：合法坐标为A(或者D或者W或者S) + 数字（两位以内）坐标之间以;分隔。非法坐标点需要进行丢弃。如AA10; A1A; $%$; YAD; 等。
下面是一个简单的例子 如：A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：起点（0,0）
+ A10 = （-10,0）
+ S20 = (-10,-20)
+ W10 = (-10,-10)
+ D30 = (20,-10)
+ x = 无效
+ A1A = 无效
+ B10A11 = 无效
+ 一个空 不影响
+ A10 = (10,-10)
结果 （10， -10）
输入描述：
一行字符串 A10;S20;W10;D30;X;A1A;B10A11;;A10;
输出描述：
最终坐标，以,分隔 10,-10
import java.util.Scanner;
public class moveCoordinate {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
String[] str1 = str.split(";");
int x = 0;
int y = 0;
for(int i = 0; i < str1.length; i++){
if(str1[i].length() <= 3){
if(str1[i].charAt(0) == 'A' && str1[i].substring(1).matches("[0-9]+")){
x -= Integer.parseInt(str1[i].substring(1));
}
if(str1[i].charAt(0) == 'D' && str1[i].substring(1).matches("[0-9]+")){
x += Integer.parseInt(str1[i].substring(1));
}
if(str1[i].charAt(0) == 'S' && str1[i].substring(1).matches("[0-9]+")){
y -= Integer.parseInt(str1[i].substring(1));
}
if(str1[i].charAt(0) == 'W' && str1[i].substring(1).matches("[0-9]+")){
y += Integer.parseInt(str1[i].substring(1));
}
}
}
System.out.println(x + "," + y);
}
}
}相关知识点：
1.判断第一个字符用charAt(0)
2.对数字进行匹配str[i].substring(1).mathces("[0-9]+")
3.substring()
十、简单错误记录
题目描述：
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
处理：
1、 记录最多8条错误记录，循环记录，对相同的错误记录（净文件名称和行号完全匹配）只记录一条，错误计数增加；
2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
3、 输入的文件可能带路径，记录文件名称不能带路径。
输入描述：
一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。
输出描述：
将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开
输入：
E:\V1R2\product\fpgadrive.c 1325
输出：
fpgadrive.c 1325 1
解题思路：
获取输入，并用空格分成数组，将第一个数组用\分割，取最后一个数组，判断其长度是否大于16，将取出的文件名与行数进行组合，作为map的key值，同时判断该条记录是否唯一，map的value即为该条记录出现了几次，存入map中。用增强for循环读出。
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
public class wrongRecord {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Map<String,Integer> map = new LinkedHashMap<String,Integer>();
while(sc.hasNext()) {
String str = sc.next();
int num = sc.nextInt();
String[] line = str.split("\\\\");
String s = line[line.length-1];
if(s.length() > 16) {
s = s.substring(s.length()-16,s.length());
}
String key = s + " " + num;
//System.out.println(map.get(key));
if(map.containsKey(key)) {
map.put(key, map.get(key)+1);
}else {
map.put(key, 1);
}
int count = 0;
for(String string:map.keySet()) {
count++;
System.out.println(string);
if(count > (map.keySet().size()-8)) {
System.out.println(string+" "+map.get(string));
}
}
}
}
}利用bufferReader进行输入：
import java.util.*;
import java.io.*;
import java.util.Map;
import java.util.TreeMap;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//Scanner sc = new Scanner(System.in);
String str=null;
Map<String,Integer> map = new LinkedHashMap<String,Integer>();
while((str=br.readLine())!=null){
String[] strs = str.split(" ");
String fileName = strs[0];
String lineNum = strs[1];
if(fileName.contains("\\")){
fileName = fileName.substring(fileName.lastIndexOf("\\")+1);
}
if(fileName.length()>16)
fileName = fileName.substring(fileName.length()-16);
String strError = fileName + " " + lineNum;
if(map.containsKey(strError)){
map.put(strError,map.get(strError)+1);
}else{
map.put(strError,1);
}
}
int count=0;
for(String string:map.keySet()){
count++;
if(count>(map.keySet().size()-8))
System.out.println(string+" "+map.get(string));
}
}
}相关知识点：
1.LinkedHashMap中：put、get、keySet方法
2.增强for循环
3.对比Scanner和BufferReader的区别
十一、识别有效的IP地址和掩码并进行分类统计
题目描述：
请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。
所有的IP地址划分为 A,B,C,D,E五类
A类地址1.0.0.0~126.255.255.255;
B类地址128.0.0.0~191.255.255.255;
C类地址192.0.0.0~223.255.255.255;
D类地址224.0.0.0~239.255.255.255；
E类地址240.0.0.0~255.255.255.255
私网IP范围是：
10.0.0.0～10.255.255.255
172.16.0.0～172.31.255.255
192.168.0.0～192.168.255.255
子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
输入描述：
多行字符串。每行一个IP地址和掩码，用~隔开。
输出描述：
统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
输入：
10.70.44.68~255.254.255.0
1.0.0.1~255.0.0.0
192.168.0.2~255.255.255.0
19..0.~255.255.255.0
输出：
1 0 1 0 0 2 1
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int a = 0, b = 0, c = 0, d = 0, e = 0;
int err = 0;
int pri = 0;
String str;
String[] ip_mask;
String[] ip;
String[] mask;
int ip0;
while((str = br.readLine()) != null) {
ip_mask = str.split("~");
ip = ip_mask[0].split("\\.");
mask = ip_mask[1].split("\\.");
//检查mask地址
if(checkMask(ip_mask[1])) {
//System.out.print("mask address is ok!");
//检查ip地址
if(checkIp(ip)) {
//System.out.print("IP address is ok!");
ip0 = Integer.parseInt(ip[0]);
if(ip0 >= 1 && ip0 <= 126) {//a类
a++;
if(ip0 == 10) {
pri++;
}
}
else if(ip0 >= 128 && ip0 <= 191) {//b类
b++;
if(ip0 == 172 && (Integer.parseInt(ip[1]) >= 16) && (Integer.parseInt(ip[1]) <= 31)) {
pri++;
}
}
else if(ip0 >= 192 && ip0 <= 223) {//c类
c++;
if(ip0 == 192 && (Integer.parseInt(ip[1]) == 168)) {
pri++;
}
}
else if(ip0 >= 224 && ip0 <= 239) {//d类
d++;
}
else if(ip0 >= 240 && ip0 <= 255) {//e类
e++;
}
}
else {
err++;
}
}else {
err++;
}
}
System.out.print(a + " " + b + " " + c + " " + d + " " + e + " " + err + " " + pri);
}
//检查mask地址
public static boolean checkMask(String ip_mask1) {
// TODO Auto-generated method stub
String[] mask1 = ip_mask1.split("\\.");
if(mask1[0].equals("255")) {
if(mask1[1].equals("255")) {
if(mask1[2].equals("255")) {
if(mask1[3].equals("254") || mask1[3].equals("252") || mask1[3].equals("248")
|| mask1[3].equals("240") || mask1[3].equals("224") || mask1[3].equals("192") || mask1[3].equals("128") || mask1[3].equals("0")) {
return true;
}else {
return false;
}
}
else if(mask1[2].equals("254") || mask1[2].equals("252") || mask1[2].equals("248")
|| mask1[2].equals("240") || mask1[2].equals("224") || mask1[2].equals("192") || mask1[2].equals("128") || mask1[2].equals("0")) {
if(mask1[3].equals("0")) {
return true;
}else {
return false;
}
}else {
return false;
}
}
else if(mask1[1].equals("254") || mask1[1].equals("252") || mask1[1].equals("248")
|| mask1[1].equals("240") || mask1[1].equals("224") || mask1[1].equals("192") || mask1[1].equals("128") || mask1[1].equals("0")) {
if(mask1[2].equals("0") && mask1[3].equals("0")) {
return true;
}else {
return false;
}
}else {
return false;
}
}
else if(mask1[0].equals("254") || mask1[0].equals("252") || mask1[0].equals("248")
|| mask1[0].equals("240") || mask1[0].equals("224") || mask1[0].equals("192") || mask1[0].equals("128") || mask1[0].equals("0")) {
if(mask1[1].equals("0") && mask1[2].equals("0") && mask1[3].equals("0")) {
return true;
}else {
return false;
}
}
else {
return false;
}
}
//检查ip地址
static boolean checkIp(String[] ip) {
// TODO Auto-generated method stub
if(ip.length == 4 && !ip[0].equals("") && !ip[1].equals("") && !ip[2].equals("") && !ip[3].equals("")) {
return true;
}
return false;
}
}
相关知识点：
1.弄清子网掩码每一位会出现的数字
2.逐位进行判断即可
十二、密码验证合格程序
题目描述：
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
输入描述：
一组或多组长度超过2的子符串。每组占一行
输出描述：
如果符合要求输出：OK，否则输出NG
输入数据：
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
输出数据：
OK
NG
NG
OK
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
int num = 0, low=0, high=0, ch=0;
if(str.length() > 8){
for(int i = 0; i < str.length(); i++){
if(Character.isDigit(str.charAt(i))){
num = 1;
}else if(Character.isUpperCase(str.charAt(i))){
high = 1;
}else if(Character.isLowerCase(str.charAt(i))){
low = 1;
}else{
ch = 1;
}
}
if(num + high + low + ch < 3){
System.out.println("NG");
}else{
System.out.println(lengthStr(str));
}
}else{
System.out.println("NG");
}
}
}
//判断是否包含2个以上相同字符串
public static String lengthStr(String str){
for(int i = 0; i < str.length()-3; i++){
String str1 = str.substring(i,i+3);
String str2 = str.substring(i+3,str.length());
if(str2.contains(str1)){
return "NG";
}
}
return "OK";
}
}相关知识点：
1.判断大小写字母、数字用Character
2.判断是否包含：先用substring取出一段字符串，再用contains判断是否包含该字符串
十三、简单的密码
题目描述：
假设渊子原来一个BBS上的密码为zvbo9441987,为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。
他是这么变换的，大家都知道手机上的字母： 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个字符，输入直到文件结尾
输出描述：
输出渊子真正的密文
输入：YUANzhi1987
输出：zvbo9441987
import java.util.Scanner;
public class simplePassword {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
String str = sc.nextLine();
StringBuffer sb = new StringBuffer();
for(int i = 0; i < str.length(); i++) {
//判断是否为数字
if(Character.isDigit(str.charAt(i))) {
sb.append(str.charAt(i));
}
//判断是否为小写字母
else if(Character.isLowerCase(str.charAt(i))) {
if(str.charAt(i) >= 'a' && str.charAt(i) <= 'c'){
sb.append(2);
}else if(str.charAt(i) >= 'd' && str.charAt(i) <= 'f'){
sb.append(3);
}else if(str.charAt(i) >= 'g' && str.charAt(i) <= 'i'){
sb.append(4);
}else if(str.charAt(i) >= 'j' && str.charAt(i) <= 'l'){
sb.append(5);
}else if(str.charAt(i) >= 'm' && str.charAt(i) <= 'o'){
sb.append(6);
}else if(str.charAt(i) >= 'p' && str.charAt(i) <= 's'){
sb.append(7);
}else if(str.charAt(i) >= 't' && str.charAt(i) <= 'v'){
sb.append(8);
}else if(str.charAt(i) >= 'w' && str.charAt(i) <= 'z'){
sb.append(9);
}
}
//判断是否为大写字母
else if(Character.isUpperCase(str.charAt(i))) {
if(str.charAt(i) == 'Z') {
sb.append('a');
}else {
//char ch = Character.toLowerCase(str.charAt(i));
char ch = (char) (str.charAt(i) + 32 + 1);
sb.append(ch);
}
}
}
System.out.println(sb.toString());
}
}
}
其他代码：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(password(sc.next()));
}
public static String password(String str) {
if (str == null || "".equals(str))
return str;
char[] nums = str.toCharArray();
StringBuilder sb = new StringBuilder();
for (char c : nums) {
if (c >= 'a' && c <= 'z') {
if (c == 's' || c == 'v'|| c == 'y' || c == 'z')
sb.append((c - 'a') / 3 + 1);
else
sb.append((c - 'a') / 3 + 2);
} else if (c >= 'A' && c <= 'Z') {
if (c == 'Z')
sb.append('a');
else
sb.append((char)(c + 'a' - 'A' + 1));
} else {
sb.append(c);
}
}
return sb.toString();
}
}相关知识点：
1.判断数字、大小写：Character.isDigit(char ch); Character.isLowerCase(char ch); Character.isUpperCase(char ch);
2.大小写转换：Character.toLowerCase(char ch); Character.toUpperCase(char ch); ch += 32;(转小写) ch -= 32;(转大写)
3.字母加一：ch += 1;
十四、汽水瓶
题目描述：
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入描述：
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出描述：
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
输入： 输出：
3 1
10 5
81 40
0
import java.util.Scanner;
public class sodaBottle {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
int num = sc.nextInt();
if(num == 0) {
break;
}
System.out.println(total(num));
}
}
public static int total(int num) {
if(num == 1) {
return 0;
}
int divisor = 0, remainder = 0, total = 0;
while(num > 2) {
divisor = num / 3;
remainder = num % 3;
num = divisor + remainder;
total += divisor;
if(num == 2) {
num = 3;
}
}
return total;
}
}相关知识点：
1.对题目分析，对给定的瓶数先除以三，商为已经喝到的瓶数，余数为剩下的瓶数，商+余数为现在剩余的总瓶数，不断循环直到瓶数=1或0停止。
十五、删除字符串中出现次数最少的字符
题目描述：
实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
输入描述：
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述：
删除字符串中出现次数最少的字符后的字符串。
输入： 输出：
abcdd dd
import java.util.HashMap;
import java.util.Scanner;
public class deleteString {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
for(int i = 0; i < str.length(); i++){
if(map.containsKey(str.charAt(i))){
map.put(str.charAt(i),map.get(str.charAt(i))+1);
}else{
map.put(str.charAt(i),1);
}
}
int num = Integer.MAX_VALUE;
for(Character key : map.keySet()){
num = Math.min(num, map.get(key));
}
for(Character key1 : map.keySet()){
if(map.get(key1) == num){
str=str.replaceAll(key1.toString(),"");
}
}
System.out.println(str);
}
}
}
其他方式：（类似桶排序）
import java.util.Scanner;
public class deleteString {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
if(str.length() > 20){
continue;
}
int[] max = new int[26];
char[] ch = str.toCharArray();
int min = Integer.MAX_VALUE;
for(int i = 0; i < ch.length; i++){
max[ch[i] - 'a']++;
min = min>max[ch[i] - 'a']?max[ch[i] - 'a']:min;
}
for(int i = 0; i < max.length; i++){
if(max[i] == min){
str = str.replaceAll(String.valueOf((char)(i + 97)), "");
}
}
System.out.println(str);
}
}
}
相关知识点：
1.先利用Map统计每个字符出现的次数。利用增强for循环，通过键值获得value值。
2.map的用法，利用get（key）可以获取对应键值的value，put（key,value）可以存值，keyset（）可以获取相应的key值，entryset（）可以获取key和value
3.利用26个英文字母，每个字母占一个数组，对每个字母进行统计，并增加相应的数组，小写字母减a即可获得对应的数组下标。大写字母可以从26开始存放即为大写字母减A+26。再将数值转为小写字母时，即为数组下标+97，A是0+65，0=48，空格=32。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
