oniic/sibsutis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Long time no see

Browse Source
This commit is contained in:
0niic
2026-02-21 10:47:00 +07:00
parent 0d54fe176e
commit b7df98a55c
198 changed files with 3249 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
1Y-2H/prog/1Practice/var2/code/head.h
+48
View File
@@ -0,0 +1,48 @@
#ifndef Head
#define Head
// INCLUDE
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
// DEFINE
#define LLI long long int
#define MAX_MATRIX_ALIVE 21
#define BUFF_MAX 10 //(char) <= 254
#define IN_BUFF_CHARS 10 //(char) <= 254
//TypeDef
// matrix.c
typedef struct {
int rows;
int cols;
int** data;
} MATRIX2D;
// FUNC
// === io.c ===
MATRIX2D* create_matrix2d(int rows, int cols);
char buff_input(char *inbuff, char *_buff);
char cmd_buff(char* _buff,char** _charCommands,char NUM_OF_CHAR_COMMANDS);
char get_matrix_num(void);
int get_num(void);
// === matrix.c ===
void create_matrix(MATRIX2D** addr, unsigned char n, int rows, int cols);
void input_matrix(MATRIX2D** addr, unsigned char n);
void get_matrix(MATRIX2D** addr, unsigned char n);
void logic_matrix(MATRIX2D** addr, unsigned char n1, unsigned char n2);
void edit_matrix(MATRIX2D** addr, unsigned char n);
void matrix_random(MATRIX2D** addr, unsigned char n);
void copy_matrix(MATRIX2D** addr, unsigned char n1, unsigned char n2);
void free_matrix(MATRIX2D** addr, unsigned char n);
void get_matrix_col(MATRIX2D** addr, unsigned char n, int c);
void get_matrix_row(MATRIX2D** addr, unsigned char n, int r);
void transp_matrix(MATRIX2D** addr, unsigned char n);
LLI determ_matrix(MATRIX2D** addr, unsigned char n);
void obr_matrix(MATRIX2D** addr, unsigned char n);
void is_Matrix_Exist(MATRIX2D** addr, unsigned char n);
#endif
1Y-2H/prog/1Practice/var2/code/io.c
+108
View File
@@ -0,0 +1,108 @@
#include "head.h"
char buff_input(char *inbuff, char *_buff){
*inbuff = 0;
{ // INPUT
char ch;
while((ch=getchar())>' '&&*inbuff<BUFF_MAX){
*(_buff+*inbuff)=(int)ch;
(*inbuff)++;
}
if(ch<= 4)return -1;
}
if (_buff[0]>='a' && _buff[0] <= 'z')
{ // Is input - command?
const char NUM_OF_CHAR_COMMANDS = 15;
char * _charCommands[NUM_OF_CHAR_COMMANDS]; // _charCommands[*]["char"]
_charCommands[0] = (char[]){"input"};
_charCommands[1] = (char[]){"getmatrix"};
_charCommands[2] = (char[]){"logic"};
_charCommands[3] = (char[]){"edit"};
_charCommands[4] = (char[]){"random"};
_charCommands[5] = (char[]){"copy"};
_charCommands[6] = (char[]){"destruct"};
_charCommands[7] = (char[]){"getcolum"};
_charCommands[8] = (char[]){"getrow"};
_charCommands[9] = (char[]){"transp"};
_charCommands[10] = (char[]){"determ"};
_charCommands[11] = (char[]){"obr"};
_charCommands[12] = (char[]){"create"};
_charCommands[13] = (char[]){"n"};
_charCommands[14] = (char[]){"exit"};
char cmd = cmd_buff(_buff,_charCommands,NUM_OF_CHAR_COMMANDS);
if(cmd==15)return -1; //exit
return cmd; //Вернуть комману
}
return 0;
}
char cmd_buff(char* _buff,char** _charCommands,char NUM_OF_CHAR_COMMANDS){
for (int i = 0;i<NUM_OF_CHAR_COMMANDS;i++){
char flag = 1;
for(int j = 0;*(_charCommands[i]+j)!='\0';j++){
if (_buff[j]!=*(_charCommands[i]+j)){
flag = 0;
break;
}
}
if(flag) return i+1;//Вернуть комманду
}
return 0;
}
char get_matrix_num(void){
char inbuff;
char _buff[BUFF_MAX];
while(buff_input(&inbuff,_buff)>0&&*_buff>' ');
long int num = 0;
char flagIsDec = 1;
{ // GetNum
int i = 0;
if(_buff[0]=='-'){i++;flagIsDec = -1;}
for(; i<inbuff;i++)
if(_buff[i]>= '0' && _buff[i] <= '9')
num = (num*10) + (_buff[i]-'0');
num *= flagIsDec;
}
if (num>MAX_MATRIX_ALIVE)num = MAX_MATRIX_ALIVE;
if (num<0)num = 0;
return num;
}
int get_num(void){
char inbuff;
char _buff[BUFF_MAX];
while(buff_input(&inbuff,_buff)>0&&*_buff>' ');
long int num = 0;
char flagIsDec = 1;
{ // GetNum
int i = 0;
if(_buff[0]=='-'){i++;flagIsDec = -1;}
for(; i<inbuff;i++)
if(_buff[i]>= '0' && _buff[i] <= '9')
num = (num*10) + (_buff[i]-'0');
num *= flagIsDec;
}
if (num>INT_MAX)num = INT_MAX;
if (num<INT_MIN)num = INT_MIN;
return (int)num;
}
/*
void outputInt(int n){
}
void outputStr(char* str){
}*/ // Подрузамевалось подобный io но он это нецелесообразная трата времени
1Y-2H/prog/1Practice/var2/code/main.c
+118
View File
@@ -0,0 +1,118 @@
#include "head.h"
int main(void){
MATRIX2D** __matrixAddr = (MATRIX2D**)calloc(MAX_MATRIX_ALIVE,sizeof(MATRIX2D*));
if(__matrixAddr == NULL) {printf("ERROR.__matrixAddr NotExist");return 1;}
char mode;
do{
char inbuff;
char _buff[BUFF_MAX];
char n1,n2;
int num1,num2;
mode = buff_input(&inbuff,_buff);
{
switch(mode){
case 1:
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
input_matrix(__matrixAddr,n1);
break;
case 2: // output
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
get_matrix(__matrixAddr,n1);
break;
case 3: // logic
n1 = get_matrix_num();
n2 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
is_Matrix_Exist(__matrixAddr,n2);
logic_matrix(__matrixAddr,n1,n2);
break;
case 4: // edit
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
edit_matrix(__matrixAddr,n1);
break;
case 5: // random
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
matrix_random(__matrixAddr,n1);
break;
case 6: // copy
n1 = get_matrix_num();
n2 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
free_matrix(__matrixAddr,n2);
copy_matrix(__matrixAddr,n1,n2);
break;
case 7: // destroy
n1 = get_matrix_num();
free_matrix(__matrixAddr,n1);
break;
case 8: // get colum
n1 = get_matrix_num();
num1 = get_num();
is_Matrix_Exist(__matrixAddr,n1);
get_matrix_col(__matrixAddr,n1,num1);
break;
case 9: // get row
n1 = get_matrix_num();
num1 = get_num();
is_Matrix_Exist(__matrixAddr,n1);
get_matrix_row(__matrixAddr,n1,num1);
break;
case 10: // transp
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
transp_matrix(__matrixAddr,n1);
break;
case 11: // determ
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
printf("%lld",determ_matrix(__matrixAddr,n1));
break;
case 12: //obr
n1 = get_matrix_num();
is_Matrix_Exist(__matrixAddr,n1);
obr_matrix(__matrixAddr,n1);
break;
case 13:
n1 = get_matrix_num();
num1 = get_num();
num2 = get_num();
free_matrix(__matrixAddr,n1);
create_matrix(__matrixAddr,n1,num1,num2);
break;
case 15:
putchar('\n');
putchar('\n');
break;
case 0: // wrong input
break;
case -1: return 0;
}
}
}while(mode>=0);
return 0;
}
1Y-2H/prog/1Practice/var2/code/matrix.c
+374
View File
@@ -0,0 +1,374 @@
#include "head.h"
MATRIX2D* create_matrix2d(int rows,int cols) {
MATRIX2D* m = (MATRIX2D*)malloc(sizeof(MATRIX2D));
m->rows = rows;
m->cols = cols;
m->data = (int**)malloc(rows * sizeof(int*));
for (int i = 0; i < rows; i++){
m->data[i] = (int*)malloc(cols * sizeof(int));
}
return m;
}
void create_matrix(MATRIX2D** __addr,unsigned char n,int rows,int cols){
__addr[n] = create_matrix2d(rows,cols);
for (int i = 0;i<rows;i++){
for(int j = 0;j<cols;j++){
__addr[n]->data[i][j] = 0;
}
}
}
void input_matrix(MATRIX2D** __addr,unsigned char n){
int** data = __addr[n]->data;
for(int rows = 0; rows < __addr[n]->rows;rows++){
for(int cols = 0; cols < __addr[n]->cols;cols++){
int num = get_num();
data[rows][cols] = num;
}
}
}
void get_matrix(MATRIX2D** __addr,unsigned char n){
int rows = __addr[n]->rows;
int cols = __addr[n]->cols;
//printf("\tМассив №%d",n);
//printf("Колл-во строк %d\nКолл-во колон %d\n\n",rows,cols);
for(int r = 0;r<rows;r++){
for(int c = 0;c<cols;c++){
printf("%d ",__addr[n]->data[r][c]);
}
putchar('\n');
}
}
void logic_matrix(MATRIX2D** __addr,unsigned char n1,unsigned char n2){
char inbuff;
char _buff[BUFF_MAX];
int** data1 = __addr[n1]->data;
int** data2 = __addr[n2]->data;
char cmd = 0;
{
buff_input(&inbuff,_buff);
const char NUM_OF_CHAR_COMMANDS = 6;
char * _charCommands[NUM_OF_CHAR_COMMANDS]; // _charCommands[*]["char"]
_charCommands[0] = (char[]){"=="};
_charCommands[1] = (char[]){"!="};
_charCommands[2] = (char[]){">="};
_charCommands[3] = (char[]){"<="};
_charCommands[4] = (char[]){">"};
_charCommands[5] = (char[]){"<"};
cmd = cmd_buff(_buff,_charCommands,NUM_OF_CHAR_COMMANDS);
}
LLI cost1 = 0;
{
for(int r = 0;r<__addr[n1]->rows;r++)
for(int c = 0;c<__addr[n1]->cols;c++)
cost1 += data1[r][c];
}
LLI cost2 = 0;
{
for(int r = 0;r<__addr[n2]->rows;r++)
for(int c = 0;c<__addr[n2]->cols;c++)
cost2 += data2[r][c];
}
switch(cmd){
case 0: //Null
putchar('-');putchar('1');
break;
case 1: // ==
putchar(cost1==cost2?'1':'0');
break;
case 2: // !=
putchar(cost1!=cost2?'1':'0');
break;
case 3: //>=
putchar(cost1>=cost2?'1':'0');
break;
case 4: //<=
putchar(cost1<=cost2?'1':'0');
break;
case 5: // >
putchar(cost1>cost2?'1':'0');
break;
case 6: // <
putchar(cost1<cost2?'1':'0');
break;
}
}
void edit_matrix(MATRIX2D** __addr, unsigned char n) {
char inbuff;
char _buff[BUFF_MAX];
int** data = __addr[n]->data;
int r = 0, c = 0;
char mode = 0;
char* _locStrings[3];
_locStrings[0] = (char[]){"point"};
_locStrings[1] = (char[]){"add"};
_locStrings[2] = (char[]){"sub"};
while (r < __addr[n]->rows) {
char res = buff_input(&inbuff, _buff);
if (res == -1) break;
if (_buff[0] == 'n' && inbuff == 1) break;
char loc_cmd = cmd_buff(_buff, _locStrings, 3);
if (loc_cmd == 1) {
buff_input(&inbuff, _buff);
long pr = 0, pc = 0;
int i = 0;
for (; i < inbuff && (_buff[i] != ':' && _buff[i] != ',' && _buff[i] != '.'); i++)
if (_buff[i] >= '0' && _buff[i] <= '9') pr = pr * 10 + (_buff[i] - '0');
for (i++; i < inbuff; i++)
if (_buff[i] >= '0' && _buff[i] <= '9') pc = pc * 10 + (_buff[i] - '0');
if (pr < __addr[n]->rows && pc < __addr[n]->cols) {
r = (int)pr;
c = (int)pc;
}
continue;
}
if (loc_cmd == 2) { mode = 1; continue; }
if (loc_cmd == 3) { mode = 2; continue; }
long val = 0;
int i = 0, sign = 1;
if (inbuff > 0 && _buff[0] == '-') { sign = -1; i++; }
for (; i < inbuff; i++) {
if (_buff[i] >= '0' && _buff[i] <= '9')
val = val * 10 + (_buff[i] - '0');
}
val *= sign;
if (mode == 1) {
long res_val = (long)data[r][c] + val;
data[r][c] = (res_val > INT_MAX) ? INT_MAX : (res_val < INT_MIN) ? INT_MIN : (int)res_val;
} else if (mode == 2) {
long res_val = (long)data[r][c] - val;
data[r][c] = (res_val > INT_MAX) ? INT_MAX : (res_val < INT_MIN) ? INT_MIN : (int)res_val;
} else {
data[r][c] = (val > INT_MAX) ? INT_MAX : (val < INT_MIN) ? INT_MIN : (int)val;
}
if (++c >= __addr[n]->cols) {
c = 0;
r++;
}
}
}
int get_rand(int min, int max) {
return (double)rand() / (RAND_MAX + 1.0) * (max - min) + min;
}
void matrix_random(MATRIX2D** __addr,unsigned char n){
unsigned int lo, hi;
__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
srand(((unsigned long long)hi << 32) | lo);
for (int r = 0; r < __addr[n]->rows; r++){
for(int c = 0; c < __addr[n]->cols; c++){
__addr[n]->data[r][c] = get_rand(-100, 100);
}
}
}
void copy_matrix(MATRIX2D** __addr,unsigned char n1, unsigned char n2){
// n2 = n1
__addr[n2] = create_matrix2d(__addr[n1]->rows,__addr[n1]->cols);
for(int i = 0; i<__addr[n1]->rows;i++){
for(int j = 0; j<__addr[n1]->cols;j++){
__addr[n2]->data[i][j] = __addr[n1]->data[i][j];
}
}
}
void free_matrix(MATRIX2D** __addr,unsigned char n){
if (__addr[n] == NULL) return;
MATRIX2D* m = __addr[n];
for (int i = 0; i < m->rows; i++) {
free(m->data[i]);
}
free(m->data);
free(m);
__addr[n] = NULL;
}
void get_matrix_col(MATRIX2D** __addr,unsigned char n,int c){
//printf("colum %d - ",c);
if(c >= __addr[n]->cols)c = __addr[n]->cols - 1;
if(c<0)c = 0;
for(int i = 0;i<__addr[n]->rows;i++){
printf("%d ",__addr[n]->data[i][c]);
}
putchar('\n');
}
void get_matrix_row(MATRIX2D** __addr,unsigned char n,int r){
//printf("row %d - ",r);
if(r >= __addr[n]->rows)r = __addr[n]->rows - 1;
if(r<0)r = 0;
for(int i = 0;i<__addr[n]->cols;i++){
printf("%d ",__addr[n]->data[r][i]);
}
putchar('\n');
}
void transp_matrix(MATRIX2D** __addr,unsigned char n){
MATRIX2D* tr = create_matrix2d(
__addr[n]->cols,__addr[n]->rows);
int** dataDef = __addr[n]->data;
int** dataRes = tr->data;
for(int r = 0;r<__addr[n]->rows;r++)
for(int c = 0;c<__addr[n]->cols;c++)
dataRes[c][r] = dataDef[r][c];
free_matrix(__addr,n);
__addr[n] = tr;
}
LLI determ_matrix(MATRIX2D** __addr, unsigned char n) {
int size = __addr[n]->rows;
int** data = __addr[n]->data;
if (size == 1) return data[0][0];
if (size == 2) return (LLI)data[0][0] * data[1][1] - (LLI)data[0][1] * data[1][0];
double det = 1.0;
double** temp = (double**)malloc(size * sizeof(double*));
for (int i = 0; i < size; i++) {
temp[i] = (double*)malloc(size * sizeof(double));
for (int j = 0; j < size; j++) temp[i][j] = (double)data[i][j];
}
for (int i = 0; i < size; i++) {
int pivot = i;
for (int j = i + 1; j < size; j++) {
double val1 = temp[j][i] < 0 ? -temp[j][i] : temp[j][i];
double val2 = temp[pivot][i] < 0 ? -temp[pivot][i] : temp[pivot][i];
if (val1 > val2) pivot = j;
}
if (pivot != i) {
double* swap = temp[i];
temp[i] = temp[pivot];
temp[pivot] = swap;
det *= -1;
}
double current_val = temp[i][i] < 0 ? -temp[i][i] : temp[i][i];
if (current_val < 1e-9) {
for (int k = 0; k < size; k++) free(temp[k]);
free(temp);
return 0;
}
det *= temp[i][i];
for (int j = i + 1; j < size; j++) {
double factor = temp[j][i] / temp[i][i];
for (int k = i + 1; k < size; k++) {
temp[j][k] -= factor * temp[i][k];
}
}
}
LLI final_det;
if (det >= 0) final_det = (LLI)(det + 0.5);
else final_det = (LLI)(det - 0.5);
for (int i = 0; i < size; i++) free(temp[i]);
free(temp);
return final_det;
}
void obr_matrix(MATRIX2D** __addr, unsigned char n) {
int size = __addr[n]->rows;
if (size != __addr[n]->cols) return;
LLI d = determ_matrix(__addr, n);
if (d == 0) return;
double** temp = (double**)malloc(size * sizeof(double*));
for (int i = 0; i < size; i++) {
temp[i] = (double*)malloc(2 * size * sizeof(double));
for (int j = 0; j < size; j++) {
temp[i][j] = (double)__addr[n]->data[i][j];
temp[i][j + size] = (i == j ? 1.0 : 0.0);
}
}
for (int i = 0; i < size; i++) {
int pivot = i;
for (int j = i + 1; j < size; j++) {
double v1 = temp[j][i] < 0 ? -temp[j][i] : temp[j][i];
double v2 = temp[pivot][i] < 0 ? -temp[pivot][i] : temp[pivot][i];
if (v1 > v2) pivot = j;
}
double* row_ptr = temp[i];
temp[i] = temp[pivot];
temp[pivot] = row_ptr;
double divisor = temp[i][i];
for (int j = i; j < 2 * size; j++) {
temp[i][j] /= divisor;
}
for (int k = 0; k < size; k++) {
if (k != i) {
double factor = temp[k][i];
for (int j = i; j < 2 * size; j++) {
temp[k][j] -= factor * temp[i][j];
}
}
}
}
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
double val = temp[i][j + size];
if (val >= 0) __addr[n]->data[i][j] = (int)(val + 0.5);
else __addr[n]->data[i][j] = (int)(val - 0.5);
}
}
for (int i = 0; i < size; i++) free(temp[i]);
free(temp);
}
void is_Matrix_Exist(MATRIX2D** __addr,unsigned char n){
if(n > MAX_MATRIX_ALIVE) n = MAX_MATRIX_ALIVE-1;
if(__addr[n] == NULL){
//printf("Матрица №%d не существует, создана новая матрица 4x4\n",n);
__addr[n] = create_matrix2d(4,4);
matrix_random(__addr,n);
}
return;
}
1Y-2H/prog/1Practice/var2/docs.md
+111
View File
@@ -0,0 +1,111 @@
## Matrix
Когда вы запускаете програму она будет ожидать одну из следующих коммнад.
Ввод чисел будет проигнорирован но, адм символы приведут к завершению программы.
При вводе символов весь ввод является строкой.
Делителем строк являются - Space Enter EOT
Также каждый 10 символ - новая строка
При вводе, каждое запрашиваемое значение должно заканчиваться делителем
###### Пример:
create
0
10 20
getmatrix
exit
Номер матрицы ограничен их возможным колличеством установленным в header.h
По умолчанию = 20
Если вы пытаетесь манипулировать несуществующей матрицей
То будет создана матрица 4 X 4 со случайными значениями от -100 до 100
##
Далее будет описыватся только ожидаеммый ввод после команды.
Функцианал коммнады понятен из названия.
#### create
(Ожидается 3 числа)
номер-матрицы
коллво-строк
коллво-колон
#### input
(Ожидается 1 число)
номер-матрицы
(далее будет ввод матрицы X на Y необходимо ввести X\*Y значений)
int1 int2 int3 ... int(x\*y)
#### getmatrix
(Ожидается 1 число)
номер-матрицы
#### logic
(Ожидается 2 числа)
номер-матрицы1
номер-матрицы2
(Ожидается логическая операция > < >= <= != == )
Логическа-операция
#### edit
(Ожидается 1 число)
номер-матрицы
(Далее принимает X\*Y чисел и заменяет предыдущие)
(Так же может принять 3 буквенных выражения,
add - все последующие введёные числа будут добавлены к имеющимся
sub - от всех имеющихся чисел будут отняты последующие введёные
point - указать на точку в массиве начиная с которой продолжить заполнение, row:col для разделения могут использоваться , . :)
#### random
(Ожидается 1 число)
номер-матрицы
#### copy
(Ожидается 2 числа)
номер-матрицы-откуда-копировать
номер-матрицы-куда-копировать
#### destruct
(Ожидается 1 число)
номер-матрицы
#### getcolum
(Ожидается 2 числа)
номер-матрицы
номер-столбца
#### getrow
(Ожидается 2 числа)
номер-матрицы
номер-строки
#### transp
(Ожидается 1 число)
номер-матрицы
#### determ
(Ожидается 1 число)
номер-матрицы
#### obr
(Ожидается 1 число)
номер-матрицы
#### exit
1Y-2H/prog/1Practice/var2/run/input
+38
View File
@@ -0,0 +1,38 @@
create 0 3 3
input 0
1 2 3
4 5 6
7 8 9
getmatrix 0
n n
transp 0
getmatrix 0
n n
create 1 3 3
random 1
getmatrix 1
n
logic 0 1 >= n
logic 0 0 == n
edit 0
add
1 1 1
1 1 1
1 1 1
getmatrix 0
n
edit 0
point 1:1
sub
10 10
getmatrix 0
n
getcolum 0 1
getrow 0 2
n
copy 0 5
getmatrix 5
n
determ 5
destruct 5
exit
1Y-2H/prog/1Practice/var2/run/makefile
+28
View File
@@ -0,0 +1,28 @@
CC = gcc
CFLAGS = -Wall -Wextra -I../ -g
TARGET = matrix
SRC_DIR = ../code
OBJ_DIR = ../.o
SRCS = $(wildcard $(SRC_DIR)/*.c)
OBJS = $(patsubst $(SRC_DIR)/%.c, $(OBJ_DIR)/%.o, $(SRCS))
.PHONY: all clean run
all: $(TARGET)
$(TARGET): $(OBJS)
$(CC) $(CFLAGS) $(OBJS) -o $(TARGET)
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
@mkdir -p $(OBJ_DIR)
$(CC) $(CFLAGS) -c $< -o $@
run: $(TARGET)
./$(TARGET) < input > output
@cat output
clean:
rm -rf $(OBJ_DIR) $(TARGET) output
1Y-2H/prog/1Practice/var2/run/matrix
Executable
BIN
View File
Binary file not shown.