Merge remote-tracking branch 'origin/master'

zeta_cpp/completed/14215.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <algorithm>
+#include <numeric>
+
+using namespace std;
+
+int main() {
+    int sides[3];
+
+    for (int i = 0; i < 3; i++) {
+        cin >> sides[i];
+    }
+
+    sort(sides, sides + 3);
+
+    if (sides[2] >= sides[1] + sides[0]) {
+        sides[2] = sides[1] + sides[0] - 1;
+    }
+
+    cout << accumulate(sides, sides + 3, 0) << endl;
+    return 0;
+}

zeta_cpp/completed/15894.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+
+using namespace std;
+
+long long solve(long long n) {
+    return 4 * n;
+}
+
+int main() {
+    long long n;
+    cin >> n;
+    cout << solve(n);
+    return 0;
+}

zeta_cpp/completed/27323.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+    int A, B;
+    cin >> A >> B;
+    cout << A * B;
+    return 0;
+}

zeta_cpp/completed/5073.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+
+int main() {
+    int sides[3];
+    while (true) {
+        for (int i = 0; i < 3; i++) {
+            cin >> sides[i];
+        }
+
+        if (sides[0] == 0) {
+            break;
+        }
+        sort(sides, sides + 3);
+
+        if (sides[0] + sides[1] <= sides[2]) {
+            cout << "Invalid\n";
+            continue;
+        }
+
+        if (sides[0] == sides[1] and sides[1] == sides[2] and sides[2] == sides[0]) {
+            cout << "Equilateral\n";
+            continue;
+        }
+        if (sides[0] == sides[1] or sides[0] == sides[2] or sides[1] == sides[2]) {
+            cout << "Isosceles\n";
+            continue;
+        }
+
+        cout << "Scalene\n";
+    }
+}

zeta_cpp/completed/9063.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int main() {
+    int N;
+    cin >> N;
+    int xs[N], ys[N];
+    int x, y;
+    for (int i = 0; i < N; i++) {
+        cin >> x >> y;
+        xs[i] = x;
+        ys[i] = y;
+    }
+    sort(xs, xs + N);
+    sort(ys, ys + N);
+
+    cout << (xs[N - 1] - xs[0]) * (ys[N - 1] - ys[0]) << endl;
+}