while (j < num_v) //цикл по всем векторам. обращение к элементу вектора r[j*p+i]
			{
				for (int k = 0; k < 4 && j < num_v; ++k)
				{
					for (int l = 0; l < frequency; ++l)
					{
						r[j*p + i] = t[k];
						++j;
					}
				}
			}

//уравнение в формате a_op_i[0]+a_op_i[1]=sum
struct Equation
{
	int ind[2];//индексы в сумме
	int sum;//сумма
};

//облако уравнений
struct CloudEquations
{
	int p;//количество уравнений CONST
	struct Equation* eqs;// = NULL уравнений
	int* solve;// = NULL решения; если решение на найдено, происходит инициализация значениями '-1';solve[i]>=0
	int state;//состояние облака
};

struct CloudEquations* create_ceqs(char* y, int shift, int p)
{
//формирование облака уравнений. на входе массив символов '0'<=c<='9' и сдвиг

	struct CloudEquations* c = (struct CloudEquations*)malloc(sizeof(struct CloudEquations));
	int n = p - 1;//n=rounding_less(lgy)
	int k = shift;
	c->p = p; //1. CONST количество уравнений
	//2. выделяю память и создаю систему уравнений
	c->eqs = (struct Equation*)malloc(sizeof(struct Equation)*p);
	for (int i = 0; i < p; ++i)
	{
		c->eqs[i].ind[0] = i;
		c->eqs[i].ind[1] = (i < k) ? n - k + 1 + i : i - k;
	}
	//3. выделяю память и инициализирую массив решений
	c->solve = (int*)malloc(sizeof(int)*p);
	for (int i = 0; i < p; ++i)
	{
		c->solve[i] = -1;
	}
	//4. установка состояния облака; -1 облако не разрешено; 1 разрешено; 
	c->state = -1;
	return c;
}

int view_ceqs(struct CloudEquations* c)
{
	printf("START VIEW\n");
	printf("CONST p/The number of equations = %i\n", c->p);
	printf("\nThe system of equations:\n");
	for (int i = 0; i < c->p; ++i)
	{
		printf("x%i + x%i = %i\n", c->eqs[i].ind[0], c->eqs[i].ind[1], c->eqs[i].sum);
	}
	printf("\nSolution of the system:\n");
	for (int i = 0; i < c->p; ++i)
	{
		printf("x%i = %i\n", i, c->solve[i]);
	}
	printf("State of clouds = %i\n", c->state);
	printf("END VIEW\n");
	return 1;
}

//Рекурсивные инъекции в облако уравнений
int injection_intoClouudEquations(struct CloudEquations* c)
{
	for (int s = 0; s < 10 && c->state < 0; ++s)//цикл по видам инъекций
	{
		//массив не найденных решений
		int* f0 = (int*)malloc(sizeof(int)*c->p);
		for (int i = 0; i < c->p; ++i)
			f0[i] = (c->solve[i] == -1) ? -1 : 0;

		//нахожу индекс для укола
		int ind_s = 0;
		while (c->solve[ind_s] >= 0) 
			++ind_s;

		c->solve[ind_s] = s;//УКОЛ (установка стартового значения)

		int count;
		while (c->state<0) //пока не найдены все решения
		{
			int isOk = 0;
			count = c->p;
			for (int i = 0; i < c->p; ++i)//цикл по уравнениям
			{
				int i0 = c->eqs[i].ind[0];//текущий 0 индекс
				int i1 = c->eqs[i].ind[1];//текущий 1 индекс
				bool t0 = (c->solve[i0] == -1);//решение не найдено
				bool t1 = (c->solve[i1] == -1);//решение не найдено
				if (t0 + t1 == 1)//одно решение найдено, другое не найдено
				{
					++isOk;
					int t2 = (t0 == 1) ? i0 : i1;//в t2 индекс не найденного значения
					c->solve[t2] = c->eqs[i].sum - c->solve[i0 + i1 - t2];

					if (c->solve[t2]<0 || c->solve[t2]>9 || c->solve[c->p - 1] == 0)
					{
						goto label_end;
					}
				}
				else if (t0 + t1 == 0 && (c->solve[c->eqs[i].ind[0]] + c->solve[c->eqs[i].ind[1]] != c->eqs[i].sum))//сумма найденных решений не равна правой части
				{
					goto label_end;
				}
				else if (t0 + t1 == 0)
				{
					--count;
				}
			}//закончился цикл по уравнениям


			if (count == 0)
			{
				c->state = 1;
				free(f0);
				return 1;
			}

			if (isOk == 0 && count != 0)
			{
				//printf("\nen\n");
				int t = injection_intoClouudEquations(c);
				if (t == -1)
				{
					break;
				}
			}

		}

		if (c->state < 0)
		{

		label_end:;
			count = c->p;
			//Зануляю те позиции, чтобы были изменены уколом в позицию
			for (int i = 0; i < c->p; ++i)
			{
				f0[i] == -1 ? c->solve[i] = -1 : false;
			}
			free(f0);
		}
	}//завершается цикл по видам инъекций
	return -1;
}

#include <stdio.h>
 #include <0655.cpp>

int view_ceqs(struct CloudEquations* c)
{
	printf("START VIEW\n");
	printf("CONST p/The number of equations = %i\n", c->p);
	printf("\nThe system of equations:\n");
	for (int i = 0; i < c->p; ++i)
	{
		printf("x%i + x%i = %i\n", c->eqs[i].ind[0], c->eqs[i].ind[1], c->eqs[i].sum);
	}
	printf("\nSolution of the system:\n");
	for (int i = 0; i < c->p; ++i)
	{
		printf("x%i = %i\n", i, c->solve[i]);
	}
	printf("State of clouds = %i\n", c->state);
	printf("END VIEW\n");
	return 1;
}

int view_rCloud(const char* r, const char* s, int p)
{
	int num_v = 1 << (p - 1);//количество вариантов правой части 2^n-1

	for (int i = 0; i < num_v; ++i)
	{
		for (int j = 0; j < p; ++j)
		{
			printf("%2i ", r[i*p + j]);
		}
		printf("\n");
	}
	printf("\n");
	return 1;
}

char* create_rCloud(const char* s, char* r, int mode)
{
	int p = (mode == STANDART) ? strlen(s) : strlen(s) - 1;
	int num_v = 1 << (p - 1);//количество вариантов правой части 2^n-1

	int t[4];//все возможные варианты на этой позиции
	for (int i = 0; i < p; ++i)//цикл по i-ым позициям в векторах 
	{
		t[0] = s[i] - '0';
		t[1] = s[i] + 10 - '0';
		t[2] = s[i] - 1 - '0';
		t[3] = s[i] + 10 - 1 - '0';
		int frequency = 1 << (p - 1 - i - 1);//частота с которой встречается каждый элемент t[k],k=0..3

		int j = 0;
		while (j < num_v)//цикл по всем векторам. обращение к элементу вектора r[j*p+i]
		{
			if (i == 0)//рассматривается первый разряд числа
			{
				for (int k = 0; k < 2; ++k)
				{
					for (int l = 0; l < frequency; ++l)
					{
						r[j*p + i] = t[k];
						++j;
					}
				}
			}

			if (i > 0 && i < p - 1)//если рассматривается не первый, и не последний разряд числа
			{
				for (int k = 0; k < 4; ++k)//&& j < num_v
				{
					for (int l = 0; l < frequency; ++l)
					{
						r[j*p + i] = t[k];
						++j;
					}
				}
			}
			if (i == p - 1)//рассматривается последний разряд числа
			{
				if (mode == STANDART)
				{
					t[1] = s[i] - 1 - '0';
				}
				else
				{
					t[0] = s[i] - '0' + 10 * (s[i + 1] - '0');
					t[1] = s[i] - 1 - '0' + 10 * (s[i + 1] - '0');
				}
				for (int k = 0; k < 2; ++k)
				{
					r[j*p + i] = t[k];
					++j;
				}
			}
		}
	}

	return r;
}

//на входе реверс индексов
char* get_next_r(char* in)
{
	int p = strlen(in);
	int t = 0;
	//отдельная проверка первого индекса
	int i = 0;
	(in[i] == 0) ? (in[i] = 1, t += 1) : in[i] = 0;
	
	i += 1;
	while (t<2)
	{
		in[i] += 1;
		(in[i] < 4) ? t += 1 : in[i] = 0;
		i += 1;
	}
	return in;
}

	char s1[5] = { 0, 0, 0, 0, 0 };
	for (int i = 0; i < 15; ++i)
	{
		get_next_r(s1);
		for (int i = 0; i < 5; ++i)
			printf("%i", s1[i]);

		printf("\n");
	}