Upload all

Author: rich140

algo/bezout.cpp

@@ -0,0 +1,12 @@
+#include <iostream>
+
+int main() {
+    for (int i = -1000; i < 1000; i++) {
+        for (int j = -1000; j < 1000; j++) {
+            if (84*i + 62*j == 2) {
+                std::cout << "i is: " << i <<"j is: " << j << std::endl;
+            }
+        }
+    }
+    return 0;
+}

algo/dfs.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void dfs(vector< vector<int> >& adj, int s, int* visited) {
+    if (visited[s]) return;
+    visited[s] = true;
+    for (auto it = adj[s].begin(); it != adj[s].end(); ++it) {
+        dfs(adj, *it, visited);
+    }
+}
+int main() {
+    vector<int> adj[4];
+    adj[0].push_back(1);
+    adj[0].push_back(2);
+    adj[1].push_back(3);
+    adj[2].push_back(3);
+
+    dfs(adj, 0, new int[4]); 
+    return 0; 
+}

algo/permutations.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int main() {
+    vector<int> v = {1,2,3,4,5};
+    do {
+        for (auto i : v) {
+            cout << i << " ";
+        }
+        cout << endl;
+    } while (next_permutation(v.begin(), v.end()));
+    return 0;
+}

algo/powerset.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void search(int k, vector<int>& subset) {
+    if (k == 3) {
+        for (auto v: subset) {
+            cout << v << " ";
+        }
+        cout << endl;
+    } else {
+       search(k+1, subset);
+       subset.push_back(k);
+       search(k+1, subset);
+       subset.pop_back();
+    }
+}
+int main() {
+    vector<int> v;
+    search(0, v);
+    // Bit Sequence
+    cout << "Bit Sequence" << endl;
+    for (int b = 0; b < (1<<3); b++) {
+        cout << b << endl;
+    }
+    return 0;
+}

c++/2darr.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+
+using namespace std;
+
+void modify(int* arr) {
+    arr[2] = 69;
+    arr[3] = 42;
+    arr[4] = 1337;
+}
+
+void modify2d(int** arr) {
+    arr[1][1] = 69;
+    arr[1][2] = 42;
+    arr[2][1] = 1337;
+    arr[2][2] = 9001;
+}
+
+int main() {
+    int *a = new int[7];
+    modify(a);
+    for (int i = 0; i < 7; i++) {
+        cout << a[i] << " ";
+    }
+    cout << endl;
+    delete[] a;
+    
+    // 2d array
+    int **b = new int*[4];
+    for (int i = 0; i < 4; i++) {
+        b[i] = new int[4];
+    }
+    modify2d(b);
+    for (int i = 0; i < 4; i++) {
+        for (int j = 0; j < 4; j++) {
+            cout << b[i][j] << " ";
+        }
+        cout << endl;
+    }
+    cout << endl;
+    for (int i = 0; i < 4; i++) {
+        delete[] b[i];
+    }
+    delete[] b;
+    return 0;
+}

c++/2dvec.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void modify(vector< vector<int> >& vec) {
+    for (int i = 0; i < vec.size(); i++) {
+        for (int j = 0; j < vec[0].size(); j++) {
+            vec[i][j] = 5;
+        }
+    }
+}
+int main() {
+    int n_row = 3, n_col = 4;
+    vector< vector<int> > v;
+    v.resize(n_row, vector<int>(n_col));
+    modify(v);
+    for (int i = 0; i < n_row; i++) {
+        for (int j = 0; j < n_col; j++) {
+            cout << v[i][j] << " ";
+        }
+        cout << endl;
+    } 
+    return 0;
+}

c++/complex.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+
+using namespace std;
+
+class complex {
+    double re, im;
+    public:
+        complex(double r, double i) :re(r), im(i) {}
+        complex(double r) :re(r), im(0) {}
+        complex() :re(0), im(0) {}
+        double real() const { return re; }
+        void real(double d) { re=d; }
+        double imag() const { return im; }
+        void imag(double d) { im=d; }
+        complex& operator+=(complex z) {
+            re+=z.re, im+=z.im; return *this;
+        }
+        complex& operator-=(complex z) {
+            re-=z.re, im-=z.im; return *this;
+        }
+        complex& operator*=(complex z); 
+        complex& operator/=(complex z); 
+};
+
+complex operator+(complex a, complex b) { return a+=b; }
+complex operator-(complex a, complex b) { return a-=b; }
+complex operator-(complex a) { return (-a.real(), -a.imag()); }
+bool operator==(complex a, complex b) {
+    return a.real()==b.real() && a.imag()==b.imag();
+}
+bool operator!=(complex a, complex b) {
+    return !(a==b);
+}
+complex sqrt(complex);
+
+int main() {
+    cout << "Complex Number Tests!" << endl;
+    complex c(2, 3);
+    cout << "Original: " << c.real() << "," << c.imag() << endl;
+    complex c2(5, 6);
+    complex c3 = c += c2;
+    cout << "New" << c3.real() << "," << c3.imag() << endl;
+
+    return 0;
+}

c++/graph.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include <vector>
+#include <utility>
+#include <tuple>
+
+using namespace std;
+
+int main() {
+    vector<pair<int,int> > edges;
+    edges.push_back(make_pair(1,2));
+    edges.push_back(make_pair(2,5));
+    for (auto e : edges) {
+        cout << e.first << ", " << e.second << endl;
+    }
+
+    vector<tuple<int,int,int> > weighted_edges;
+    weighted_edges.push_back(make_tuple(1,2,3));
+    weighted_edges.push_back(make_tuple(2,3,7));
+    for (auto e : weighted_edges) {
+        cout << get<0>(e) << ", " << get<1>(e) << ", " << get<2>(e) << endl;
+    }
+    return 0;
+}

c++/map.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <map>
+#include <string>
+
+using namespace std;
+
+int main() {
+    map<string, int> m;
+    m["a"] = 1;
+    m["b"] = 2;
+    cout << "(a, " << m["a"] << ")" << endl;
+    cout << "(b, " << m["b"] << ")" << endl;
+    cout << "Size of map: " << m.size() << endl;
+    // Check if element exists in map
+    cout << "a exists: " << m.count("a") << endl;
+    cout << "c doesn't exist: " << m.count("c") << endl;
+    // Remove element in map
+    m.erase("a");
+    // Print everything in map
+    for (auto x : m) {
+        cout << "(" << x.first << "," << x.second << ")" << endl;
+    }
+    return 0;
+}

c++/matrix.cpp

@@ -0,0 +1,12 @@
+template <typename T>
+class Matrix {
+    public:
+        void resize(int rows, int cols);
+        T& at(int row, int col);
+        int rows() { return row; }
+        int cols() { return col; }
+    private:
+        int row;
+        int col;
+        T **data;
+};

c++/ref.cpp

@@ -0,0 +1,22 @@
+#include <string>
+#include <iostream>
+
+using namespace std;
+
+class Person {
+    public:
+        Person(string name):name(name){};
+        string name;
+};
+
+void change_name(Person& p, string name) {
+    p.name = name;
+}
+
+int main() {
+    Person a = Person("Alice");
+    cout << a.name << endl;
+    change_name(a, "Bob");
+    cout << a.name << endl;
+    return 0;
+}

c++/set.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <set>
+#include <string>
+#include <unordered_set>
+
+using namespace std;
+
+int main() {
+    unordered_set<string> s;
+    s.insert("a");
+    s.insert("b");
+    s.insert("c");
+    // Size of set
+    cout << "Size: " << s.size() << endl;
+    // Check whether element exists
+    cout << "Does a exist: " << s.count("a") << endl;
+    cout << "Does d exist: " << s.count("d") << endl;
+    // Remove a
+    s.erase("a");
+    cout << "New size: " << s.size() << endl;
+    return 0;
+}

c++/template.cpp

@@ -0,0 +1,11 @@
+template<class T, const int N>
+
+class Things {
+    T myArray[N];
+    T getElement(int);
+    void setElement(int, T);
+};
+
+int main() {
+    return 0;
+}

c++/vector.cpp

@@ -0,0 +1,27 @@
+#include <initializer_list>
+
+using namespace std;
+
+class Vector {
+    private:
+        double* elem;
+        int sz;
+    public:
+        Vector(int s) : elem(new double[s]), sz(s) {
+            for (int i = 0; i < s; i++) {
+                elem[i] = 0;
+            } 
+        }
+        Vector(std::initializer_list<double> lst)
+            : elem(new double[lst.size()]), sz(static_cast<int>(lst.size())) {
+                copy(lst.begin(), lst.end(), elem);
+            }
+        ~Vector() { delete[] elem; } // destructor
+        double& operator[](int i);
+        int size() const;
+        void push_back(double);
+};
+
+int main() {
+    return 0;
+}

pb/cf/1579a.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+
+#include <string>
+#include <algorithm>
+
+using namespace std;
+
+void run(string s) {
+	size_t a = count(s.begin(), s.end(), 'A');
+	size_t b = count(s.begin(), s.end(), 'B');
+	size_t c = count(s.begin(), s.end(), 'C');
+	if (a + c == b) {
+		cout << "YES\n";
+	} else {
+		cout << "NO\n";
+	}
+}
+
+int main() {
+	int n;
+	cin >> n;
+	while (n > 0) {
+		string s;
+		cin >> s;
+		run(s);
+		n--;
+	}
+	return 0;
+}