O(n) in -place algorithm for compressing "same letters pattern" - arrays

Question

thats my first post here so I hope im following the rules.
I had a job interview few days ago and I got a problem which I coulnd solve (until now).
The idea is (was on C but I guess its not an isuue): given a char* of n length, you should use O(1) memory comp (in-place changes), and compress the patterns of the same char to "num+char" where num is the pattern length and char is the character of the pattern. you can assume the memory is long enough to contain the expected result. Expected time comp is O(n).
Example- [abbbccccdee] ---> [1a3b4c1d2e]
my main issue here was with the case of 1 long patterns, because "pushing forward" all letters to get the 1 before it, raising the complexity. Otherwise my idea was to work with a pointer that indicates the locations of the next compress pattern, and it works only as long as the pointer is behind the regular scanning of the array.
Thanks!

Answer 1

compressing “same letters pattern”
my main issue here was with the case of 1 long patterns, because "pushing forward" all letters to get the 1 before it, raising the complexity
Note the length needed in the first pass to keep O(n) and expand from the end.
2 passes.
Compress:
Walk the string from beginning counting character repetition:
-- If digit encountered, error out.
-- Replace any repeat of 2 or more characters with the decimal length as text followed by the character.
-- Count single character cases.
Note the length of the compressed data.
Expand:
Let source = &s[length] - 1
Let destination = &s[length + single] - 1
Walk the array from the end reading from source and then writing to destination:
-- With special detection of the the array start:
---- Detect a character lacking a preceding digit, then write to the destination as '1' + character.
---- Otherwise copy "digits + character" to destination. Copy these characters in reverse order so with "12z", copy 'z', '2', then '1'.
Insure algorithm handles "" case.
Similar to #dratenik

Answer 2

Let's put #chux amazing answer into real code! The following code:
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
char *compress_num_to_str(char *out, size_t v) {
// the standard output&reverse
char *tmp = out;
while (v) {
*tmp++ = v % 10 + '0';
v /= 10;
}
char *ret = tmp;
while (tmp > out) {
--tmp;
char a = *tmp;
*tmp = *out;
*out = a;
out++;
}
return ret;
}
char *compress(char *string) {
if (*string == '\0') {
return string;
}
// compress
char *in = string;
char *out = string;
size_t single = 0;
for (char c; (c = *in++) != '\0'; ) {
// the letter is going to be written anyway
char *const pos = in;
// iterate over repeated letters
while (c == *in) {
++in;
}
// if there are any repeated letters
if (pos != in) {
// output the count
const size_t count = in - pos + 1;
out = compress_num_to_str(out, count);
} else {
// a single char
single++;
}
*out++ = c;
}
const size_t length = out - string;
// expand
in = &string[length];
out = &string[length + single];
*out = '\0';
// I am not particularly happy at how this loops
// it's unreadable, but hey - it's fast and it works.
char c = *--in; // current character is buffered to be read
int cont; // should _the next_ loop continue
do {
// this should be a letter always
assert(!isdigit(c));
*--out = c;
// put the letter into destination
if ((cont = in != string) && (c = *--in, isdigit(c))) {
// copy up until digits
do {
*--out = c;
} while ((cont = in != string) && (c = *--in, isdigit(c)));
} else {
// the next input is not a digit
// add a one and repeat
*--out = '1';
}
} while (cont);
assert(in == string);
assert(out == string);
return string;
}
#define TEST(str) printf("%s -> %s\n", str, compress((char[sizeof(str) * 2 - 1]){str}))
int main() {
TEST("abbcccddddeef");
TEST("aabcdee");
TEST("");
TEST("a");
TEST("abcde");
TEST("aaaaaaaaaaaaaaaaaab");
TEST("aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
TEST("abbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
}
outputs:
abbcccddddeef -> 1a2b3c4d2e1f
aabcdee -> 2a1b1c1d2e
->
a -> 1a
abcde -> 1a1b1c1d1e
aaaaaaaaaaaaaaaaaab -> 18a1b
aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb -> 18a374b
abbbbbbbbbbbbbbbbbbbbbbbbbbbbbb -> 1a30b