HJ1 字符串最后一个单词的长度
描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：
输入一行，代表要计算的字符串，非空，长度小于5000。
输出描述：
输出一个整数，表示输入字符串最后一个单词的长度。
示例1
输入：hello nowcoder
输出：8
说明：最后一个单词为nowcoder，长度为8
代码
#include <iostream>
#include <string>
using namespace std;
int main(){
string str;
getline(cin, str);
int loc = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] == ' ') {
loc = i + 1;
}
}
cout << str.size() - loc << endl;
return 0;
}
HJ2 计算某字符出现次数
描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
数据范围： 1 ≤ n ≤ 1000 1\le n\le 1000 1≤n≤1000
输入描述：
第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）
代码
注：题目中字符串包含数字，大小写字母直接用ASCII码相差32判断并不行，因为存在数字字符和字母之间ASCII码相差32。
例如：字符0的ASCII码值为48，字符P的ASCII码值为80
#include<iostream>
#include<string>
using namespace std;
int main(){
string str;
char ch;
int count = 0;
getline(cin, str);
cin >> ch;
for (int i = 0; i < str.size(); i++) {
if (str[i] == toupper(ch) || str[i] == tolower(ch)) {
count++;
}
}
cout << count << endl;
return 0;
}
HJ3 明明的随机数
描述
明明生成了N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
数据范围： 1 ≤ n ≤ 1000 1 \le n \le 1000 1≤n≤1000 ，输入的数字大小满足 1 ≤ v a l ≤ 500 1 \le val \le 500 1≤val≤500
输入描述：
第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。
输出描述：
输出多行，表示输入数据处理后的结果
代码
#include <iostream>
using namespace std;
int main() {
int N, n;
while (cin >> N) {
int a[1001] = {
0 };
while (N--) {
cin >> n;
a[n] = 1;
}
for (int i = 0; i < 1001; i++)
if (a[i])
cout << i << endl;
}
return 0;
}
HJ4 字符串分隔
描述
-
输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
-
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：
连续输入字符串(每个字符串长度小于等于100)
输出描述：
依次输出所有分割后的长度为8的新字符串
代码
注：需要了解substr的用法
#include <iostream>
using namespace std;
int main(){
string str;
while(getline(cin,str)){
while(str.size() > 8){
cout << str.substr(0, 8) << endl;
str = str.substr(8);
}
cout << str.append(8 - str.size(),'0') << endl; //不够8位的补0
}
}
HJ5 进制转换
描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
数据范围：保证结果在 1 ≤ n ≤ 2 31 − 1 1 \le n \le 2^{31}-1 1≤n≤231−1
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。
代码
#include <iostream>
using namespace std;
int main() {
int a;
while (cin >> hex >> a)
cout << a << endl;
return 0;
}
HJ6 质数因子
描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
数据范围： 1 ≤ n ≤ 2 × 1 0 9 + 14 1 \le n \le 2 \times{10^{9} + 14} 1≤n≤2×109+14
输入描述：
输入一个整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。
示例：
输入：180
输出：2 2 3 3 5
代码
思路： 1. 先从 2 至 n 2至\sqrt{n} 2至n除 n n n，记录下这个除数，然后用商去继续进行上述的操作，直到商为1
2. 如果除不进，除数加一。如果一直加一，除数大于 n \sqrt{n} n，则说明x的质因子只有它本身。
#include<iostream>
#include <math.h>
using namespace std;
int main(){
int n;
while (cin >> n) {
for (int i = 2; i <= sqrt(n); i++) {
while (n%i == 0) {
cout << i << ' ';
n /= i;
}
}
if (n > 1) {
cout << n << endl;
}
}
return 0;
}
HJ7 取近似值
描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。
数据范围：保证输入的数字在 32 位浮点数范围内
输入描述：
输入一个正浮点数值
输出描述：
输出该数值的近似整数值
示例1：
输入：5.5
输出：6
说明：0.5>=0.5，所以5.5需要向上取整为6
示例2：
输入：2.499
输出：2
说明：0.499<0.5，2.499向下取整为2
代码
#include <iostream>
using namespace std;
int main(){
double n;
while (cin >> n) {
cout << int(n+0.5) << endl;
}
return 0;
}
HJ8 合并表记录
描述
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
提示:
- 0 < = i n d e x < = 11111111 0 <= index <= 11111111 0<=index<=11111111
- 1 < = v a l u e < = 100000 1 <= value <= 100000 1<=value<=100000
输入描述：
先输入键值对的个数 n n n（ 1 < = n < = 500 1 <= n <= 500 1<=n<=500）
接下来n行每行输入成对的index和value值，以空格隔开
输出描述：
输出合并后的键值对（多行）
代码
题目中要求结果升序输出，由此想到map容器
#include<iostream>
#include<map>
using namespace std;
int main(){
map<int, int> result;
int n;
int a, b;
while (cin >> n) {
// 将数据读入map容器
while (n--) {
cin >> a >> b;
if (result.find(a) == result.end()) {
result.insert(pair<int, int>(a, b));
}
else {
result[a] += b;
}
}
// 输出
for (map<int, int>::iterator it = result.begin(); it != result.end(); it++) {
cout << it->first << " " << it->second << endl;
}
}
return 0;
}
HJ9 提取不重复的整数
描述
输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。
数据范围： 1 ≤ n ≤ 1 0 8 1 \le n \le 10^{8} 1≤n≤108
输入描述：
输入一个int型整数
输出描述：
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例：
输入：9876673
输出：37689
代码
#include <iostream>
#include <string>
#include <unordered_set>
using namespace std;
int main(){
unordered_set<int> result;
int n;
while (cin >> n) {
//分解整数
while (n >= 10) {
if (result.find(n%10) == result.end()) {
//在哈希表中未找到
result.insert(n%10); //取余，并添加到哈希表
cout << n % 10; //打印
n /= 10;
}
else {
n /= 10;
}
}
// 当n为个位数时，若在哈希表中未找到，则输出
if (result.find(n) == result.end()) {
cout << n;
}
else {
cout << endl;
}
}
return 0;
}
HJ10 字符个数统计
描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
数据范围： 1 ≤ n ≤ 500 1 \le n \le 500 1≤n≤500
输入描述：
输入一行没有空格的字符串。
输出描述：
输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
示例1
输入：abc
输出：3
示例2
输入：aaa
输出：1
代码
#include<iostream>
#include<string>
#include<set>
using namespace std;
int main(){
set<char> st;
string str;
while (cin >> str) {
for (int i = 0; i < str.size(); i++) {
st.insert(str[i]); //往set容器中插入元素
}
cout << st.size() << endl;
}
return 0;
}
HJ11 数字颠倒
描述
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
数据范围： 0 ≤ n ≤ 2 30 − 1 0 \le n \le 2^{30}-1 0≤n≤230−1
输入描述：
输入一个int整数
输出描述：
将这个整数以字符串的形式逆序输出
示例1
输入：1516000
输出：0006151
示例2
输入：0
输出：0
代码
思路：掌握to_string方法，然后反转即可
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
int n;
string str;
while (cin >> n) {
str = to_string(n);
reverse(str.begin(), str.end());
cout << str;
}
return 0;
}
HJ12 字符串反转
描述
接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
输入描述：
输入一行，为一个只包含小写字母的字符串。
输出描述：
输出该字符串反转后的字符串。
示例1
输入：abcd
输出：dcba
代码
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main(){
string str;
while (cin >> str) {
reverse(str.begin(), str.end());
cout << str;
}
}
HJ13 句子逆序
描述
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
数据范围：输入的字符串长度满足 1 ≤ n ≤ 1000 1 \le n \le 1000 1≤n≤1000
注意本题有多组输入
输入描述：
输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。
输出描述：
得到逆序的句子
示例1
输入：I am a boy
输出：boy a am I
示例2
输入：nowcoder
输出：nowcoder
代码
思路：1. 先将句子整体逆序；2. 再将局部单词逆序。本题与151.翻转字符串里的单词是差不多的。
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
void reverse(string& s, int start, int end) {
//翻转，区间写法：左闭又闭 []
for (int i = start, j = end; i < j; i++, j--) {
swap(s[i], s[j]);
}
}
int main() {
string str;
int left = 0;
int right = 0;
while (getline(cin, str)) {
reverse(str, 0, str.size() - 1); //整个反转
//局部单词反转
for (int i = 0; i <= str.size(); i++) {
if (i == str.size() || str[i] == ' ') {
//空格或字符串末尾就得反转
right = i - 1;
reverse(str, left, right);
left = i + 1;
}
}
cout << str;
}
return 0;
}
HJ14字符串排序
描述
给定 n n n 个字符串，请对 n n n 个字符串按照字典序排列。
数据范围： 1 ≤ n ≤ 1000 1 \le n \le 1000 1≤n≤1000，字符串长度满足 1 ≤ l e n ≤ 100 1 \le len \le 100 1≤len≤100
输入描述：
输入第一行为一个正整数n( 1 ≤ n ≤ 1000 1≤n≤1000 1≤n≤1000)，下面n行为n个字符串(字符串长度 ≤ 100 ≤100 ≤100)，字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串。
代码
思路1：使用sort算法快排
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
vector<string> vc;
string str;
int n;
while (cin >> n) {
while (n--) {
//将n个字符串读入数组中
cin >> str;
vc.push_back(str);
}
sort(vc.begin(), vc.end());
for (int i = 0; i < vc.size(); i++) {
cout << vc[i] << endl;
}
}
return 0;
}
思路2：multiset容器自带排序
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
int main(){
multiset<string> st;
string str;
int n;
while (cin >> n) {
while (n--) {
//将字符串输入set容器
cin >> str;
st.insert(str);
}
for (auto it = st.begin(); it != st.end(); it++) {
cout << (*it) << endl;
}
}
return 0;
}
HJ15 求int型正整数在内存中存储时1的个数
描述
输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。
数据范围：保证在 32 位整型数字范围内
输入描述：
输入一个整数（int类型）
输出描述：
这个数转换成2进制后，输出1的个数
示例1
输入：5
输出：2
示例2
输入：0
输出：0
代码
#include <iostream>
using namespace std;
int main()
{
int i, count = 0;
cin >> i;
while (i > 0) {
if (i & 1) count++;
i >>= 1;
}
cout << count;
return 0;
}
HJ17 坐标移动
描述
开发一个坐标计算工具， 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）
数据范围：每组输入的字符串长度满足 1 ≤ n ≤ 10000 1\le n \le 10000 1≤n≤10000 ，坐标保证满足 − 2 31 ≤ x , y ≤ 2 31 − 1 -2^{31} \le x,y \le 2^{31}-1 −231≤x,y≤231−1，且数字部分仅含正数
输入描述：
一行字符串
输出描述：
最终坐标，以逗号分隔
示例1
输入：A10;S20;W10;D30;X;A1A;B10A11;;A10;
输出：10,-10
示例2
输入：ABC;AKL;DA1;
输出：0,0
代码
思路：先将字符串按分号分割，再挑选目标字符串进行计算，注意其中字符与数字的转换
#include <iostream>
#include <string>
#include <vector>
#include <set>
using namespace std;
int main() {
string s;
string str; //每个字符串
getline(cin, s); //总字符串
vector<string> vc; //存放分割后的字符串
int x = 0, y = 0;
for (int i = 0; i <= s.size(); i++) {
if (s[i] == ';' || i == s.size()) {
//找到;或者字符串末尾，捕获前面一个字符串
vc.push_back(str);
str.clear();
}
else {
str += s[i];
}
}
// 遍历搜寻目标字符串
for (int j = 0; j < vc.size(); j++) {
int num = 0; //每次初始化为0
if (vc[j].size() == 3 && vc[j][1] >= '0' && vc[j][1] <= '9'
&& vc[j][2] >= '0' && vc[j][2] <= '9') {
num = (vc[j][1] - '0') * 10 + (vc[j][2] - '0');
}
if (vc[j].size() == 2 && vc[j][1] >= '0' && vc[j][1] <= '9') {
num = (vc[j][1] - '0');
}
switch (vc[j][0]) {
case 'A': x -= num;
break;
case 'D': x += num;
break;
case 'S': y -= num;
break;
case 'W': y += num;
break;
default:
break;
}
}
cout << x << "," << y << endl;
return 0;
}