110 => 1000

100 => 011

111 => 01X

size_t strlen(const char* s)

size_t size =strlen(s); 

size_t s =strlen(str);

size_t len=strlen(s);  

size_t p=strlen(s)+1;  

//УМНОЖЕНИЕ
//s-строка,num-число
//функция оптимизированна под умножение строки на строку за счёт сдвига shift
int la_multiplication_string_on_num_inplace(char* res, size_t p, const char* s, size_t ps, unsigned int num, int sh)
{
	if ((ps == MIN_POW && s[0] == '0') || (num == 0))
	{
		*res++ = '0';
		*res = '\0';
		return 0;
	}
	memset(res, '0', p);
	int d = 0;
	for (int i = ps - 2; i >= 0; --i)
	{
		int t = (s[i] - SHIFT)*num + d;
		int t1 = t % 10;
		res[i + 1] = t1 + SHIFT;
		d = (t - t1)/10;
	}
	res[p - 1] = '\0';
	!d ? (char)memmove(res, res + 1, p - 1) : res[0] = d + SHIFT;
	return 0;
}

//умножение строки на число. обёртка s*num*10^sh
char* la_multiplication_string_on_num(const char* s, unsigned int num, int sh)
{
	size_t ps = strlen(s)+1;
	if (ps > MAX_POW)
	{
		printf("Incorrect size of the string(s).\n");
		return NULL;
	}
	size_t p = ps + 1+sh;//реализую умножение на 10^sh
	char* res = allocate_memory(p);
	la_multiplication_string_on_num_inplace(res, p, s, ps, num, sh);
	return res;
}

int la_multiplication_inplace(char* res, size_t p, const char* s1, size_t p1, const char* s2, size_t p2)
{
	memset(res, '0', p);
	*(res + p - 1) = '\0';
	for (int i = p2 - 2; i >= 0; --i)
	{
		char* t = la_multiplication_string_on_num(s1, s2[i] - SHIFT, p2 - 2 - i);
		char* t2=la_sum(res, t);
		memcpy(res + p - 1 - strlen(t2), t2, strlen(t2));
		free(t2);
		free(t);
	}
	return 0;
}

char* la_multiplication(const char* s1, const char* s2)
{
	size_t p1 = strlen(s1) + 1;
	size_t p2 = strlen(s2) + 1;
	size_t p = p1 + p2 - 1;
	if (p > MAX_POW)
	{
		printf("Incorrect size of the string(s).\n");
		return NULL;
	}
	char* res = allocate_memory(p);
	la_multiplication_inplace(res, p, s1, p1, s2, p2);
	res[0]=='0' ? (char)memmove(res, res + 1, p - 1) : 0;
	return res;
}

//Сочетания
char* la_combination(unsigned n, unsigned m)
{
	int* up = (int*)malloc(sizeof(int)*m);//числитель
	int* down = (int*)malloc(sizeof(int)*m);//
	for (int i = 1; i <= m; ++i)
	{
		*(up + i - 1) = n - m + i;
		*(down + i - 1) = i;
	}
#ifdef DEBUG
	for (int i = 0; i < m; ++i)
		printf("%i ", up[i]);
	printf("\n");
	for (int i = 0; i < m; ++i)
		printf("%i ", down[i]);
	printf("\n");
#endif

	//сокращаем знаменатель в один проход. Необходимо обоснование того, что это можно сделать за один проход
	for (int i = 0; i < m; ++i)
	{
		if (down[i] != 1)
		{
			for (int j = 0; j < m; ++j)
			{
				if (!(up[j] % down[i]))
				{
					up[i] /= down[i];
					down[i] = 1;//если этот алгоритм верный, то эта строчка не нужна
				}
			}
		}
	}
#ifdef DEBUG
	for (int i = 0; i < m; ++i)
		printf("%i ", up[i]);
	printf("\n");
	for (int i = 0; i < m; ++i)
		printf("%i ", down[i]);
	printf("\n");
#endif
	return NULL;
}

up[j] /= down[i];