leetcode/nowcoder-huawei-1-入门题

1.入门题

1、输入处理：HJ5-进制转换

1. 描述

   写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
   
   数据范围：保证结果在 1≤n≤2^{31}-1
   
   输入描述：
   输入一个十六进制的数值字符串。
   
   输出描述：
   输出该数值的十进制字符串。不同组的测试用例用\n隔开。
   
   示例1
   输入：
   0xAA
   复制
   输出：
   170
   

2. 思路

   获取所有的字符，得到对应的数字

   每次获取char，总数左移四位，再按位或当前char对应的数字

3. 代码

   #include<iostream>
   using namespace std;
   #include <string>
   int getHex(char ch) {
       int num;
       if (ch >= '0' && ch <= '9')       num = ch - '0';
       else if (ch == 'A' || ch == 'a')  num = 10;
       else if (ch == 'B' || ch == 'b')  num = 11;
       else if (ch == 'C' || ch == 'c')  num = 12;
       else if (ch == 'D' || ch == 'd')  num = 13;
       else if (ch == 'E' || ch == 'e')  num = 14;
       else if (ch == 'F' || ch == 'f')  num = 15;
       return num;
   }
   
   int change2Hex(string str) {
       char ch;
       int tmp,num = 0;
       for(int i = 2; i < str.size(); i++) {
           ch = str[i];
           tmp = getHex(ch);
           printf("getHex  %d\n",tmp);
           num = num << 4;
           printf("<<4  %d\n",ch,num);
           num = num | tmp;
           printf("ch %c     num %d\n",ch,num);
       }
       return 0;
   }
   
   int main() {
       string str;
       while (cin>>str) {
           cout << "   ------ >>>>  " << str << endl;
           change2Hex(str);
       }
       return 0;
   }
   

2、两数之和

1. 描述

   给出一个整型数组 numbers 和一个目标值 target，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
   （注：返回的数组下标从1开始算起，保证target一定可以由数组里面2个数字相加得到）
    
   要求：空间复杂度 O(n)O(n)，时间复杂度 O(nlogn)O(nlogn)
       
   示例1
   输入:		[3,2,4],6
   返回值：	[2,3]
   说明：
   因为 2+4=6 ，而 2的下标为2 ， 4的下标为3 ，又因为 下标2 < 下标3 ，所以返回[2,3]
       
   示例2
   输入：		[20,70,110,150],90
   返回值：	[1,2]
   复制
   说明：		20+70=90
   

2. 思路

   暴力解法：两个指针，两个 和数，得到结果后就返回索引

   于是超时了

   节省时间：将索引和数字放入map

3. 代码

   • 暴力解法

   class Solution {
   public:
       vector<int> twoSum(vector<int>& numbers, int target) {
           for(int i = 0; i < numbers.size(); i++) {
               for(int j = i + 1; j < numbers.size(); j++) {
                   if(numbers[i] + numbers[j] == target)
                       return {i+1,j+1};
               }
           }
           return {};
       }
   };
   

   • 节省时间

   class Solution {
   public:
       vector<int> twoSum(vector<int>& numbers, int target) {
           map<int,int> nums;
           int tmp;
           for(int i = 0; i < numbers.size(); i++) {
               tmp = numbers[i];
               if(!nums[tmp])
                   nums[tmp] = i + 1;
               printf(" %d  -- %d\n",tmp,nums[tmp]);
           }
           printf("\n");
           int index;
           for(int i = 0; i < numbers.size(); i++) {
               tmp = target - numbers[i];
               index = nums[tmp];
               printf(" %d  -- %d\n",tmp,index);
               if(index && index != i + 1) {
                   if(index > i + 1)   return {i + 1, index};
                   else        return {index, i + 1};
               }
           }
           return {};
       }
   };
   

3、明明的随机数

1. 描述

   描述
   明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
   
   数据范围： 1≤n≤1000  ，输入的数字大小满足 1≤val≤500 
   输入描述：
   第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。
   输出描述：
   输出多行，表示输入数据处理后的结果
   
   示例1
   输入：
   3
   2
   2
   1
   输出：
   1
   2
   复制
   说明：
   输入解释：
   第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：
   2
   2
   1
   所以样例的输出为：
   1
   2       
   

2. 思路

   获取数字，放入数组，数组排序 ，打印不相同的数字

3. 代码

   #include <iostream>
   using namespace std;
   #include <vector>
   #include <algorithm>
   
   int main() {
       int m;
       int tmp;
       cin >> m;
       vector<int> nums;
       for(int i = 0; i < m; i++) {
           cin >> tmp;
           nums.push_back(tmp);
       }
       for(int i = 0; i < m; i++) {
           printf("%d    ",nums[i]);
       }
       printf("\n");
       sort(nums.begin(),nums.end());
       for(int i = 0; i < m; i++) {
           if(i == 0 || tmp != nums[i]) {
               tmp = nums[i];
               cout << tmp << endl;
           }
       }
       return 0;
   }
   

4、字符个数统计

1. 描述

   编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
   例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
   
   数据范围： 1≤n≤500 
   输入描述：
   输入一行没有空格的字符串。
   
   输出描述：
   输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
   
   示例1
   输入：	abc
   输出：	3
   示例2
   输入：	aaa
   输出：	1
   

2. 思路

   遍历数组，获取所有的字符放入map并更新个数

   直接返回map的size

3. 代码

   #include <iostream>
   using namespace std;
   #include <string>
   #include <map>
   int getChars(string str) {
       map<char,int> ch;
       for(int i = 0; i < str.size(); i++) {
           ch[str[i]]+=1;
       }
       return ch.size();
   }
   
   int main() {
       string str;
       cin >> str;
       cout << getChars(str) << endl;
       return 0;
   }
   

5、跳台阶

1. 描述

   一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
   
   数据范围：1≤n≤40
   要求：时间复杂度：O(n)O(n) ，空间复杂度： O(1)O(1)
   示例1
   输入：		2
   返回值：	2
   说明：
   青蛙要跳上两级台阶有两种跳法，分别是：先跳一级，再跳一级或者直接跳两级。因此答案为2       
   示例2
   输入：		7
   返回值：	21
   

2. 思路

   动态规划，到达当前台阶的可能性等于i-1和i-2两种可能性之和

3. 代码

   #include <iostream>
   using namespace std;
   int stepJump(int step) {
       int dp[step + 1] = {0};
       if(step <= 1)   return step;
       dp[1] = 1;
       dp[0] = 1;
       for(int i = 2; i <= step; i++) {
           dp[i] = dp[i-1] + dp[i-2];
           printf("%d   ",dp[i]);
       }
       printf("\n");
       return dp[step];
   }
   
   int main() {
       int step = 7;
       cout << stepJump(step) << endl;
       return 0;
   }