misc

Author: MaskRay

check-if-numbers-are-ascending-in-a-sentence.cc

@@ -0,0 +1,20 @@
+// Check if Numbers Are Ascending in a Sentence
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  bool areNumbersAscending(string s) {
+    int last = -1;
+    REP(i, s.size())
+      if (s[i] != ' ') {
+        int j = i, x = atoi(&s[i]);
+        while (++i < s.size() && s[i] != ' ');
+        if (isdigit(s[j])) {
+          if (last >= 0 && last >= x)
+            return false;
+          last = x;
+        }
+      }
+    return true;
+  }
+};

count-special-quadruplets.cc

@@ -0,0 +1,19 @@
+// Count Special Quadruplets
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int countQuadruplets(vector<int>& a) {
+    int n = a.size(), ans = 0;
+    REP(i, n)
+      FOR(j, i+1, n)
+        FOR(k, j+1, n) {
+          int x = a[i]+a[j]+a[k];
+          FOR(l, k+1, n)
+            if (x == a[l])
+              ans++;
+        }
+    return ans;
+  }
+};

final-value-of-variable-after-performing-operations.cc

@@ -0,0 +1,11 @@
+// Final Value of Variable After Performing Operations
+class Solution {
+public:
+  int finalValueAfterOperations(vector<string>& operations) {
+    int s = 0;
+    for (auto op: operations)
+      if (op[1] == '+') s++;
+      else s--;
+    return s;
+  }
+};

find-missing-observations.cc

@@ -0,0 +1,17 @@
+// Find Missing Observations
+#define ALL(x) (x).begin(), (x).end()
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  vector<int> missingRolls(vector<int>& rolls, int mean, int n) {
+    int s = mean*(rolls.size()+n)-accumulate(ALL(rolls), 0);
+    if (s < n || s > 6*n) return {};
+    vector<int> a(n);
+    REP(i, n) {
+      a[i] = s/(n-i);
+      s -= a[i];
+    }
+    return a;
+  }
+};

grid-game.cc

@@ -1,7 +1,6 @@
 // Grid Game
-#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
-#define REP(i, n) FOR(i, 0, n)
-#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
+#define REP(i, n) for (long i = 0; i < (n); i++)
+#define ROF(i, a, b) for (long i = (b); --i >= (a); )
 
 class Solution {
 public:
@@ -11,7 +10,7 @@ class Solution {
     REP(i, n)
       l[i] = grid[1][i] + (i ? l[i-1] : 0);
     ROF(i, 0, n)
-      r[i] = grid[0][i] + (i+1<n ? r[i+1] : 0);
+      r[i] = grid[0][i] + r[i+1];
     REP(i, n)
       ans = min(ans, max(r[i+1], i ? l[i-1] : 0));
     return ans;

maximum-value-at-a-given-index-in-a-bounded-array.nim

@@ -0,0 +1,16 @@
+# Maximum Value at a Given Index in a Bounded Array
+proc maxValue(n: int, index: int, maxSum: int): int {.exportc.} =
+  var
+    l = 0
+    h = maxSum - n
+  while l < h:
+    let a = (l+h+1) shr 1
+    var b = max(a-index, 0)
+    var sum = (a+b)*(a-b+1)
+    b = max(a-(n-1)+index, 0)
+    sum += (a+b)*(a-b+1)
+    if sum div 2 - a <= maxSum - n:
+      l = a
+    else:
+      h = a-1
+  l+1

minimum-moves-to-convert-string.cc

@@ -0,0 +1,18 @@
+// Minimum Moves to Convert String
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int minimumMoves(string s) {
+    int n = s.size(), ans = 0;
+    REP(i, n)
+      if (s[i] == 'X') {
+        int j = min((int)i+2, n-1);
+        s[j] = 'O';
+        if (j) s[j-1] = 'O';
+        if (j > 1) s[j-2] = 'O';
+        ans++;
+      }
+    return ans;
+  }
+};

next-greater-numerically-balanced-number.cc

@@ -0,0 +1,34 @@
+// Next Greater Numerically Balanced Number
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int nextBeautifulNumber(int n) {
+    int a[9] = {}, c[10] = {}, m = 0;
+    for (int i = n; i; i /= 10)
+      c[a[m++] = i%10]++;
+    for(;;) {
+      n++;
+      int i = 0;
+      for (; ; i++) {
+        if (i < m)
+          c[a[i]]--;
+        else
+          m++;
+        if (a[i] < 9) {
+          c[++a[i]]++;
+          i++;
+          break;
+        }
+        c[a[i] = 0]++;
+      }
+
+      int j = 0;
+      for (; j < 10; j++)
+        if (c[j] && c[j]!=j)
+          break;
+      if (j == 10)
+        return n;
+    }
+  }
+};

number-of-pairs-of-interchangeable-rectangles.cc

@@ -0,0 +1,21 @@
+// Number of Pairs of Interchangeable Rectangles
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  long long interchangeableRectangles(vector<vector<int>>& rs) {
+    auto a = rs;
+    for (auto &x: a) {
+      long d = __gcd(x[0], x[1]);
+      x[0] /= d;
+      x[1] /= d;
+    }
+    sort(ALL(a));
+    long ans = 0;
+    for (long j = 0, i = 0; i != a.size(); i = j) {
+      for (; j < a.size() && a[i] == a[j]; j++);
+      ans += (j-i)*(j-i-1)/2;
+    }
+    return ans;
+  }
+};

number-of-valid-words-in-a-sentence.cc

@@ -0,0 +1,26 @@
+// Number of Valid Words in a Sentence
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int countValidWords(string a) {
+    int n = a.size(), ans = 0;
+    REP(i, n)
+      if (a[i] != ' ') {
+        int j = i, hyp = 0, dot = 0, digit = 0;
+        for (; j < n && a[j] != ' '; j++) {
+          if (a[j] == '-') {
+            hyp++;
+            if (!j || !isalpha(a[j-1]) || !isalpha(a[j+1]))
+              hyp++;
+          }
+          dot += a[j]=='.'||a[j]==','||a[j]=='!';
+          digit += isdigit(a[j]);
+        }
+        if (hyp <= 1 && !digit && (!dot || dot==1 && (a[j-1]=='.'||a[j-1]==','||a[j-1]=='!')))
+          ans++;
+        i = j;
+      }
+    return ans;
+  }
+};

simple-bank-system.cc

@@ -0,0 +1,26 @@
+// Simple Bank System
+class Bank {
+  vector<long long> a;
+public:
+  Bank(vector<long long>& balance) : a(move(balance)) {}
+  bool f(int x) const { return 1 <= x && x <= a.size(); }
+
+  bool transfer(int x, int y, long long mo) {
+    if (!f(x) || !f(y) || a[x-1] < mo) return false;
+    a[x-1] -= mo;
+    a[y-1] += mo;
+    return true;
+  }
+
+  bool deposit(int x, long long mo) {
+    if (!f(x)) return false;
+    a[x-1] += mo;
+    return true;
+  }
+
+  bool withdraw(int x, long long mo) {
+    if (!f(x) || a[x-1] < mo) return false;
+    a[x-1] -= mo;
+    return true;
+  }
+};

smallest-index-with-equal-value.nim

@@ -0,0 +1,5 @@
+proc smallestEqual(nums: ptr UncheckedArray[cint], n: int): cint {.exportc.} =
+  for i in 0..<n:
+    if i mod 10 == nums[i]:
+      return cast[cint](i)
+  -1

sum-of-beauty-in-the-array.cc

@@ -0,0 +1,23 @@
+// Sum of Beauty in the Array
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
+#define ROF(i, a, b) for (long i = (b); --i >= (a); )
+
+class Solution {
+public:
+  int sumOfBeauties(vector<int>& a) {
+    int n = a.size(), s = 0, b = a[0];
+    vector<int> c(n);
+    c[n-1] = a[n-1];
+    ROF(i, 0, n-1)
+      c[i] = min(c[i+1], a[i]);
+    FOR(i, 1, n-1) {
+      if (a[i-1] < a[i] && a[i] < a[i+1]) {
+        if (b < a[i] && a[i] < c[i+1])
+          s++;
+        s++;
+      }
+      b = max(b, a[i]);
+    }
+    return s;
+  }
+};

two-out-of-three.cc

@@ -0,0 +1,15 @@
+// Two Out of Three
+class Solution {
+public:
+  vector<int> twoOutOfThree(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3) {
+    int a[101] = {};
+    for (int x: nums1) a[x] |= 1;
+    for (int x: nums2) a[x] |= 2;
+    for (int x: nums3) a[x] |= 4;
+    vector<int> ans;
+    for (int i = 0; i < sizeof(a)/sizeof(*a); i++)
+      if (__builtin_popcount(a[i]) > 1)
+        ans.push_back(i);
+    return ans;
+  }
+};