#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void parse_text(const char* text);
void handle_word(const char* word, int word_len);
int try_convert_to_int(const char* word, int word_len);
int compare_short_words(const void* word_1, const void* word_2);

int main() {
  parse_text("when they read tiny data item like ' zone - 5m = -12 + 1000 ', it is done real fast");
  return 0;
}

const int _max_text_len = 200;
const int _short_word_len = 4;
const int _max_short_words_count = _max_text_len / (_short_word_len + 1);

struct short_word_t {
  const char* elems; // не завершается нулевым элементом '\0'
};

short_word_t _short_words[_max_short_words_count];
int _short_words_count;
bool _handled_number;

void parse_text(const char* text) {
  assert(strlen(text) <= _max_text_len);

  _short_words_count = 0;
  _handled_number = false;

  int pos = 0;
  for (;;) {
    // пропускаем пробелы и запятые
    while ((text[pos] == ' ') || (text[pos] == ',')) {
      pos++;
    }

    if (text[pos] == '\0') { // если дошли до конца текста
      break;
    }

    // сканируем слово
    int word_start = pos;
    do {
      pos++;
    } while ((text[pos] != ' ') && (text[pos] != ',') && (text[pos] != '\0'));
    handle_word(text + word_start, pos - word_start);
  }

  // сортируем короткие слова
  qsort(_short_words, _short_words_count, sizeof(short_word_t), &compare_short_words);
  printf("Sorted short words:\n");
  for (int i = 0; i < _short_words_count; i++) {
    printf("%.*s\n", _short_word_len, _short_words[i].elems);
  }
}

void handle_word(const char* word, int word_len) {
  //printf("%.*s\n", word_len, word); // для отладки

  if (word_len == _short_word_len) {
    // добавляем короткое слово в массив
    assert(_short_words_count < _max_short_words_count);
    _short_words[_short_words_count].elems = word;
    _short_words_count++;
  }

  if (!_handled_number) {
    int n = try_convert_to_int(word, word_len);
    if (n != INT_MIN) {
      printf("square(%i) = %i\n", n, n * n);
      _handled_number = true;
    }
  }
}

// если слово не является целым числом, то возвращает INT_MIN
// не обрабатывает переполнение (overflow)
int try_convert_to_int(const char* word, int word_len) {
  assert(word_len >= 1);
  int pos = 0;

  // сканируем знак
  bool minus = false;
  if (word[pos] == '+') {
    pos++;
  } else if (word[pos] == '-') {
    minus = true;
    pos++;
  }

  if (pos == word_len) {
    return INT_MIN;
  }

  // сканируем цифры
  int num = 0;
  do {
    char e = word[pos];
    if (('0' <= e) && (e <= '9')) {
      num = 10 * num + (e - '0');
    } else {
      return INT_MIN;
    }
    pos++;
  } while (pos < word_len);

  if (minus) {
    num = -num;
  }

  return num;
}

// если слово_1 < слово_2, то возвращает число < 0
// если слово_1 = слово_2, то возвращает 0
// если слово_1 > слово_2, то возвращает число > 0
int compare_short_words(const void* word_1, const void* word_2) {
  const short_word_t* w1 = static_cast<const short_word_t*>(word_1);
  const short_word_t* w2 = static_cast<const short_word_t*>(word_2);
  return memcmp(w1->elems, w2->elems, _short_word_len);
}

square(-12) = 144
Sorted short words:
1000
data
done
fast
item
like
read
real
they
tiny
when
zone