feat(cses): a few problems

cses/increasing-array/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/increasing-array/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/increasing-array/compile_flags.txt

@@ -0,0 +1,5 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL

cses/increasing-array/solution.cc

@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  ll ans = 0;
+  int n;
+  cin >> n;
+  ll last = 0;
+  while (n--) {
+    ll x;
+    cin >> x;
+    if (last != 0 && last > x) {
+      ans += last - x;
+      x += last - x;
+    }
+    last = x;
+  }
+  cout << ans << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/increasing-array/solution.in

@@ -0,0 +1,2 @@
+10
+1000000000 1 1 1 1 1 1 1 1 1

cses/increasing-array/solution.out

@@ -0,0 +1,4 @@
+8999999991
+
+[code]: 0
+[time]: 4.4868 ms

cses/missing-number/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/missing-number/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/missing-number/compile_flags.txt

@@ -0,0 +1,6 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL
+-std=c++20

cses/missing-number/solution.cc

@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  vec<bool> seen(n + 1, false);
+  while (--n) {
+    int x;
+    cin >> x;
+    seen[x] = true;
+  }
+  for (int i = 1; i < sz<int>(seen); ++i) {
+    if (!seen[i]) {
+      cout << i << endl;
+      break;
+    }
+  }
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/missing-number/solution.in

@@ -0,0 +1,2 @@
+5
+2 3 1 5

cses/missing-number/solution.out

@@ -0,0 +1,4 @@
+4
+
+[code]: 0
+[time]: 3.88908 ms

cses/number-spiral/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/number-spiral/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/number-spiral/compile_flags.txt

@@ -0,0 +1,5 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL

cses/number-spiral/solution.cc

@@ -0,0 +1,62 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  ll x, y;
+  cin >> y >> x;
+  ll base = max(x, y);
+  ll ans = base * base;
+  if (ans & 1)
+    swap(x, y);
+  ans -= x - 1 + base - y;
+  cout << ans << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  int t;
+  cin >> t;
+  while (t--)
+    solve();
+
+  return 0;
+}
+// }}}

cses/number-spiral/solution.in

@@ -0,0 +1,5 @@
+4
+2 3
+1 1
+4 2
+2 4

cses/number-spiral/solution.out

@@ -0,0 +1,7 @@
+8
+1
+15
+11
+
+[code]: 0
+[time]: 4.26793 ms

cses/permutations/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/permutations/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/permutations/compile_flags.txt

@@ -0,0 +1,5 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL

cses/permutations/solution.cc

@@ -0,0 +1,76 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  /*
+     n= 5;
+     1 4 2 5 3
+     1 4 2 5 3 6
+     1 7 2 6 3 5 4
+
+
+     41325
+     */
+
+  if (n == 1) {
+    cout << 1 << endl;
+  } else if (n <= 3) {
+    cout << "NO SOLUTION\n";
+  } else {
+    for (int cur = n & 1 ? n - 1 : n; cur > 4; cur -= 2) {
+      cout << cur << ' ';
+    }
+    cout << "2 4";
+    for (int cur = 1; cur <= n; cur += 2) {
+      cout << ' ' << cur;
+    }
+  }
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/permutations/solution.in

@@ -0,0 +1 @@
+1

cses/permutations/solution.out

@@ -0,0 +1,4 @@
+1
+
+[code]: 0
+[time]: 4.06551 ms

cses/repetitions/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/repetitions/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/repetitions/compile_flags.txt

@@ -0,0 +1,5 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL

cses/repetitions/solution.cc

@@ -0,0 +1,60 @@
+#include <bits/stdc++.h> // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T> constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T> constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T> [[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T> [[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T> using vec = std::vector<T>;
+template <typename T, size_t N> using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  string s;
+  cin >> s;
+
+  ll streak = 0, ans = 0;
+  char last = ' ';
+  for (auto c : s) {
+    if (last == ' ' || last == c) {
+      ++streak;
+      ans = max(ans, streak);
+    } else {
+      streak = 1;
+    }
+    last = c;
+  }
+  cout << ans << endl;
+}
+
+int main() { // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/repetitions/solution.in

@@ -0,0 +1 @@
+ABCDEF

cses/repetitions/solution.out

@@ -0,0 +1,4 @@
+1
+
+[code]: 0
+[time]: 4.20523 ms

cses/two-knights/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/two-knights/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/two-knights/compile_flags.txt

@@ -0,0 +1,5 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL

cses/two-knights/solution.cc

@@ -0,0 +1,58 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  for (ll i = 1; i <= n; ++i) {
+    ll ans = (i * i) * (i * i - 1) / 2;
+    ans -= 2 * 2 * (i - 1) * (i - 2);
+    cout << ans << endl;
+  }
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/two-knights/solution.in

@@ -0,0 +1 @@
+8

cses/two-knights/solution.out

@@ -0,0 +1,11 @@
+0
+6
+28
+96
+252
+550
+1056
+1848
+
+[code]: 0
+[time]: 4.07505 ms

cses/two-sets/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/two-sets/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/two-sets/compile_flags.txt

@@ -0,0 +1,6 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL
+-std=c++20

cses/two-sets/solution.cc

@@ -0,0 +1,89 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+struct hash_pair {
+  size_t operator()(const pair<int, int> &p) const {
+    return hash<int>()(p.first) ^ (hash<int>()(p.second) << 1);
+  }
+};
+
+void solve() {
+  ll n;
+  cin >> n;
+
+  ll full = n * (n + 1) / 2;
+  if (full & 1) {
+    cout << "NO\n";
+    return;
+  }
+  ll half = full / 2;
+
+  vec<int> ans1, ans2;
+  ll total1 = 0;
+
+  for (int i = n; i >= 1; --i) {
+    if (total1 + i <= half) {
+      ans1.eb(i);
+      total1 += i;
+    } else {
+      ans2.eb(i);
+    }
+  }
+
+  cout << ans1.size() << endl;
+  for (auto e : ans1)
+    cout << e << ' ';
+  cout << endl;
+  cout << ans2.size() << endl;
+  for (auto e : ans2)
+    cout << e << ' ';
+  cout << endl;
+
+  cout << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/two-sets/solution.in

@@ -0,0 +1 @@
+7

cses/two-sets/solution.out

@@ -0,0 +1,8 @@
+3
+7 6 1 
+4
+5 4 3 2 
+
+
+[code]: 0
+[time]: 11.0717 ms

cses/weird-algorithm/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

cses/weird-algorithm/.clangd

@@ -0,0 +1,9 @@
+CompileFlags:
+	Add:
+		- -std=c++23
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

cses/weird-algorithm/compile_flags.txt

@@ -0,0 +1,6 @@
+-std=c++23
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL

cses/weird-algorithm/solution.cc

@@ -0,0 +1,64 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using vec = std::vector<T>;
+template <typename T, size_t N>
+using arr = std::array<T, N>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  ll n;
+  cin >> n;
+
+  while (n != 1) {
+    cout << n << ' ';
+    if (n & 1) {
+      n = n * 3 + 1;
+    } else {
+      n /= 2;
+    }
+  }
+  cout << 1 << endl;
+}
+
+// {{{
+int main() {
+  cin.tie(nullptr)->sync_with_stdio(false);
+
+  solve();
+
+  return 0;
+}
+// }}}

cses/weird-algorithm/solution.in

@@ -0,0 +1 @@
+3

cses/weird-algorithm/solution.out

@@ -0,0 +1,4 @@
+3 10 5 16 8 4 2 1
+
+[code]: 0
+[time]: 11.0214 ms