10.7 Fizz Buzz 经典问题
1. 题目
2. 解题思路
【法1】逻辑硬解：按照题目逻辑分四种情况，用if else 判断即可。
【法2】switch语句无脑判断：跳出思维逻辑，多引入一个变量，懒人做法。
【法3】if条件表达式判断：这里需要注意的是逻辑与运算符（&&）的运用，只有都为真，整个表达式的值才为真，这里可以不单独判断同时被3和5整除的情况。
【法4】条件运算符（三元运算符）：需要一些额外操作，且用到三元条件运算符，此方法相对来说最简单，代码量最少。
3. 代码实现（AC_Code）
- C++
法1
#include <iostream>
using namespace std;
int main()
{
int N;
cin >> N;
if(N % 3 == 0)
{
if(N % 5 == 0)
cout << "FizzBuzz" << endl;
else
cout << "Fizz" << endl;
}
else if(N % 5 == 0)
cout << "Buzz" << endl;
else
cout << N << endl;
return 0;
}
法2
#include <iostream>
using namespace std;
int main()
{
int N,a = 0;
cin >> N;
if(N % 3 == 0)
a = 1;
if(N % 5 == 0)
a = 2;
if(N % 3 == 0 && N % 5 == 0)
a = 3;
switch(a)
{
case 0:
cout << N << endl;
break;
case 1:
cout << "Fizz" << endl;
break;
case 2:
cout << "Buzz" << endl;
break;
case 3:
cout << "FizzBuzz" << endl;
break;
}
return 0;
}
法3
#include <iostream>
using namespace std;
int main()
{
int N;
cin >> N;
if(!(N % 3))
cout << "Fizz";
if(!(N % 5))
cout << "Buzz";
if(N % 3 && N % 5)
cout << N << endl;
return 0;
}
- Java
法4
import java.io.BufferedInputStream; // 位于java.io包中，这个类用于提供对输入流的缓冲功能
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(new BufferedInputStream(System.in, 128));
public static void main(String[] args) {
int n = sc.nextInt();
System.out.print(n % 3 == 0 && n % 5 == 0 ? "FizzBuzz" : n % 5 == 0 ? "Buzz" : n % 3 == 0 ? "Fizz" : n);
}
}
10.8 确定字符串是否是另一个的排列
1. 题目
2. 解题思路
题目核心要求：理解字符串排列，判断str2是否为str1的排列。
排列：如果将 str1的字符拆分开，重新排列后再拼接起来，能够得到str2，那么就说字符串str2是字符串str1的排列。（不忽略大小写）
第一步：将str1、str2分别进行冒泡排序（这里按照从小到大排序）。
第二步：判断两个字符是否相等。
3. 代码实现（AC_Code）
- C++
#include <iostream>
#include <cstring> //包含 strlen 函数
using namespace std;
int main()
{
// 定义有长度限制的字符数组
char str1[100];
char str2[100];
cin >> str1 >> str2;
// 冒泡排序：将str1排序
for(int i = 0; i < strlen(str1) - 1; i++)
{
// 最后i个元素已经排序好，不用重复遍历
for(int j = 0; j < strlen(str1) - 1 - i; j++)
{
if(str1[j+1] < str1[j])
{
char temp = str1[j];
str1[j] = str1[j + 1];
str1[j + 1] = temp;
}
}
}
// 冒泡排序：将str2排序
for(int i = 0; i < strlen(str2) - 1; i++)
{
// 最后i个元素已经排序好，不用重复遍历
for(int j = 0; j < strlen(str2) - 1 - i; j++)
{
if(str2[j+1] < str2[j])
{
char temp = str2[j];
str2[j] = str2[j + 1];
str2[j + 1] = temp;
}
}
}
// 用strcmp函数判断两个字符是否相等
if(strcmp(str1,str2) == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
- Java
import java.util.Scanner;
import java.util.Arrays;
public class Main {
// 冒泡排序
public static void sort(char[] array,int n) {
for(int i = 0; i < n - 1; i++) {
for(int j = 0; j < n - 1 - i; j++) {
if(array[j + 1] < array[j]) {
char temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 输入两行字符串
String str1 = scan.nextLine();
String str2 = scan.nextLine();
// Java中的字符串是不可变的，所以我们需要将输入的字符串转换为字符数组来执行排序操作
char[] s1 = str1.toCharArray();
char[] s2 = str2.toCharArray();
// 排序
sort(s1,str1.length());
sort(s2,str2.length());
// 将排序后的字符数组转换为字符串
str1 = new String(s1);
str2 = new String(s2);
// 判断字符串是否相等
if(str1.equals(str2))
System.out.println("YES");
else
System.out.println("NO");
scan.close();
}
}
10.9 压缩字符串
1. 题目
2. 解题思路
-
定义一个函数compress_string，接收一个字符串s作为参数。
-
检查字符串是否为空，如果为空，返回"NO"。
-
初始化一个空字符串compressed用于存储压缩过程中的字符串，以及一个计数器count用于记录字符重复的次数。
-
遍历字符串，比较当前字符与前一个字符是否相同，如果相同，计数器加1；如果不同，将前一个字符和计数器（如果计数器大于1）添加到compressed字符串中，并重置计数器。
-
遍历结束后，处理最后一个字符，确保它也被添加到compressed字符串中。
-
构造最终的压缩字符串final_compressed，遍历原始字符串，计算每个字符的重复次数，并构建压缩字符串。
-
比较最终压缩字符串的长度与原始字符串的长度，如果压缩后的长度更短，返回压缩字符串；否则返回"NO"。
-
在main函数中，从标准输入读取一个字符串，调用compress_string函数，并输出结果。
3. 代码实现（AC_Code）
- C++
#include <iostream>
#include <string>
using namespace std;
// compress_string函数用于压缩输入字符串
string compress_string(const string& s)
{
// 如果字符串为空，返回"NO"
if(s.empty()) return "NO";
// 初始化压缩后的字符串和计数器
string compressed = "";
int count = 1;
char prev_char = s[0]; // 上一个字符初始化为字符串的第一个字符
// 遍历字符串，从第二个字符开始
for(int i =1; i < s.length(); ++i)
{
// 如果当前字符与前一个字符相同，计数器加1
if(s[i] == prev_char)
{
count++;
}
else
{
// 如果计数器大于1，说明有重复字符，将计数器转换为字符串并添加到压缩字符串中
if(count >1)
{
compressed += to_string(count);
}
// 将前一个字符添加到压缩字符串中
compressed += s[i-1];
// 更新前一个字符为当前字符，并重置计数器
prev_char = s[i];
count =1;
}
}
// 处理字符串的最后一个字符
if(count >1)
{
compressed += to_string(count);
}
// 将最后一个字符添加到压缩字符串中
compressed += s[s.length()-1];
// 构造最终压缩字符串
string final_compressed = "";
int i =0;
// 遍历原始字符串
while(i < s.length())
{
char current = s[i]; // 当前字符
int j = i;
// 计算当前字符重复的次数
while(j < s.length() && s[j] == current) j++;
int cnt = j -i; // 当前字符的计数
final_compressed += current; // 将当前字符添加到最终压缩字符串中
// 如果计数大于1，将计数添加到最终压缩字符串中
if(cnt >1)
{
final_compressed += to_string(cnt);
}
i = j; // 更新索引到下一个不同的字符
}
// 如果最终压缩字符串的长度小于原始字符串的长度，返回压缩字符串
if(final_compressed.length() < s.length())
{
return final_compressed;
}
else
{
// 否则返回"NO"，表示压缩没有效果
return "NO";
}
}
int main()
{
string s;
// 从标准输入读取字符串
cin >> s;
// 输出压缩后的字符串
cout << compress_string(s);
return 0;
}
- Java
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String str=scan.next();
StringBuilder sb=new StringBuilder();
for(int i=0;i<str.length();i++){
int count=0;
int j=i;
for(;j<str.length();j++){
if(str.charAt(i)==str.charAt(j)){
count++;
}
else{
break;
}
}
if(count>1){
sb.append(str.charAt(i));
sb.append(count);
i=j-1;
}
else{
sb.append(str.charAt(i));
}
}
if(sb.length()<str.length()){
System.out.print(sb.toString());
}
else{
System.out.print("NO");
}
scan.close();
}
}
10.10 求路程
1. 题目
2. 解题思路
s = t * v
3. 代码实现（AC_Code）
- C++
#include <iostream>
using namespace std;
int main()
{
int t,v;
cin >> t >> v;
cout << t * v << endl;
return 0;
}
- Java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int t = scan.nextInt();
int v = scan.nextInt();
System.out.println(t * v);
scan.close();
}
}
10.11 补 0 输出
1. 题目
2. 解题思路
第一步：将输入的数字转换为字符串。
第二步：利用for循环往前面补0。
第三步：完整输出。
3. 代码实现（AC_Code）
- C++
#include <iostream>
#include <string>
using namespace std;
int main()
{
int n;
cin >> n;
string s = to_string(n);
for(int i = 0; i < 8 - s.length(); i++)
cout << '0';;
cout << s << endl;
return 0;
}
- Java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
String s = Integer.toString(n);
for(int i = 0; i < 8 - s.length(); i++)
System.out.print('0');
System.out.println(s);
scan.close();
}
}
10.12 IP 补充
1. 题目
2. 解题思路
知识补充：IP地址的每一部分都是一个8位的二进制数（也称为一个“字节”），每个字节可以存储的最大值是255，它的数值范围是从0到255。
原因：因为二进制的8位可以表示的最大十进制数是255（即 11111111 转换为十进制就是 255）。
3. 代码实现（AC_Code）
- C++
#include <iostream>
using namespace std;
int main()
{
cout << "255" << endl;
return 0;
}
- Java
public class Main {
public static void main(String[] args) {
System.out.println("255");
}
}
10.13 出现最多的字符
1. 题目
2. 解题思路
第一步：定义一个21*21的二维数组存储矩阵字符。
第二步：遍历矩阵，遇到对应字符，则此字符+1。
第三步：将最后的a,b,c,d,e,f从小到大排序，输出出现次数最多的字符。
3. 代码实现（AC_Code）
- C++
#include <iostream>
#include <string>
#include <algorithm> // 包含冒泡排序（从小到大）的头文件
using namespace std;
int main()
{
// 考虑‘\0’
char Array[21][21] =
{
"FFEEFEAAECFFBDBFBCDA",
"DACDEEDCCFFAFADEFBBA",
"FDCDDCDBFEFCEDDBFDBE",
"EFCAAEECEECDCDECADDC",
"DFAEACECFEADCBFECADF",
"DFBAAADCFAFFCEADFDDA",
"EAFAFFDEFECEDEEEDFBD",
"BFDDFFBCFACECEDCAFAF",
"EFAFCDBDCCBCCEADADAE",
"BAFBACACBFCBABFDAFBE",
"FCFDCFBCEDCEAFBCDBDD",
"BDEFCAAAACCFFCBBAAEE",
"CFEFCFDEEDCACDACECFF",
"BAAAFACDBFFAEFFCCCDB",
"FADDDBEBCBEEDDECFAFF",
"CDEAFBCBBCBAEDFDBEBB",
"BBABBFDECBCEFAABCBCF",
"FBDBACCFFABEAEBEACBB",
"DCBCCFADDCACFDEDECCC",
"BFAFCBFECAACAFBCFBAF",
};
int A = 0,B = 0,C = 0,D = 0,E = 0,F = 0;
for(int i = 0; i < 20; i++)
{
for(int j = 0; j < 20; j++)
{
if(Array[i][j] == 'A')
A++;
if(Array[i][j] == 'B')
B++;
if(Array[i][j] == 'C')
C++;
if(Array[i][j] == 'D')
D++;
if(Array[i][j] == 'E')
E++;
if(Array[i][j] == 'F')
F++;
}
}
int newArray[6] = { A , B , C , D , E , F };
sort(newArray,newArray + 6);
cout << newArray[5] << endl;
return 0;
}
- Java
public class Main {
public static void main(String[] args) {
// 将矩阵转为字符串形式
String s =
"FFEEFEAAECFFBDBFBCDA\n"+
"DACDEEDCCFFAFADEFBBA\n"+
"FDCDDCDBFEFCEDDBFDBE\n"+
"EFCAAEECEECDCDECADDC\n"+
"DFAEACECFEADCBFECADF\n"+
"DFBAAADCFAFFCEADFDDA\n"+
"EAFAFFDEFECEDEEEDFBD\n"+
"BFDDFFBCFACECEDCAFAF\n"+
"EFAFCDBDCCBCCEADADAE\n"+
"BAFBACACBFCBABFDAFBE\n"+
"FCFDCFBCEDCEAFBCDBDD\n"+
"BDEFCAAAACCFFCBBAAEE\n"+
"CFEFCFDEEDCACDACECFF\n"+
"BAAAFACDBFFAEFFCCCDB\n"+
"FADDDBEBCBEEDDECFAFF\n"+
"CDEAFBCBBCBAEDFDBEBB\n"+
"BBABBFDECBCEFAABCBCF\n"+
"FBDBACCFFABEAEBEACBB\n"+
"DCBCCFADDCACFDEDECCC\n"+
"BFAFCBFECAACAFBCFBAF";
int[] cout = new int[6];
for(int i = 0; i < s.length(); i++) {
// 利用charAt：用下标获取单个字符
if(s.charAt(i) == 'A')
cout[0]++;
if(s.charAt(i) == 'B')
cout[1]++;
if(s.charAt(i) == 'C')
cout[2]++;
if(s.charAt(i) == 'D')
cout[3]++;
if(s.charAt(i) == 'E')
cout[4]++;
if(s.charAt(i) == 'F')
cout[5]++;
}
// 找出出现次数最大的字符
int max = 0;
for(int i = 0; i < 6; i++) {
if(cout[i] > max)
max = cout[i];
}
System.out.println(max);
}
}
最后，感谢您的阅读，期待您的一键三连！
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
