IXL Learning - OA

1. #include <iostream>
   
2. #include <cassert>
   
3. #include <cstring>
   
4. #include <climits>
   
5. #include <string>
   
6. #include <vector>
   
7. #include <utility>
   
8. using namespace std;
   
9. 
   
10. class Solution {
    
11. public:
    
12.         vector<int> p1(vector<int>& nums) {
    
13.                 int OPT[10] = {1, 0, 0, 0, 1, 0, 1, 0, 2, 1};
    
14.                 vector<int> result;
    
15.                 for (const auto &i : nums) {
    
16.                         string s = to_string(i);
    
17.                         int val = 0;
    
18.                         for (const auto &j : s) {
    
19.                                 int k = j - '0';
    
20.                                 val += OPT[k];
    
21.                         }
    
22.                         result.push_back(val);
    
23.                 }
    
24.                 return result;               
    
25.         }
    
26.        
    
27.         vector<int> p2(vector<pair<string, string>>& strprs) {
    
28.                 vector<int> result;
    
29.                 for (const auto &i : strprs) {
    
30.                         const string &s = i.first, &t = i.second;
    
31.                         if (s.size() == t.size()) {
    
32.                                 int a[256], b[256];
    
33.                                 memset(a, 0, sizeof(a));
    
34.                                 memset(b, 0, sizeof(b));
    
35.                                 for (size_t j = 0; j < s.size(); j++) {
    
36.                                         int k = s.at(j) - 0, l = t.at(j) - 0;
    
37.                                         a[k]++;
    
38.                                         b[l]++;
    
39.                                 }
    
40.                                 int k = 0;
    
41.                                 for (int j = 0; j < 256; j++) {
    
42.                                         k += a[j] > b[j] ? a[j] - b[j] : 0;                                       
    
43.                                 }
    
44.                                 result.push_back(k);
    
45.                         }
    
46.                         else {
    
47.                                 result.push_back(-1);                       
    
48.                         }
    
49.                 }
    
50.                 return result;
    
51.         }
    
52. 
    
53.         size_t p3(vector<pair<int, int>> steps) {
    
54.             size_t x = INT_MAX, y = INT_MAX;
    
55.             for (const auto &i : steps) {
    
56.                 x = min(x, size_t(i.first));
    
57.                 y = min(y, size_t(i.second));
    
58.             }
    
59.             return x * y;
    
60.         }
    
61. 
    
62.         vector<string> p4(vector<string>& strs) {
    
63.                 vector<string> result;
    
64.                 for (const auto &i : strs) {
    
65.                         int a = INT_MIN, b = INT_MIN, c = INT_MIN, d = INT_MIN;
    
66.                         for (size_t j = 0, n = i.size(); j < n; j++) {
    
67.                                 size_t k = j;
    
68.                                 if (a == INT_MIN) {
    
69.                                         while (j < n and i.at(j) != '/') {
    
70.                                                 j++;
    
71.                                         }
    
72.                                         a = stoi(i.substr(k, j - k));
    
73.                                         continue;
    
74.                                 }
    
75.                                 if (b == INT_MIN) {
    
76.                                         while (j < n and i.at(j) != '+') {
    
77.                                                 j++;
    
78.                                         }
    
79.                                         b = stoi(i.substr(k, j - k));
    
80.                                         continue;
    
81.                                 }
    
82.                                 if (c == INT_MIN) {
    
83.                                         while (j < n and i.at(j) != '/') {
    
84.                                                 j++;
    
85.                                         }
    
86.                                         c = stoi(i.substr(k, j - k));
    
87.                                         continue;
    
88.                                 }
    
89.                                 if (d == INT_MIN) {
    
90.                                         d = stoi(i.substr(k, n - k));
    
91.                                         continue;                                       
    
92.                                 }
    
93.                         }
    
94.                         int x = a * d + b * c, y = b * d, r = gcd(x, y);
    
95.                         result.push_back(to_string(x / r) + '/' + to_string(y / r));
    
96.                 }
    
97.                 return result;
    
98.         }
    
99. private:
    
100.         int gcd(int a, int b) {
     
101.                 return b == 0 ? a : gcd(b, a % b);
     
102.         }
     
103. };
     
104. 
     
105. int main(void) {
     
106.         Solution solution;
     
107.         vector<int> nums = {462, 1288, 0, 4, 6, 9, 8}, answer = {2, 4, 1, 1, 1, 1, 2}, result;
     
108.         result = solution.p1(nums);
     
109.         assert(answer == result);
     
110. 
     
111.         vector<pair<string, string>> strprs = {{"aabc", "abcd"}, {"ahahah", "aanannananna"}};
     
112.         answer = {1, -1};
     
113.         result = solution.p2(strprs);
     
114.         assert(answer == result);
     
115. 
     
116.         size_t answerL = 2, resultL = 0;
     
117.         vector<pair<int, int>> steps = {{2, 3}, {3, 7}, {4, 1}};
     
118.         resultL = solution.p3(steps);
     
119.         assert(answerL == resultL);
     
120. 
     
121.         vector<string> strs = {"1/2+1/3", "1/3+1/6", "3/2+1/2", "0/1+0/10"}, answerStrs = {"5/6", "1/2", "2/1", "0/1"}, resultStrs;
     
122.         resultStrs = solution.p4(strs);
     
123.         assert(answerStrs == resultStrs);
     
124. 
     
125.         cout << "\nPassed All\n";
     
126.         return 0;
     
127. }

复制代码

补充内容 (2017-5-8 20:09):
g++ -s

您好！
本帖隐藏的内容需要积分高于 188 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 188 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

ignature 不一致 另外我用的C++17 所以直接照抄代码会跪掉....

感谢楼主分享！想问一下第三题到底是啥意思？

史蒂文421 发表于 2017-5-12 07:08
感谢楼主分享！想问一下第三题到底是啥意思？

不需要准备 直接上

LeetCodeOJ 发表于 2017-5-12 07:13
不需要准备 直接上

哈哈哈好！谢谢楼主！你有结果了吗？

LeetCodeOJ 发表于 2017-5-12 07:13
不需要准备 直接上

顺便问一下，开摄像头吗？谢谢

史蒂文421 发表于 2017-5-12 08:11
顺便问一下，开摄像头吗？谢谢

不开 用两台电脑 随便搞

史蒂文421 发表于 2017-5-12 08:11
顺便问一下，开摄像头吗？谢谢

我电脑没有摄像头 哈哈哈哈哈

史蒂文421 发表于 2017-5-12 07:55
哈哈哈好！谢谢楼主！你有结果了吗？

目前没有 估计不好说

LeetCodeOJ 发表于 2017-5-12 08:12
不开 用两台电脑 随便搞

为什么要开两台电脑呢 不可以同一个电脑滑动页面看嘛

FF-Ti 发表于 2017-8-15 13:28
为什么要开两台电脑呢 不可以同一个电脑滑动页面看嘛

现在的oa都很厉害 可以看到你离开的了 界面。。。