老师说作为一个程序员，最重要的是要多练习，多动手。
另一个老师说，程序员需要保证有一个定期的总结和输出。
我觉得写这个博客是就是个对于我来说就是个唯一的办法了哈哈哈哈。
坚持才是最重要的，不要怕烂开始，那我就尽量什么都发一发，也当是记录一下吧。
最近秋招开始了，我也趁着这个机会去报名了一些公司，经历了几场线上笔试之后发现大厂都算法的要求很高，而我自己的算法就是一塌糊涂。所以打算要开始抓紧时间去学习和连续算法。在这记录几道我做得出来的题目。
一 ：
小易今天读了一篇英语文章，他现在想从里面找出一个单词作为这篇文章的关键词，一个单词可以作为关键词当且仅当它在这篇文章中出现的频率不低于1>% ，
现在他想知道有多少个不同的单词可以作为关键词。
一个单词出现的频率 =（这个单词出现的次数/这篇文章的单词总数）X100%
import java.util.*;
/* Author:Zhuzhide */
public class HashMapAndDouble {
public static void main(String arg[]) {
Scanner scan =new Scanner(System.in);
int n = scan.nextInt();
//將正整数n转为Double型方便后面的计算
Double all = (double) n;
Map<String,Integer> times = new HashMap<String,Integer>();
//Set集合里面的内容是不可重复的
Set<String> words = new HashSet<String>();
scan.nextLine();
while(n>0) {
String word = scan.nextLine();
//判断如果Set集合里有该单词，则在Map集合里增加其出现次数
if(words.contains(word.toString())) {
Integer time = times.get(word);
time = time+1;
times.replace(word, time);
//否则往Set集合添加该新单词，并在Map集合中记录出现次数为1
}else {
Integer time = 1;
times.put(word.toString(), time);
words.add(word);
}
n--;
}
scan.close();
//关键词的数量
int num = 0 ;
//循环遍历Map集合
for(String key:times.keySet()) {
//获取该单词的出现次数
Double time = (double)times.get(key);
//计算该单词出现的频率
Double rate = (double) (time/all);
if(rate>= 0.01) {
num++;
}
}
System.out.println(num);
}
}
二 ：
小Q想要给他的朋友发送一个神秘字符串，但是他发现字符串的过于长了，
于是小Q发明了一种压缩算法对字符串中重复的部分进行了压缩，
对于字符串中连续的m个相同字符串S将会压缩为m|S，
例如字符串ABCABCABC将会被压缩为[3|ABC]，现在小Q的同学收到了小Q发送过来的字符串，你能帮助他进行解压缩么？
import java.util.*;
/* Author:Zhuzhide */
public class indexOfAndSubstring {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String input = scan.nextLine();
scan.close();
//当输入的字符串中有"]"时进入循环
while (input.indexOf("]") != -1) {
//记录第一个"]"的位置, 其实也相当于是第1个被压缩的字符串的最内层的"]"
int right = input.indexOf("]");
//从一个"]"位置向前寻找最近的"["
int left = input.lastIndexOf("[",right);
//substring(int beginIndex, int endIndex)方法：beginIndex(包括); endIndex(不包括)
//获取"[xxxx]"前的字符
String fontWord = input.substring(0,left);
//获取"[xxxx]"后的字符
String backWord = input.substring(right+1,input.length());
//从"]"处向前寻找获取最近的"|"的位置
int numRight = input.lastIndexOf("|",right);
//获取"|"之后到"]"前的字符串，也就是被压缩的字符
String repate = input.substring(numRight+1,right);
//获取"["之后到"|"之前的字符串,并转成int类型,即为被压缩的次数
int times = Integer.parseInt(input.substring(left+1,numRight));
//先用前一段字符串创建一个StringBuffer
StringBuffer fwSb = new StringBuffer(fontWord);
//根据被压缩次数,循环添加进入StringBuffer中
for(int i=0;i<times ;i++) {
fwSb.append(repate);
}
//获得一个新的字符串，再次循环
input = fwSb.toString()+backWord;
}
System.out.println(input);
}
}
三 ：
Z国的货币系统包含面值1元、4元、16元、64元共计4种硬币，以及面值1024元的纸币。
现在小Y使用1024元的纸币购买了一件价值为N(0 < N < 1024)的商品，请问最少他会收到多少硬币？
import java.util.*;
/* Author:Zhuzhide */
public class money {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int N = scan.nextInt();
// 计算出剩下需要找零的金额
int change = 1024 - N;
scan.close();
int num = 0;
int money = 0;
// 计算出使用64元硬币后余下的金额
money = change % 64;
// 获取使用64元硬币的数量
num = change / 64;
// 接下来的步骤类似
if (money > 0) {
num = num + money / 16;
money = money % 16;
if (money > 0) {
num = num + money / 4;
money = money % 4;
if (money > 0) {
num = num + money;
}
}
System.out.println(num);
}
}
}
四 ：
检查是否为有效字符串
import java.util.*;
/* Author:Zhuzhide */
public class NormalString {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
scanner.close();
//排除不包含"的字符串
if (input.indexOf('"') == -1) {
System.out.println("false");
//排除最后一个不为"的字符串
} else if (input.lastIndexOf('"') != input.length() - 1) {
System.out.println("false");
//排除长度少于2的字符串
} else if (input.length() < 2) {
System.out.println("false");
//在上面的基础上再排除第二个字符为"的字符串
}else if(input.charAt(1) == '"') {
System.out.println("false");
//如果倒数第二个字符是"如果没有被转义的话则排除
}else if (input.charAt(input.length()-2) == '"' && input.charAt(input.length()-3)!='\\') {
System.out.println("false");
//如果倒数第一个字符是转义符也排除
}else if(input.charAt(2) == '\\') {
System.out.println("false");
}
else {
System.out.println("true");
}
}
}
五 ：
为了得到一个数的"相反数",我们将这个数的数字顺序颠倒,然后再加上原先的数得到"相反数"。
例如,为了得到1325的"相反数",首先我们将该数的数字顺序颠倒,我们得到5231,之后再加上原先的数,
我们得到5231+1325=6556.如果颠倒之后的数字有前缀零,前缀零将会被忽略。如n = 100, 颠倒之后是1.
import java.util.*;
/* Author:Zhuzhide */
public class ReverseNumber {
public static void main(String[] args) {
Scanner sa = new Scanner(System.in);
int input = sa.nextInt();
sa.close();
if (input > 0) {
//将输入的整数转换为字符串
String inputStr = Integer.toString(input);
//将字符串转换为StringBuffer
StringBuffer inputSb = new StringBuffer(inputStr);
//利用StringBuffer的reverse()方法将其进行翻转
String reverseInput = inputSb.reverse().toString();
//将翻转后的字符串转换回整型（因为是整型所以前缀零都会被忽略掉）
int outPut = Integer.parseInt(reverseInput);
//将两数相加得到结果
int result = outPut + input;
System.out.println(result);
} else {
System.out.println(0);
}
}
}
六 ：
给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。
请注意，它是排序后的第k小元素，而不是第k个元素。
示例:
matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,
返回 13。
说明:
你可以假设 k 的值永远是有效的, 1 ≤ k ≤ n2 。
import java.util.*;
/* Author:Zhuzhide */
public class Sort {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int k = scan.nextInt();
int n = scan.nextInt();
//通过n*n获取矩阵中元素的个数
int data [] =new int [n*n];
for(int i = 0; i<n*n; i++) {
data[i] = scan.nextInt();
}
scan.close();
//Collection.sort是对list进行排序，Arrays.sort是对数组进行排序
//sort默认的是升序
Arrays.sort(data);
System.out.println(data[k-1]);
}
}
七 ：
小易得到了一个仅包含大小写英文字符的字符串，该字符串可能不是回文串。（“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串，“asds”就不是回文串。） 小易可以在字符串尾部加入任意数量的任意字符，使其字符串变成回文串。
现在请你编写一个程序，程序要能计算出小易可以得到的最短回文串。
import java.util.*;
/* Author:Zhuzhide */
public class StringBufferReverse {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String input = scan.nextLine();
scan.close();
StringBuffer inputSB = new StringBuffer();
inputSB.append(input);
//使用StringBuffer来对字符串进行翻转
String stringReverse = inputSB.reverse().toString();
//如果翻转过来的字符串是与原本的字符串相同的话就是回文串，输出并结束任务
if (stringReverse.equals(input)) {
System.out.println(stringReverse);
return;
} else {
String newInput = input;
String newReverse = stringReverse;
int num = 0;
//当翻转过来的字符串与原来字符串不相等时进入循环
//逐个删除字符串两端字符，直到相等
//如：input = noo ;
//循环1: noo != oon
//循环2: oo == oo
while (!newReverse.equals(newInput)) {
//逐个删除
newInput = newInput.substring(1, newInput.length());
newReverse = newReverse.substring(0, newReverse.length() - 1);
num++;
}
//在原字符串后面拼接上删除掉的翻转字符串则得到最短回文串
stringReverse = input + stringReverse.substring(stringReverse.length() - num, stringReverse.length());
System.out.println(stringReverse);
}
}
}
八 ：
输入两个字符串a和b，字符串内容为二进制数字，求两个字符串相加的结果，
加法计算方法以二进制方式计算，并返回对应的字符串结果。要求程序尽可能的高效。
import java.util.Scanner;
/* Author:Zhuzhide */
public class toBinaryString {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String a = scan.next();
String b = scan.next();
scan.close();
//2个将字符串转为int类型
int a1 = Integer.valueOf(a, 2);
int b1 = Integer.valueOf(b,2);
//Integer.toBinaryString(int) 将int转成2进制
//Integer.toOctalString(int) 将int转成8进制
//Integer.toHexString(int) 将int转成16进制
//输出二者相加
String outPut = Integer.toBinaryString(a1+b1);
System.out.println(outPut);
}
}
九 ：
小A刚学了二进制，他十分激动。为了确定他的确掌握了二进制，你给他出了这样一道题目：给定N个非负整数，
将这N个数字按照二进制下1的个数分类，二进制下1的个数相同的数字属于同一类。求最后一共有几类数字？
import java.util.*;
/* Author:Zhuzhide */
public class toBinaryStringAndHashSet {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int T = scan.nextInt();
while (T > 0) {
T--;
int N = scan.nextInt();
// Set集合中不会出现重复的元素
Set<Integer> type = new HashSet<Integer>();
for (int i = 0; i < N; i++) {
int num = scan.nextInt();
// 将输入的非负整数转成二进制数
String numBinary = Integer.toBinaryString(num);
// 将二进制数中的'0'去除
String newNumBinary = numBinary.replaceAll("0", "");
// 获取到'1'的个数，并存进set集合中
type.add(numBinary.length() - newNumBinary.length());
}
// 此时set集合的里元素的个数就是数字一共有几类
System.out.println(type.size());
}
scan.close();
}
}
以上的代码都是我自己写的，能通过测试用例，但是具体内容是否完全正确我就无法保证。
肯定都会有不完美的地方，希望有大佬能指出我的错误，优化我的代码。
题目来源：牛客网https://www.nowcoder.com （不知道会不会侵权，侵删）
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
