Форум DL

Мой профиль

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __bits(16) R;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

i16 CONST    (i16 A) {return A;}
u4 CONST4    (u4 A) {return A;}
i16 CBW      (i8  A) {return A;}
i32 CWD      (i16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

void main() {
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i16 b16 = CBW(b);
    i32 a32 = CWD(a16);
    i32 b32 = CWD(b16);

    i16 one = CONST(1);
    i32 one32 = CWD(one);
    i16 three = CONST(3);
    i32 three32 = CWD(three);

    i16 x_minus_1 = ISUB(x, one);                 // x - 1
    i32 x_minus_1_a_mul = IMUL(x_minus_1, a16);  // (x - 1) * a
    i16 y_plus_b = SUM(y, b16);                  // y + b
	i32 y_plus_b_32 = CWD(y_plus_b);
    i32 y_plus_b_div_3 = IDIV(y_plus_b_32, three32); // (y + b) / 3
	i16 x_minus_1_a_mul_16 = x32Tox16(x_minus_1_a_mul);
	i16 y_plus_b_div_3_16 = x32Tox16(y_plus_b_div_3);
    i16 res1 = SUM(x_minus_1_a_mul_16, y_plus_b_div_3_16); // (x - 1) * a + (y + b) / 3

    i16 x_plus_b = SUM(x, b16);                  // x + b
    i32 y_a_mul = IMUL(y, a16);                  // y * a
    i16 y_a_mul_16 = x32Tox16(y_a_mul);
    i16 x_plus_b_minus_y_a = ISUB(x_plus_b, y_a_mul_16); // x + b - y * a
    i16 b_div_x = IDIV(b32, x32);                // b / x
    i16 res2 = SUM(x_plus_b_minus_y_a, b_div_x); // x + b - y * a + b / x

    ICMPResult(x32, one32);
    u1 cond = ILT;  // x < 1

    R = MSb16x2(res2, res1, cond);
}

Мой профиль

Задача №22

int __in __bits(16) x;
int __in __bits(16) c;
int __in __bits(8) y;
int __in __bits(8) a;
int __out __bits(16) RES;
 
#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)
 
#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)
 
i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }
 
u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }
 
u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }
 
i16 CBW      (i8  A) {return A;}
i32 CWD      (i16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}
i16 CONST    (i16 A) {return A;}
u4 CONST4    (u4 A) {return A;}
 
i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}
 
u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}
 
void main() {
   i32 x32 = CWD(x);
   i32 c32 = CWD(c);
   i16 y16 = CBW(y);
   i16 a16 = CBW(a);
   i32 y32 = CWD(y16);
   i32 a32 = CWD(a16);
 
   i16 zero16 = CONST(0);
   i32 zero32 = CWD(zero16);
 
   // Ветка 1: (x * a + y * c) / a - c, если x * y <= 0
   i32 xa_mul = IMUL(x, a16);
   i16 xa_mul_16 = x32Tox16(xa_mul);
   i32 yc_mul = IMUL(y16, c);
   i16 yc_mul_16 = x32Tox16(yc_mul);
   i16 sum1 = SUM(xa_mul_16, yc_mul_16);
   i32 sum1_32 = CWD(sum1);
   i16 div1 = IDIV(sum1_32, a32);
   i16 res1 = ISUB(div1, c); // (x * a + y * c) / a - c

   // Ветка 2: (x * c - a * y) / (y + x), если x * y > 0
   i32 xc_mul = IMUL(x, c);
   i16 xc_mul_16 = x32Tox16(xc_mul);
   i32 ay_mul = IMUL(a16, y16);
   i16 ay_mul_16 = x32Tox16(ay_mul);
   i16 sub2 = ISUB(xc_mul_16, ay_mul_16);
   i32 sub2_32 = CWD(sub2);
   i16 sum2 = SUM(y16, x);
   i16 res2 = IDIV(sub2_32, sum2); // (x * c - a * y) / (y + x)

   // Условие: x * y <= 0
   i32 xy_mul = IMUL(x, y16);
   ICMPResult(xy_mul, zero32);
   u1 cond = OR2(IEQ, ILT);

   // Выбор результата на основе условия
   RES = MSb16x2(res2, res1, cond);
}

Мой профиль

Задача №8

#include <hlccad.mpc>

int __in __bits(16) X;
int __in __bits(16) Y;
int __in __bits(8) A9;
int __in __bits(8) B7;
int __out __bits(16) RES;

void main() {
    // Приведение переменных к необходимым типам
    i32 X32 = CWD(X);
    i32 Y32 = CWD(Y);
    i16 A9_16 = CBW(A9);
    i16 B7_16 = CBW(B7);

    // Константа 0
    i16 ZERO_16 = CONST(0);
    i32 ZERO_32 = CWD(ZERO_16);

    // Вычисление для первой ветки: (Y + X * A9 - B7) / Y
    i32 XA9 = IMUL(X, A9_16);         // X * A9
    i16 XA9_16 = x32Tox16(XA9);
    i16 Y_XA9 = SUM(Y, XA9_16);       // Y + X * A9
    i16 Y_XA9_B7 = ISUB(Y_XA9, B7_16);// Y + X * A9 - B7
    i32 Y_XA9_B7_32 = CWD(Y_XA9_B7);
    i16 RES1 = IDIV(Y_XA9_B7_32, Y32);// (Y + X * A9 - B7) / Y

    // Вычисление для второй ветки: (Y + A9) * X / Y - B7
    i16 Y_A9 = SUM(Y, A9_16);         // Y + A9
    i32 Y_A9_X = IMUL(Y_A9, X);       // (Y + A9) * X
    i16 Y_A9_X_div_Y = IDIV(Y_A9_X, Y32); // (Y + A9) * X / Y
    i16 RES2 = ISUB(Y_A9_X_div_Y, B7_16); // (Y + A9) * X / Y - B7

    // Условие: X * Y >= 0
    i32 XY = IMUL(X, Y);              // X * Y
    ICMPResult(XY, ZERO_32);
    u1 COND = OR2(IEQ, IGT);          // X * Y >= 0

    // Выбор результата
    RES = MSb16x2(RES2, RES1, COND);
}

Мой профиль

Задача №21

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) b;
int __out __bits(16) R;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A) { return A; }
u32 CWD      (u16 A) { return A; }
i16 CONST    (i16 A) { return A; }

i16 x32Tox16 (i32 A) { return A; }
i8  x16Tox8  (i16 A) { return A; }

i16 SUM      (i16 A, i16 B) { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B) { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B) { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B) { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3  ICMP     (i32 A, i32 B) { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1  IGT;
u1  IEQ;
u1  ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {
    // Приведение входных данных к необходимым типам
    i16 a16 = CBW(a);                      // Приведение a к i16
    i16 b16 = CBW(b);                      // Приведение b к i16
    i16 x16 = x;                           // Приведение x к i16
    i16 y16 = y;                           // Приведение y к i16
    i32 x32 = CWD(x16);                    // Приведение x к i32
    i32 y32 = CWD(y16);                    // Приведение y к i32

    // Константы
    i16 const_0 = CONST(0);                // Константа 0
    i16 const_15 = CONST(15);              // Константа 15

    // Проверка диапазона x для вычисления факториала
    ICMPResult(x16, const_0);              // Сравнение x и 0
    u1 x_ge_0 = OR2(IEQ, IGT);             // x >= 0
    ICMPResult(x16, const_15);             // Сравнение x и 15
    u1 x_le_15 = OR2(IEQ, ILT);            // x <= 15
    u1 x_valid = AND2(x_ge_0, x_le_15);    // Условие: 0 <= x <= 15

    // Приведение x к u4 или замена на 0
    u4 x_u4 = x16;                         // Приведение x к u4
    u4 x_u4_safe = MSb16x2(0, x_u4, x_valid); // x, если 0 <= x <= 15, иначе 0

    // Вычисление x!
    u64 x_fact_64 = FACT(x_u4_safe);       // Факториал x
    i16 x_fact_16 = x32Tox16(x_fact_64);   // Приведение результата факториала к i16

    // Вычисление y / (a - b)
    i16 diff_ab = ISUB(a16, b16);          // Разность a - b
    i32 diff_ab_32 = CWD(diff_ab);         // Приведение разности к i32
    i16 y_div_ab = IDIV(y32, diff_ab_32);  // y / (a - b)

    // Результат первой ветки
    i16 res1 = SUM(x_fact_16, y_div_ab);   // x! + y / (a - b)

    // Вычисление 7!
    u4 const_7 = CONST(7);                 // Константа 7
    u64 fact_7_64 = FACT(const_7);         // Факториал 7
    i16 fact_7_16 = x32Tox16(fact_7_64);   // Приведение результата факториала к i16

    // Вычисление x * y / (a - b)
    i32 xy_mul = IMUL(x16, y16);           // Произведение x * y
    i16 xy_div_ab = IDIV(xy_mul, diff_ab_32); // Деление (x * y) / (a - b)

    // Результат второй ветки
    i16 res2 = SUM(fact_7_16, xy_div_ab);  // 7! + x * y / (a - b)

    // Условие выбора ветки
    i16 const_1 = CONST(1);                // Константа 1
    i32 const_1_32 = CWD(const_1);         // Приведение 1 к i32
    i16 const_8 = CONST(8);                // Константа 8
    i32 const_8_32 = CWD(const_8);         // Приведение 8 к i32

    ICMPResult(x32, const_1_32);           // Сравнение x и 1
    u1 cond1 = ILT;                        // x < 1
    ICMPResult(x32, const_8_32);           // Сравнение x и 8
    u1 cond2 = IGT;                        // x > 8
    u1 cond = OR2(cond1, cond2);           // Условие выбора ветки

    // Выбор результата на основе условия
    R = MSb16x2(res1, res2, cond);
}

Мой профиль

Задача №25

int __in __bits(16) x;
int __in __bits(16) y;
int __in __bits(8) a;
int __in __bits(8) c;
int __out __bits(16) RES;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

i16 CONST    (i16 A) {return A;}
u4 CONST4    (u4 A) {return A;}
i16 CBW      (i8  A) {return A;}
i32 CWD      (i16 A) {return A;}
i16 x32Tox16 (i32 A) {return A;}
i8  x16Tox8  (i16 A) {return A;}

i16 SUM      (i16 A, i16 B) {i16 C; C = A + B; return C;}
i16 ISUB     (i16 A, i16 B) {i16 C; C = A - B; return C;}
i32 IMUL     (i16 A, i16 B) {i32 C; C = A * B; return C;}
i16 IDIV     (i32 A, i32 B) {i16 C; C = A / B; return C;}

u16 MSb16x2(u16 Zero, u16 One, u1 A) {return (A) ? One : Zero;}
u3 ICMP(i32 A, i32 B) {return (A > B) ? 4 : (A == B) ? 2 : 1;}
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) {u3 C = ICMP(A,B); IGT = C == 4; IEQ = C == 2; ILT = C == 1;}

void main() {
    i32 x32 = CWD(x);
    i32 y32 = CWD(y);
    i16 a16 = CBW(a);
    i16 c16 = CBW(c);
    i32 a32 = CWD(a16);
    i32 c32 = CWD(c16);

    i16 zero = CONST(0);
    i32 zero32 = CWD(zero);

    i32 x_squared = IMUL(x, x);            // x^2
	i16	x_squared_16 = x32Tox16(x_squared);
    i16 x_squared_div_a = IDIV(x_squared, a32); // x^2 / a
    i32 y_squared = IMUL(y, y);            // y^2
	i16	y_squared_16 = x32Tox16(y_squared);
    i16 y_squared_div_c = IDIV(y_squared, c32); // y^2 / c
    i32 a_c_mul = IMUL(a16, c16);          // a * c
    i16 a_c_mul_16 = x32Tox16(a_c_mul); 
    i16 res1_temp = SUM(x_squared_div_a, y_squared_div_c); // x^2 / a + y^2 / c
    i16 res1 = ISUB(res1_temp, a_c_mul_16); // x^2 / a + y^2 / c - a * c

    i32 a_squared = IMUL(a16, a16);        // a^2
    i16 x_div_a_squared = IDIV(x32, a_squared); // x / a^2
    i32 c_squared = IMUL(c16, c16);        // c^2
    i16 y_div_c_squared = IDIV(y32, c_squared); // y / c^2
    i32 x_squared_y_squared = IMUL(x_squared_16, y_squared_16); // x^2 * y^2
    i16 x_squared_y_squared_16 = x32Tox16(x_squared_y_squared);
    i16 res2_temp = SUM(x_div_a_squared, y_div_c_squared); // x / a^2 + y / c^2
    i16 res2 = ISUB(res2_temp, x_squared_y_squared_16); // x / a^2 + y / c^2 - x^2 * y^2

    i32 x_y_mul = IMUL(x, y);          // x * y
    ICMPResult(x_y_mul, zero32);
    u1 cond = ILT;  // x * y < 0

    RES = MSb16x2(res2, res1, cond);
}

Мой профиль

Задача №1

#include <hlccad.mpc>

int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;
int __out __bits(16) RES;

void main() {
    i32 a32 = CWD(a);
    i32 b32 = CWD(b);
    i16 c16 = CBW(c);
    i16 d16 = CBW(d);
    i32 c32 = CWD(c16);
    i32 d32 = CWD(d16);

    i16 zero = CONST(0);
    i32 zero32 = CWD(zero);

    i16 a_div_b = IDIV(a32, b32);                       // a / b
    i16 sum1 = SUM(a_div_b, c16);                       // a / b + c
    i32 d_a_mul = IMUL(d16, a);                         // d * a
    i16 d_a_mul_16 = x32Tox16(d_a_mul);
    i16 res1 = ISUB(sum1, d_a_mul_16);                  // a / b + c - d * a

    i16 a_div_d = IDIV(a32, d32);                       // a / d
    i16 c_plus_a_div_d = SUM(c16, a_div_d);             // c + a / d
    i32 c_plus_a_b_mul = IMUL(c_plus_a_div_d, b);       // (c + a / d) * b
    i16 c_plus_a_b_mul_16 = x32Tox16(c_plus_a_b_mul);
    i16 res2 = ISUB(b, c_plus_a_b_mul_16);              // b - (c + a / d) * b

    i32 a_d_mul = IMUL(a, d16);                         // a * d
    ICMPResult(a_d_mul, zero32);
    u1 cond = ILT;

    RES = MSb16x2(res2, res1, cond);
}

Мой профиль

Задача №7

int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;
int __out __bits(16) RES;

#define i8  int __bits(8)
#define i16 int __bits(16)
#define i32 int __bits(32)

#define u1  unsigned __bits(1)
#define u3  unsigned __bits(3)
#define u8  unsigned __bits(8)
#define u16 unsigned __bits(16)
#define u32 unsigned __bits(32)
#define u64 unsigned __bits(64)
#define u4  unsigned __bits(4)

i16 SIGN     (i16 A)             { return (A > 0) ? 1 : (A == 0) ? 0 : -1; }
i16 ABS      (i16 A)             { return (A > 0) ? A : (A * (-1)); }
u64 FACT     (u4 A)              { u64 RES = 1; while (A > 1) RES *= A--; return RES; }

u1  NOT      (u1  A)             { return ~A; }
u1  OR2      (u1  A, u1  B)      { return A | B; }
u1  XOR2     (u1  A, u1  B)      { return A ^ B; }
u1  AND2     (u1  A, u1  B)      { return A & B; }

u8  DC       (u1  CS, u3  X)     { u8 d = 1; return (CS == 0) ? 0 : d << X; }
u4  CD       (u8  X)             { if (X == 0) return 0; u4 i = 0; while (!(X & 1)) { i++; X = X >> 1; } return (i << 1) + 1; }
u1  MS       (u8  X, u3  A)      { return ((X >> A) & 1); }

u16 CBW      (u8  A)             { return A; }
u32 CWD      (u16 A)             { return A; }
i16 x32Tox16 (i32 A)             { return A; }
i8  x16Tox8  (i16 A)             { return A; }
i16 CONST    (i16 A)             { return A; }

i16 SUM      (i16 A, i16 B)      { i16 C; C = A + B; return C; }
i16 ISUB     (i16 A, i16 B)      { i16 C; C = A - B; return C; }
i32 IMUL     (i16 A, i16 B)      { i32 C; C = A * B; return C; }
i16 IDIV     (i32 A, i32 B)      { i16 C; C = A / B; return C; }

u16 MSb16x2  (u16 Zero, u16 One, u1 A) { return (A) ? One : Zero; }
u3 ICMP      (i32 A, i32 B)      { return (A > B) ? 4 : (A == B) ? 2 : 1; }
u1 IGT;
u1 IEQ;
u1 ILT;
void ICMPResult(i32 A, i32 B) { u3 C = ICMP(A, B); IGT = C == 4; IEQ = C == 2; ILT = C == 1; }

void main() {
    i32 a32 = CWD(a);
    i16 c16 = CBW(c);
    i32 c32 = CWD(c16);
    i16 d16 = CBW(d);
    i32 d32 = CWD(d16);
    i32 b32 = CWD(b);

    i16 div_c_a = IDIV(c32, a32);         // c / a
    i16 div_b_d = IDIV(b32, d32);         // b / d
    i32 mul_ac = IMUL(a, c16);            // a * c
    i16 mul_ac16 = x32Tox16(mul_ac);
    i16 res1_temp = SUM(div_c_a, div_b_d);
    i16 res1 = ISUB(res1_temp, mul_ac16); // res1 = c/a + b/d - a * c

    i32 mul_cd32 = IMUL(c16, d16);        // c * d
    i16 sign_cd = SIGN(mul_cd32);         // sign(c * d)
    i16 sum_ab = SUM(a, b);               // a + b
    i16 res2_temp = ISUB(sum_ab, sign_cd);
    i32 res2_temp32 = CWD(res2_temp);
    i16 res2 = IDIV(res2_temp32, a32);    // res2 = (a + b - sign(c * d)) / a

    i16 const4 = CONST(4);
    i32 const4_32 = CWD(const4);
    ICMPResult(a32, const4_32);
    u1 isEqual = IEQ;

    RES = MSb16x2(res2, res1, isEqual);
}

Мой профиль

Задача №2

#include <hlccad.mpc>

// Объявление входных и выходных переменных
int __in __bits(16) a;
int __in __bits(16) b;
int __in __bits(8) c;
int __in __bits(8) d;
int __out __bits(16) RES;

// Главная функция
void main() {
    // Приведение входных переменных к нужным типам
    i16 a16 = a;
    i16 b16 = b;
    i16 c16 = CBW(c);
    i16 d16 = CBW(d);
    i32 a32 = CWD(a16);
    i32 b32 = CWD(b16);
    i32 c32 = CWD(c16);
    i32 d32 = CWD(d16);

    i16 zero16 = CONST(0);
    i32 zero32 = CWD(zero16);

    // Вычисление res1 для первой ветки: (a / b) / c + (d * c - d / b) * a
    i16 div_ab = IDIV(a32, b32); // a / b
    i32 div_ab_32 = CWD(div_ab);
    i16 div_ab_c = IDIV(div_ab_32, c32); // (a / b) / c
    i32 mul_dc = IMUL(d16, c16); // d * c
    i16 mul_dc_16 = x32Tox16(mul_dc);
    i16 div_db = IDIV(d32, b32); // d / b
    i16 sub_dc_db = ISUB(mul_dc_16, div_db); // (d * c) - (d / b)
    i16 mul_sub_dc_db_a = IMUL(sub_dc_db, a16); // ((d * c) - (d / b)) * a
    i16 mul_sub_dc_db_a_16 = x32Tox16(mul_sub_dc_db_a);
    i16 res1 = SUM(div_ab_c, mul_sub_dc_db_a_16); // (a / b) / c + ((d * c - d / b) * a)

    // Вычисление res2 для второй ветки: ((a * b + c) * d - (a * d + b) * c) / b
    i32 mul_ab = IMUL(a16, b16); // a * b
    i16 mul_ab_16 = x32Tox16(mul_ab);
    i16 sum_ab = SUM(mul_ab_16, c16); // a * b + c
    i32 mul_sum_ab_d = IMUL(sum_ab, d16); // (a * b + c) * d
    i16 mul_sum_ab_d_16 = x32Tox16(mul_sum_ab_d);
    i32 mul_ad = IMUL(a16, d16); // a * d
    i16 mul_ad_16 = x32Tox16(mul_ad);
    i16 sum_ad_b = SUM(mul_ad_16, b16); // a * d + b
    i32 mul_sum_ad_b_c = IMUL(sum_ad_b, c16); // (a * d + b) * c
    i16 mul_sum_ad_b_c_16 = x32Tox16(mul_sum_ad_b_c);
    i16 sub_mul_sum = ISUB(mul_sum_ab_d_16, mul_sum_ad_b_c_16); // ((a * b + c) * d - (a * d + b) * c)
    i32 sub_mul_sum_32 = CWD(sub_mul_sum);
    i16 res2 = IDIV(sub_mul_sum_32, b32); // ((a * b + c) * d - (a * d + b) * c) / b

    // Определение условия b > 0 или c > 0
    ICMPResult(b32, zero32);
    u1 cond1 = IGT; // b > 0
    ICMPResult(c32, zero32);
    u1 cond2 = IGT; // c > 0
    u1 cond = OR2(cond1, cond2); // b > 0 или c > 0

    // Выбор результата
    RES = MSb16x2(res2, res1, cond);
}

Мой профиль

Решенные задачи HLCCAD:
Задача 1
Задача 2
Задача 3
Задача 4
Задача 5
Задача 6
Задача 7
Задача 8
Задача 9
Задача 10
Задача 11
Задача 12
Задача 13
Задача 14
Задача 15
Задача 16
Задача 17
Задача 18
Задача 19
Задача 20
Задача 21
Задача 22
Задача 23
Задача 24
Задача 25
Задача 26
Задача 27
Задача 28
Задача 29
Задача 30

Файл препромпт:
Файл препромпт для AI

GenAI
https://bigmodel.cn/console/trialcenter?modelCode=glm-4-plus
https://chatgpt.com (через vpn)

Мой профиль

Задачи, которые прошли с использованием DL AI:
Сам-с1 Задача №1 (пришлось только исправить #define вручную, чтобы был один #define на одну строку) - прошла с первой отсылки.
Сам-с4. Задача №4 - прошла с первой отсылки.
Сам-с7. - Задача №7 - прошла с первой отсылки
Сам-с16. Задача №16 - прошла с первой отсылки
Сам-с19. Задача №19 - прошла с первой отсылки
Сам-с25. Задача №25 - прошла с первой отсылки
Сам-с28. Задача №28 - прошла с первой отсылки

Задачи которые не прошли при использовании DL-AI:
Сам-с10. Задача №10 - ошибка при написании условия >=, а также приведение типов на одной строке с делением.
Сам-с13. Задача №13 - ошибка с форматированием от DL-AI и ,как следствие, трата времени на обнаружение части кода в закомментированной части, ошибка с построением условия >=, он пишет проверку для X > 0 и Y > 0, а необходимое условие - X * Y >= 0.
Сам-с22. Задача №22 - ошибка в названии переменной и неправильное использование функций (функция не возвращает такую размерность, какую DL-AI ожидает), неправильное условие <=

Мой профиль

Задачи которые прошли при использовании DL-AI:
Задача №3 - прошла с первой отсылки.
Задача №9 - прошла, но ai не везде использует правильные размерности а так же не использует функцию CONST, а использует просто число.
Задача №12 - прошла после запроса у ai, чтобы исправил условие, т.к. он изначально проверял только X*Y>0, а нужно X*Y>=0. Также в некоторых местах ai сделал вложение функций.
Задача №15 - прошла снова после исправления условия, ai добавил функцию NOT в условии, которая там не нужна была. Снова сделал вложения и не те размерности в некоторых местах.
Задача №18 - прошла после исправления условия(>=), снова ошибки в размерностях и вложении.
Задача №21 - прошла после исправления функции CONST, ai изменил название библиотечной функции на CONST4 при объявлении некоторых констант.

Задачи которые не прошли при использовании DL-AI:
Задача №6 - не проходит 1-й тест, также ai использует вложение функций во второй ветке, т.к. в задаче очень много умножений и ai забывает про размерности.

Мой профиль

Задачи, прошедшие на DL_Ai:
Задача №2 - с первой отсылки.
Задача №5 - с первой отсылки.
Задача №8 - с четвёртой отсылки. DL_Ai делает ошибки в создании сложного условия (>=). Так же иногда встречаются ошибки в размерностях переменных. Ещё появляются вложенные вызовы функций.
Задача №11 - с первой отсылки. Но код содержит вложенные вызовы функций, и иногда встречаются неправильные размерности переменных.
Задача №14 - с пятой отсылки. DL_Ai неправильно понял условие второй ветки. И долго ничего не исправлял. Так же ошибка в проверке условия. Снова встречаются некорректные размерности переменных.
Задача №17 - со второй отсылки. Снова неправильное условие для проверки. Код содержит много вложенных вызовов и ошибок в размерностях.
Задача №20 - с первой отсылки.
Задача №23 - с третьей отсылки. Из-за ошибочного форматирования в DL_Ai в комментарии попали строки объявления переменных, что вызвало ошибку компиляции. И программа с include так же вызвала ошибку компиляции, из-за чего нужно вставлять всю библиотеку в исходный файл. Код всё так же содержит некорректные размерности в аргументах функций.
Задача №24 - с четвертой отсылки. ИИ долго не мог исправить ошибки, связанные с условием выбора ветки.
Задача №26 - с первой отсылки. Но неправильное форматирование кода снова вызвало ошибку компиляции.
Задача №27 - с пятой отсылки. Задача содержит большие степени у переменных. ИИ часто неправильно расставлял размерности, делал много вложенностей, что не позволяло правильно решить задачу.
Задача №29 - со второй отсылки. ИИ неправильно понял условие первой ветки. После указания на ошибку, код был исправлен.
Задача №30 - с пятой отсылки. ИИ долго не мог решить задачу, пример которой написан в файле.

Мой профиль

Работа в HLCCAD с использованием ИИ

Мой профиль

int __in __bits(8) a; 
int __in __bits(8) c; 
int __in __bits(16) x; 
int __in __bits(16) y; 
int __out __bits(16) res;

void main() { // Приведение переменных к необходимым типам 
i16 a16 = CBW(a); 
i16 c16 = CBW(c); 
i32 x32 = CWD(x); 
i32 y32 = CWD(y);

// Вычисление выражения для первой ветки: ((x+y)/c-x)*a, если x*y<0
i32 xy_mul = IMUL(x, y); // x * y
i16 xy_mul_16 = x32Tox16(xy_mul);

i32 x_y_sum = IMUL(x, y); // x + y
i16 x_y_sum_16 = x32Tox16(x_y_sum);
i16 x_y_div_c = IDIV(x_y_sum_16, c16); // (x + y) / c
i16 x_y_div_c_x = ISUB(x_y_div_c, x); // (x + y) / c - x
i32 x_y_div_c_x_a = IMUL(x_y_div_c_x, a16); // ((x + y) / c - x) * a
i16 res1 = x32Tox16(x_y_div_c_x_a);

// Вычисление выражения для второй ветки: ((a-x*y)*c)/y+x*y, если x*y>=0
i32 a_xy_mul = IMUL(a16, xy_mul_16); // a * x * y
i16 a_xy_mul_16 = x32Tox16(a_xy_mul);
i16 a_xy_mul_c = IMUL(a_xy_mul_16, c16); // (a - x * y) * c
i16 a_xy_mul_c_y = IDIV(a_xy_mul_c, y); // ((a - x * y) * c) / y
i16 res2 = SUM(a_xy_mul_c_y, xy_mul_16);

// Условие для выбора выражения
i16 zero = CONST(0);
ICMPResult(xy_mul_16, zero);
u1 cond = ILT; // x * y < 0

// Выбор результата на основе условия
res = MSb16x2(res2, res1, cond);

}

Отправила на DLAI ваш препромпт для решения 28-й задачи. Получила код, предоставленный выше, и он не прошел. [TEST1]: Ошибка компиляции (mpc): Ошибка синтаксиса (строка 8): i16 a16 = CBW(a); .

Мой профиль

Ксения Бышик:

int __in __bits(8) a; 
int __in __bits(8) c; 
int __in __bits(16) x; 
int __in __bits(16) y; 
int __out __bits(16) res;

void main() { // Приведение переменных к необходимым типам 
i16 a16 = CBW(a); 
i16 c16 = CBW(c); 
i32 x32 = CWD(x); 
i32 y32 = CWD(y);

// Вычисление выражения для первой ветки: ((x+y)/c-x)*a, если x*y<0
i32 xy_mul = IMUL(x, y); // x * y
i16 xy_mul_16 = x32Tox16(xy_mul);

i32 x_y_sum = IMUL(x, y); // x + y
i16 x_y_sum_16 = x32Tox16(x_y_sum);
i16 x_y_div_c = IDIV(x_y_sum_16, c16); // (x + y) / c
i16 x_y_div_c_x = ISUB(x_y_div_c, x); // (x + y) / c - x
i32 x_y_div_c_x_a = IMUL(x_y_div_c_x, a16); // ((x + y) / c - x) * a
i16 res1 = x32Tox16(x_y_div_c_x_a);

// Вычисление выражения для второй ветки: ((a-x*y)*c)/y+x*y, если x*y>=0
i32 a_xy_mul = IMUL(a16, xy_mul_16); // a * x * y
i16 a_xy_mul_16 = x32Tox16(a_xy_mul);
i16 a_xy_mul_c = IMUL(a_xy_mul_16, c16); // (a - x * y) * c
i16 a_xy_mul_c_y = IDIV(a_xy_mul_c, y); // ((a - x * y) * c) / y
i16 res2 = SUM(a_xy_mul_c_y, xy_mul_16);

// Условие для выбора выражения
i16 zero = CONST(0);
ICMPResult(xy_mul_16, zero);
u1 cond = ILT; // x * y < 0

// Выбор результата на основе условия
res = MSb16x2(res2, res1, cond);

}

Отправила на DLAI ваш препромпт для решения 28-й задачи. Получила код, предоставленный выше, и он не прошел. [TEST1]: Ошибка компиляции (mpc): Ошибка синтаксиса (строка 8): i16 a16 = CBW(a); .

Код написан исправно, единственное что неправильно, так это момент с подключением библиотеки hlccad. На данный момент необходимо вручную прописывать всю библиотеку в самом верху кода. Мы это сделали для сокращения записи в файле-препромте.