https://leetcode.com/problems/minimum-operations-to-reduce-x-to-zero/

int minOperations(int* nums, int n, int x) {
  int goal = -x;
  for (int i = 0; i < n; ++i) goal += nums[i];

  if (goal < 0) return -1;
  if (!goal) return n;

  int length = -1;
  for (int w = 0, l = 0, r = 0; r < n; ++r) {
    w += nums[r];
    while (w > goal)
      w -= nums[l++];
    if (w == goal)
      length = MAX(length, r - l + 1); 
  }
  return length == - 1 ? -1 : n - length;
}

#leetcode #c

https://leetcode.com/problems/binary-tree-inorder-traversal

#define N 100
static int bag[N];
static struct TreeNode* stack[N];
int* inorderTraversal(struct TreeNode* root, int* m) {
  *m = 0;

  int sp = 0;
  while (root || sp > 0) {
    while (root) {
      stack[sp++] = root;
      root = root->left;
    }

    root = stack[--sp];
    bag[(*m)++] = root->val;
    root = root->right;
  }

  return bag;
}

#leetcode #c

https://leetcode.com/problems/evaluate-the-bracket-pairs-of-a-string/

#define TABLE_SIZE 262144
#define INDEX_MASK (TABLE_SIZE - 1)

static unsigned int hash_fnv1a (const char *key) {
  unsigned int hash = 2166136261u;
  while (*key) {
    hash ^= (unsigned char)*key++;
    hash *= 16777619u;
  }
  return hash & INDEX_MASK;
}

static int ht[TABLE_SIZE];

static void ht_insert (const char *key, int value) {
  unsigned int index = hash_fnv1a(key);
  while (ht[index] != -1)
    index = (index + 1) & INDEX_MASK;
  ht[index] = value;
}

static int ht_search (const char *key, char *** knowledge) {
  unsigned int index = hash_fnv1a(key);
  while (ht[index] != -1) {
    if (!strcmp(key, knowledge[ht[index]][0]))
      return ht[index];
    index = (index + 1) & INDEX_MASK;
  }
  return -1;
}

static void append (char **s, int *n, int i, char c) {
  if (*n <= i)
    *s = realloc(*s, (*n *= 2));
  (*s)[i] = c;
}

char* evaluate (char* s, char*** knowledge, int knowledgeSize, int* knowledgeColSize) {
  memset(ht, -1, sizeof(int[TABLE_SIZE]));
  for (int i = 0; i < knowledgeSize; ++i) ht_insert(knowledge[i][0], i);

  int m = 50;
  char *a = malloc(m);

  int i = 0;
  int t = 0;
  while (s[i]) {
    if (s[i] == '(') {
      char key[11];
      ++i;
      int j = 0;
      for (; s[i] != ')'; ++i, ++j)
        key[j] = s[i];
      key[j] = 0;
      ++i;

      if ((j = ht_search(key, knowledge)) > -1)
        for (int i = 0; knowledge[j][1][i]; ++i)
          append(&a, &m, t++, knowledge[j][1][i]);
      else append(&a, &m, t++, '?');
    }
    else append(&a, &m, t++, s[i++]);
  }
  a[t] = 0;

  return a;
}

#leetcode #c

По соцсетям гуляет контроверсивный ролик с недавнего Rails World, в котором DHH со сцены странным голосом произносит фразу «Rust is [an] amazing [language] if you never, ever, ever, ever, have to look at it yourself». Я, если честно, не знаю, в чем конкретно все остальные видят контроверсивность, каюсь, не слежу (ну, кроме его фашистских взглядов, понятно), но с утверждением хотел бы поспорить.

Тезис, как я понимаю, в том, что раз код теперь пишет ЛЛМ, то нам пофиг более-менее на эстетические чувства тупой машины и на то, насколько она устанет. А раз пофиг, надо язык по характеристикам выдаваемого результата выбирать. Ну и понятно, что хоть на Руби писать и приятнее, но на Расте зато программы быстрее получаются, а значит надо брать Раст. (Вот это да, программист начал думать об удобстве пользователя, а не об удобстве программиста??? Последние времена настают).

Ну, короче. Программы на Расте, конечно, быстрые получаются. НО! В чем вообще было видение Раста? В том, чтобы понаставить везде заборов и ограждений и помешать программисту сконструировать некорректную программу. Не неправильную — этих можно конструировать сколько угодно — а именно некорректную. Делает он это ценой значительного такого мозгоебства, которое запрещает, конечно, по построению некорректные программы, но также и многие корректные, которые я тебе или ты мне могли бы объяснить, но никто из нас не смог бы объяснить компилятору. Короче говоря, Раст это не просто безопасный язык, это безопасный язык с довольно неудобными ограничениями, которые предлагается терпеть во имя высшей цели — корректности. Не правильности, опять напоминаю, а корректности.

Ну вот. Понятно, зачем это нужно человеку. Человек слаб. Он ошибается тут и там. Память течет направо и налево. Сегфолт за сегфолтом, эксплойт за эксплойтом. Но это человек. Понятно, ему нужен Руби^W Раст.

А что ЛЛМ? А ЛЛМ, на самом деле, пофиг. Она мало того, что пишет сразу правильно и допускает меньше ошибок, так она еще и не ленится: может и проверить, и поревьюить, и баги поискать. И в этом смысле совсем неочевидно, что вот эти вот страховочные сетки, расставленные в Расте тут и там, обязательно помогают. Если ты сразу видишь и пишешь корректную программу, они даже скорее мешают. Без борьбы с борроу чекером можно сгенерировать корректную быструю программу в несколько раз быстрее, потом еще проверить, и в конце суммарно меньше устать.

Так что я думаю, что Раст, конечно, эмейзинг, но лучший язык для ЛЛМ это все-таки Си.

https://leetcode.com/problems/heaters/

int cmp (const void *a, const void *b) {
  return *(const int *)a - *(const int *)b;
}

int findRadius(int* houses, int n, int* heaters, int m) {
  qsort(houses, n, sizeof(int), cmp);
  qsort(heaters, m, sizeof(int), cmp);

  int a = 0;
  for (int i = 0, j = 0; i < n; ++i) {
    while (j < m - 1 && abs(houses[i] - heaters[j + 1]) <= abs(houses[i] - heaters[j]))
      ++j;
    a = MAX(a, abs(houses[i] - heaters[j]));
  }
  return a;
}

#leetcode #c

https://leetcode.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/

static int a[10000];
int* maxDepthAfterSplit(char* seq, int* returnSize) {
  *returnSize = 0;
  for (int i = 0, d = 0; seq[i]; ++i)
    a[(*returnSize)++] = (d = ~d) + seq[i] & 1;
  return a;
}

#leetcode #c

Beautiful Type Erasure with C++26 Reflection -- Ryan Keane

Источник: isocpp.org (Standard C++)

What TLA+ can and can't check
Article, Comments

EDG C++ front-end goes public
Article, Comments