├── .vscode
    └── settings.json
├── README.md
├── day00
    ├── GravitFlip.cpp
    ├── IncreaseByTwo.cpp
    ├── ParenthesesBalance.cpp
    ├── binarytree.cpp
    ├── easyStack.cpp
    ├── maxWord.cpp
    ├── priorityQueue.cpp
    └── twoSum.cpp
└── day01
    ├── A.cpp
    ├── B.cpp
    ├── C.cpp
    ├── D.cpp
    ├── E.cpp
    ├── F.cpp
    ├── a
    └── test.cpp


/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |     "files.associations": {
3 |         "iostream": "cpp"
4 |     }
5 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # cppBotcampProblems
2 | problems solving 
3 | 


--------------------------------------------------------------------------------
/day00/GravitFlip.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <set>
 3 | 
 4 | using namespace std;
 5 | int main()
 6 | {
 7 |     int len, tmp;
 8 |     cin >> len;
 9 | 
10 |     multiset<int> v;
11 |     for (int i = 0; i < len; i++)
12 |     {
13 |         cin >> tmp;
14 |         v.insert(tmp);
15 |     }
16 |     for (multiset<int>::iterator i = v.begin(); i != v.end(); i++)
17 |         cout << *i << ' ';
18 |     cout << endl;
19 | }
20 | 


--------------------------------------------------------------------------------
/day00/IncreaseByTwo.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | int main()
 6 | {
 7 |     short i;
 8 |     cin >> i;
 9 |     std::vector<short> v(i);
10 | 
11 |     for (int j = 0; j < i; j++)
12 |     {
13 |         cin >> v[j];
14 |         if (v[j] >= 0)
15 |             v[j] += 2;
16 |     }
17 |     for (int j = 0; j < i; j++)
18 |         std::cout << v[j] << " ";
19 |     std::cout << endl;
20 | 
21 | }


--------------------------------------------------------------------------------
/day00/ParenthesesBalance.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <vector>
 4 | #include <stack>
 5 | #include <fstream>
 6 | using namespace std;
 7 | int main()
 8 | {
 9 |     int len;
10 |     string l;
11 |     std::getline(cin, l);
12 |     len = stoi(l);
13 |     vector<string> v(len);
14 |     for (int i = 0; i < len; i++)
15 |         getline(cin, v[i]);
16 |     for (int i = 0; i < len ; i++)
17 |     {
18 |         stack<char> s;
19 |         size_t l = v[i].length();
20 |         int j = 0;
21 |         for (j = 0; j < l; j++)
22 |         {
23 |             if (v[i][j] == '[' || v[i][j] == '(')
24 |                 s.push(v[i][j]);
25 |             else
26 |             {
27 |                 if (s.empty())
28 |                 {
29 |                     cout << "No" << endl;
30 |                     break;
31 |                 }
32 |                 if ((v[i][j] == ']' && s.top() == '[') || (v[i][j] == ')' && s.top() == '('))
33 |                     s.pop();
34 |                 else
35 |                 {
36 |                     cout << "No" << endl;
37 |                     break;
38 |                 }
39 |             }
40 |         }
41 |         if (s.empty() && j == l)
42 |             cout << "Yes" << endl;
43 |         else if (!s.empty())
44 |             cout << "No" << endl;
45 |     }
46 | }


--------------------------------------------------------------------------------
/day00/binarytree.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <set>
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |     ios::sync_with_stdio(false);
 8 |     string cmd;
 9 |     int x;
10 |     set<int> s;
11 | 
12 |     while (cin >> cmd)
13 |     {
14 |         cin >> x;
15 |         if (cmd == "insert")
16 |             s.insert(x);
17 |         else if (cmd == "delete")
18 |             s.erase(x);
19 |         else
20 |         {
21 |             if (s.find(x) != s.end())
22 |                 cout << "true" << "\n";
23 |             else 
24 |                 cout << "false" << "\n";
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/day00/easyStack.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <stack>
 3 | #include <vector>
 4 | #include <string>
 5 | using namespace std;
 6 | int main ()
 7 | {
 8 |     ios_base::sync_with_stdio(false);
 9 |     cin.tie(NULL);
10 |     cout.tie(NULL);
11 |     int len, tmp, n;
12 |     stack<int> s;
13 |     cin >> len;
14 | 
15 |     for (int i = 0; i < len; i++)
16 |     {
17 |         cin >> tmp;
18 |         if (tmp == 1)
19 |         {
20 |             cin >> n;
21 |             s.push(n);
22 |         }
23 |         if (tmp == 2 && !s.empty())
24 |             s.pop();
25 |         if (tmp == 3)
26 |         {
27 |             if (!s.empty())
28 |                 cout << s.top() << "\n";
29 |             else 
30 |                 cout << "Empty!" << "\n";
31 |         }
32 |     }
33 | }   


--------------------------------------------------------------------------------
/day00/maxWord.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <map>
 3 | #include <string>
 4 | 
 5 | using namespace std;
 6 | int main()
 7 | {
 8 |     int len;
 9 |     string str;
10 |     string w;
11 |     map<string , int> m;
12 |     cin >> len;
13 | 
14 |     for (int i = 0; i < len; i++)
15 |     {
16 |         cin >> str;
17 |         if (m.find(str) == m.end())
18 |             m[str] = 1;
19 |         else
20 |             m[str]++;
21 |     }
22 |     int max = 0;
23 |     for (auto& p : m) {
24 |         max = std::max(max, p.second);
25 |     }
26 |     for (auto& p : m) {
27 |         if (p.second >= max)
28 |             w = p.first;
29 |     }
30 |     cout << w << " " << max << endl;
31 | }


--------------------------------------------------------------------------------
/day00/priorityQueue.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <queue>
 3 | #include <vector>
 4 | 
 5 | using namespace std;
 6 | int main()
 7 | {
 8 |     ios_base::sync_with_stdio(false);
 9 |     cin.tie(NULL);
10 |     cout.tie(NULL);
11 |     int n, np, op, qt, value;
12 |     cin >> n;
13 |     cin >> np;
14 | 
15 |     vector<priority_queue<int> > v(n);
16 | 
17 |     for (int i = 0; i < np; i++)
18 |     {
19 |         cin >> op;
20 |         if (op == 0)
21 |         {
22 |             cin >> qt;
23 |             cin >> value;
24 |             v[qt].push(value);
25 |         }
26 |         else if (op == 1)
27 |         {
28 |             cin >> qt;
29 |             if (!v[qt].empty())
30 |                 cout << v[qt].top() << '\n';
31 |         }
32 |         else if (op == 2)
33 |         {
34 |             cin >> qt;
35 |             if (!v[qt].empty())
36 |                 v[qt].pop();
37 |         }
38 |     }
39 | }


--------------------------------------------------------------------------------
/day00/twoSum.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <map>
 3 | #include <vector>
 4 | using namespace std;
 5 | int main()
 6 | {
 7 |     int i , t, n;
 8 |     cin >> i;
 9 |     cin >> t;
10 |     std::vector<int> v(i);
11 |     std::map<int, int> d;
12 |     for (int j = 0; j < i; j++)
13 |         cin >> v[j];
14 |     for (int j = 0; j < i; j++)
15 |     {
16 |         n = t - v[j];
17 |         if (d.find(n) != d.end())
18 |             return (std::cout << d[n] + 1 << " " << j + 1, 0);
19 |         else 
20 |             d[v[j]] = j;
21 |     }
22 |     std::cout << "IMPOSSIBLE";
23 | }


--------------------------------------------------------------------------------
/day01/A.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | 
 6 | vector<int> v(100001 * 2);
 7 | vector<long long> pre(100001 * 2); 
 8 | int main()
 9 | {
10 |     ios_base::sync_with_stdio(false);
11 |     cin.tie(NULL);
12 |     int n,q;
13 |     cin>>n>>q;
14 |     for (int i=1; i <=n ; i++)
15 |     {
16 |         cin >> v[i];
17 |         pre[i]=v[i];
18 |     }
19 |     for (int i=1; i <= n; i++)
20 |         pre[i] = pre[i] ^ pre[i - 1];
21 |     while(q--)
22 |     {
23 |         int l,r;
24 |         cin >> l >> r;
25 |         long long sum;
26 |         sum = pre[r] ^ pre[l - 1];
27 |         cout << sum << '\n';
28 |     }
29 | }


--------------------------------------------------------------------------------
/day01/B.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <map>
 4 | 
 5 | using namespace std;
 6 | int main()
 7 | {
 8 |     ios_base::sync_with_stdio(false);
 9 |     in.tie(NULL);
10 |     int n, x;
11 |     cin >> n >> x;
12 |     vector<int> v(n);
13 |     vector<long long > pre(n+1);
14 |     for (int i = 0; i < n; i++)
15 |         cin >> v[i];
16 |     map<long long, long long> s;
17 | 
18 |     s[0] = 1;
19 |     long long ans = 0;
20 |     for (int i = 1; i <= n; i++)
21 |     {
22 |         pre[i] = pre[i - 1] + v[i - 1];
23 |         ans = ans + s[pre[i] - x];
24 |         s[pre[i]]++;
25 |     }
26 |     cout << ans << '\n';
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/day01/C.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | vector<int> v(100000 * 2);
 6 | vector<long long> pre(100000 * 2); 
 7 | int main()
 8 | {
 9 |     ios_base::sync_with_stdio(false);
10 |     cin.tie(NULL);
11 |     int n,q;
12 |     cin>>n>>q;
13 | 
14 | }


--------------------------------------------------------------------------------
/day01/D.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | vector<int> v(44);
 6 | int main ()
 7 | {
 8 |     ios_base::sync_with_stdio(false);
 9 |     cin.tie(NULL);
10 |     cout.tie(NULL);
11 |     v[0] = 1;
12 |     v[1] = 1;
13 |     for (int i = 2; i <= 44; i++)
14 |         v[i] = v[i -1] + v[i -2];
15 |     int n;
16 |     cin >> n;
17 |     if (n >= 0 && n <= 44 )
18 |         cout << v[n] << '\n';
19 | }


--------------------------------------------------------------------------------
/day01/E.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | const int MOD = 1000000007;  // 10^9 + 7
 5 | 
 6 | int main() {
 7 |     int n;
 8 |     std::cin >> n;
 9 | 
10 |     std::vector<std::vector<char>> grid(n, std::vector<char>(n));
11 |     for (int i = 0; i < n; ++i) {
12 |         for (int j = 0; j < n; ++j) {
13 |             std::cin >> grid[i][j];
14 |         }
15 |     }
16 | 
17 |     std::vector<std::vector<int>> dp(n, std::vector<int>(n, 0));
18 |     dp[0][0] = (grid[0][0] == '.') ? 1 : 0;
19 | 
20 |     for (int i = 0; i < n; ++i) {
21 |         for (int j = 0; j < n; ++j) {
22 |             if (grid[i][j] == '.') {
23 |                 if (i > 0) {
24 |                     dp[i][j] = (dp[i][j] + dp[i - 1][j]) % MOD;
25 |                 }
26 |                 if (j > 0) {
27 |                     dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD;
28 |                 }
29 |             }
30 |         }
31 |     }
32 | 
33 |     std::cout << dp[n - 1][n - 1] << std::endl;
34 | 
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/day01/F.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <limits.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int solve(vector<int> v, int x, int n, vector<int> dp) 
 8 | {
 9 |     for (int j = 1; j <= x; j++)
10 |     {
11 |         int ans = INT_MAX;
12 |         for (int i = 0; i < n ; i++)
13 |         {
14 |             if (j - v[i] < 0)
15 |                 continue;
16 |             int val = dp[j - v[i]];
17 |             if (val != -1) ans = min(ans , val + 1);
18 |         }
19 |         if (ans == INT_MAX) dp[j] = -1;
20 |         else dp[j] = ans;
21 |     }
22 |     return dp[x];
23 | }
24 | 
25 | int main()
26 | {
27 |     ios_base::sync_with_stdio(false);
28 |     cin.tie(NULL);
29 |     int n, x;
30 |     cin >> n >> x;
31 |     vector<int> v(n);
32 |     vector<int> dp(x + 1, -2);
33 |     dp[0] = 0;
34 |     for (int i = 0; i < n; i++) 
35 |         cin >> v[i];
36 |     cout << solve(v, x, n, dp) << '\n';
37 | }


--------------------------------------------------------------------------------
/day01/a:
--------------------------------------------------------------------------------
1 | 3
2 | 


--------------------------------------------------------------------------------
/day01/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <limits.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int solve(vector<int> v, int x, int n, vector<int> dp) 
 8 | {
 9 |     for (int j = 1; j <= x; j++)
10 |     {
11 |         int ans = INT_MAX;
12 |         for (int i = 0; i < n ; i++)
13 |         {
14 |             if (j - v[i] < 0)
15 |                 continue;
16 |             int val = dp[j - v[i]];
17 |             if (val != -1) ans = min(ans , val + 1);
18 |         }
19 |         if (ans == INT_MAX) dp[j] = -1;
20 |         else dp[j] = ans;
21 |     }
22 |     return dp[x];
23 | }
24 | 
25 | int main()
26 | {
27 |     ios_base::sync_with_stdio(false);
28 |     cin.tie(NULL);
29 |     int n, x;
30 |     cin >> n >> x;
31 |     vector<int> v(n);
32 |     vector<int> dp(x + 1, -2);
33 |     dp[0] = 0;
34 |     for (int i = 0; i < n; i++) 
35 |         cin >> v[i];
36 |     cout << solve(v, x, n, dp) << '\n';
37 | }


--------------------------------------------------------------------------------