From c53ba677c0b2d76e1797d39f5bce920591ef93c4 Mon Sep 17 00:00:00 2001
From: superhakeroftheworld
 <32217428+superhakeroftheworld@users.noreply.github.com>
Date: Thu, 13 Dec 2018 22:25:40 +0300
Subject: [PATCH 1/6] Add files via upload

---
 system.java | 155 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 155 insertions(+)
 create mode 100644 system.java

diff --git a/system.java b/system.java
new file mode 100644
index 0000000..4b50aab
--- /dev/null
+++ b/system.java
@@ -0,0 +1,155 @@
+/**
+я тут еще не допилил считывание с файла (и считывание В файл ответов) 
+и не допилил текстовый вид преобразований над строками
+но хотел бы отправить, т.к. понимаю что мой код совершенно ужасен, я уже в нем немного путаюсь
+
+*/
+import java.util.*;
+
+public class system {
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		int n = in.nextInt();
+		double[] line = new double[n + 1];
+/*
+Я не уверен, правильно ли я передаю параметры.
+Т.е. у меня есть класс Row, сначала я хотел зашить получение всей информации 
+о строке внутрь конструктора Row, но проблема, с которой я столкнулся:
+dimension mismatch.
+т.е. мне нужно было в классе Row как-то сделать массив даблов,
+и как-то подгадать его размерность, но размерность я сразу не мог установить
+в итоге получился такой (костыль?), что я в main считываю строку, а потом
+уже полученную строку отправляю в конструктор Row.
+В таком случае, вероятно, мне не нужно передавать параметр N, но я решил
+его пока оставить, не знаю зачем.
+P.s. как минимум мне нужен параметр N для copyOf, в джаве, оказывается, arr1 = arr2 - приравнивание ссылок
+*/		
+		Row[] row = new Row[n];
+		for (int j = 0; j < n; j++) 
+		{	
+			for (int i = 0; i <= n; i++){line[i] = in.nextDouble();}
+			row[j] = new Row(n, line);
+		}
+		Matrix matrix = new Matrix(row, n);
+		System.out.println(matrix.getString());
+		matrix.diagonalizable();
+		System.out.println(matrix.getString());
+	}
+}
+/*
+Я думаю, класс Row (по крайней мере в моей реализации) тут излишен и можно было хранить все
+в массива даблов, но я его написал для набивания руки
+*/
+class Row { // N на 1 больше, чем вход, т.к. тут я учитываю и ответ (то, что справа от равно)
+	int N;
+	double[] line = new double[N];
+	public Row(int N, double[] row) {
+		this.line = Arrays.copyOf(row, N + 1);
+		this.N = N;
+	}
+
+	double getValue(int i) {
+		return this.line[i];
+	}
+
+	void add(Row other) { //поидее можно сделать private?
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] += other.line[i];
+		}
+	}
+	void mul(double num) { //умножение строки на константу
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] = this.line[i] * num;
+		}
+	}
+
+	String getString() {
+		return Arrays.toString(this.line);
+	}
+}
+
+class Matrix {
+/*
+это очередным грабли (с инт Н), т.к. у меня не получилось найти длину массива Row, то я передавал длину из мэина,
+не уверен, что это хорошая практика
+*/
+	int N;
+	Row[] rows = new Row[1];
+	public Matrix(Row[] row, int n) {
+		this.rows = row;
+		this.N = n;
+	}
+
+	boolean checkValue(int i, int j) { // true - значит этот элемент не 0; j строка i столбец 
+		return (this.rows[j].getValue(i) == 0 ? false: true);
+	}
+
+	void diagonalizable() {	
+		this.diagonalizable_down();
+		this.diagonalizable_up();
+	}
+
+	void diagonalizable_down() {
+		for (int i = 0; i < this.N; i++) { 
+			if(!this.checkValue(i, i)) { 
+				for (int k = (i < this.N - 1) ? i + 1: this.N; k < this.N; k++) {
+					if (this.checkValue(i, k)) {
+						this.swap(i, k); 
+					}
+				}
+			}
+			else {
+				double coef = this.rows[i].getValue(i);
+				this.rows[i].mul(1 / coef);
+				for (int j = (i < this.N - 1) ? i + 1: this.N; j < this.N; j++) {
+					coef = (-1) * this.rows[j].getValue(i);
+					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
+					this.rows[i].mul(coef);
+					this.rows[j].add(this.rows[i]);
+					this.rows[i].mul(1 / coef);
+				}
+				
+			}
+		}
+	}
+
+	void diagonalizable_up() {
+		for (int i = this.N - 1; i >= 0; i--) {
+			if(!this.checkValue(i, i)) {
+				for (int k = (i > 0) ? i - 1: -1; k >= 0; k--) {
+					if (this.checkValue(i, k)) {
+						this.swap(i, k);
+					}
+				}
+			}
+			else {
+				double coef = this.rows[i].getValue(i);
+				this.rows[i].mul(1 / coef);
+				for (int j = (i > 0) ? i - 1: -1; j >= 0; j--) {
+					coef = (-1) * this.rows[j].getValue(i);
+					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
+					this.rows[i].mul(coef);
+					this.rows[j].add(this.rows[i]);
+					this.rows[i].mul(1 / coef);
+				}
+			}
+		}
+	}
+/*
+тут свап работает так, как бы я этого хотел, но не так, как я думаю, что он должен работать ((
+т.е. когда я пробовал так манипулировать с arrays, я увидел, что массивы записываются по ссылке
+а тут происходит что-то в стиле arr1.copyOf(arr2), не совсем понимаю почему так
+*/
+	void swap(int i, int j) { 
+		Row row = this.rows[i];
+		this.rows[i] = this.rows[j];
+		this.rows[j] = row;
+	}
+	String getString() {
+		String s = "";
+		for (int i = 0; i < this.N; i++) {
+			s += this.rows[i].getString();
+		}
+		return s;
+	}
+}

From 31665855da56921efd0d643e87f4212739f29c81 Mon Sep 17 00:00:00 2001
From: superhakeroftheworld
 <32217428+superhakeroftheworld@users.noreply.github.com>
Date: Thu, 13 Dec 2018 22:26:56 +0300
Subject: [PATCH 2/6] Update Main.java

---
 src/solver/Main.java | 157 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 153 insertions(+), 4 deletions(-)

diff --git a/src/solver/Main.java b/src/solver/Main.java
index 4404714..322c392 100644
--- a/src/solver/Main.java
+++ b/src/solver/Main.java
@@ -1,7 +1,156 @@
+/**
+я тут еще не допилил считывание с файла (и считывание В файл ответов) 
+и не допилил текстовый вид преобразований над строками
+но хотел бы отправить, т.к. понимаю что мой код совершенно ужасен, я уже в нем немного путаюсь
+
+*/
 package solver;
+import java.util.*;
 
 public class Main {
-    public static void main(String[] args) {
-        System.out.print("Hello world!");
-    }
-}
\ No newline at end of file
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		int n = in.nextInt();
+		double[] line = new double[n + 1];
+/*
+Я не уверен, правильно ли я передаю параметры.
+Т.е. у меня есть класс Row, сначала я хотел зашить получение всей информации 
+о строке внутрь конструктора Row, но проблема, с которой я столкнулся:
+dimension mismatch.
+т.е. мне нужно было в классе Row как-то сделать массив даблов,
+и как-то подгадать его размерность, но размерность я сразу не мог установить
+в итоге получился такой (костыль?), что я в main считываю строку, а потом
+уже полученную строку отправляю в конструктор Row.
+В таком случае, вероятно, мне не нужно передавать параметр N, но я решил
+его пока оставить, не знаю зачем.
+P.s. как минимум мне нужен параметр N для copyOf, в джаве, оказывается, arr1 = arr2 - приравнивание ссылок
+*/		
+		Row[] row = new Row[n];
+		for (int j = 0; j < n; j++) 
+		{	
+			for (int i = 0; i <= n; i++){line[i] = in.nextDouble();}
+			row[j] = new Row(n, line);
+		}
+		Matrix matrix = new Matrix(row, n);
+		System.out.println(matrix.getString());
+		matrix.diagonalizable();
+		System.out.println(matrix.getString());
+	}
+}
+/*
+Я думаю, класс Row (по крайней мере в моей реализации) тут излишен и можно было хранить все
+в массива даблов, но я его написал для набивания руки
+*/
+class Row { // N на 1 больше, чем вход, т.к. тут я учитываю и ответ (то, что справа от равно)
+	int N;
+	double[] line = new double[N];
+	public Row(int N, double[] row) {
+		this.line = Arrays.copyOf(row, N + 1);
+		this.N = N;
+	}
+
+	double getValue(int i) {
+		return this.line[i];
+	}
+
+	void add(Row other) { //поидее можно сделать private?
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] += other.line[i];
+		}
+	}
+	void mul(double num) { //умножение строки на константу
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] = this.line[i] * num;
+		}
+	}
+
+	String getString() {
+		return Arrays.toString(this.line);
+	}
+}
+
+class Matrix {
+/*
+это очередным грабли (с инт Н), т.к. у меня не получилось найти длину массива Row, то я передавал длину из мэина,
+не уверен, что это хорошая практика
+*/
+	int N;
+	Row[] rows = new Row[1];
+	public Matrix(Row[] row, int n) {
+		this.rows = row;
+		this.N = n;
+	}
+
+	boolean checkValue(int i, int j) { // true - значит этот элемент не 0; j строка i столбец 
+		return (this.rows[j].getValue(i) == 0 ? false: true);
+	}
+
+	void diagonalizable() {	
+		this.diagonalizable_down();
+		this.diagonalizable_up();
+	}
+
+	void diagonalizable_down() {
+		for (int i = 0; i < this.N; i++) { 
+			if(!this.checkValue(i, i)) { 
+				for (int k = (i < this.N - 1) ? i + 1: this.N; k < this.N; k++) {
+					if (this.checkValue(i, k)) {
+						this.swap(i, k); 
+					}
+				}
+			}
+			else {
+				double coef = this.rows[i].getValue(i);
+				this.rows[i].mul(1 / coef);
+				for (int j = (i < this.N - 1) ? i + 1: this.N; j < this.N; j++) {
+					coef = (-1) * this.rows[j].getValue(i);
+					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
+					this.rows[i].mul(coef);
+					this.rows[j].add(this.rows[i]);
+					this.rows[i].mul(1 / coef);
+				}
+				
+			}
+		}
+	}
+
+	void diagonalizable_up() {
+		for (int i = this.N - 1; i >= 0; i--) {
+			if(!this.checkValue(i, i)) {
+				for (int k = (i > 0) ? i - 1: -1; k >= 0; k--) {
+					if (this.checkValue(i, k)) {
+						this.swap(i, k);
+					}
+				}
+			}
+			else {
+				double coef = this.rows[i].getValue(i);
+				this.rows[i].mul(1 / coef);
+				for (int j = (i > 0) ? i - 1: -1; j >= 0; j--) {
+					coef = (-1) * this.rows[j].getValue(i);
+					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
+					this.rows[i].mul(coef);
+					this.rows[j].add(this.rows[i]);
+					this.rows[i].mul(1 / coef);
+				}
+			}
+		}
+	}
+/*
+тут свап работает так, как бы я этого хотел, но не так, как я думаю, что он должен работать ((
+т.е. когда я пробовал так манипулировать с arrays, я увидел, что массивы записываются по ссылке
+а тут происходит что-то в стиле arr1.copyOf(arr2), не совсем понимаю почему так
+*/
+	void swap(int i, int j) { 
+		Row row = this.rows[i];
+		this.rows[i] = this.rows[j];
+		this.rows[j] = row;
+	}
+	String getString() {
+		String s = "";
+		for (int i = 0; i < this.N; i++) {
+			s += this.rows[i].getString();
+		}
+		return s;
+	}
+}

From 1f7fd5c9ac0f67e83eda56bcfcebc48fc973e42d Mon Sep 17 00:00:00 2001
From: superhakeroftheworld
 <32217428+superhakeroftheworld@users.noreply.github.com>
Date: Fri, 14 Dec 2018 12:10:14 +0300
Subject: [PATCH 3/6] Delete system.java

---
 system.java | 155 ----------------------------------------------------
 1 file changed, 155 deletions(-)
 delete mode 100644 system.java

diff --git a/system.java b/system.java
deleted file mode 100644
index 4b50aab..0000000
--- a/system.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/**
-я тут еще не допилил считывание с файла (и считывание В файл ответов) 
-и не допилил текстовый вид преобразований над строками
-но хотел бы отправить, т.к. понимаю что мой код совершенно ужасен, я уже в нем немного путаюсь
-
-*/
-import java.util.*;
-
-public class system {
-	public static void main(String[] args) {
-		Scanner in = new Scanner(System.in);
-		int n = in.nextInt();
-		double[] line = new double[n + 1];
-/*
-Я не уверен, правильно ли я передаю параметры.
-Т.е. у меня есть класс Row, сначала я хотел зашить получение всей информации 
-о строке внутрь конструктора Row, но проблема, с которой я столкнулся:
-dimension mismatch.
-т.е. мне нужно было в классе Row как-то сделать массив даблов,
-и как-то подгадать его размерность, но размерность я сразу не мог установить
-в итоге получился такой (костыль?), что я в main считываю строку, а потом
-уже полученную строку отправляю в конструктор Row.
-В таком случае, вероятно, мне не нужно передавать параметр N, но я решил
-его пока оставить, не знаю зачем.
-P.s. как минимум мне нужен параметр N для copyOf, в джаве, оказывается, arr1 = arr2 - приравнивание ссылок
-*/		
-		Row[] row = new Row[n];
-		for (int j = 0; j < n; j++) 
-		{	
-			for (int i = 0; i <= n; i++){line[i] = in.nextDouble();}
-			row[j] = new Row(n, line);
-		}
-		Matrix matrix = new Matrix(row, n);
-		System.out.println(matrix.getString());
-		matrix.diagonalizable();
-		System.out.println(matrix.getString());
-	}
-}
-/*
-Я думаю, класс Row (по крайней мере в моей реализации) тут излишен и можно было хранить все
-в массива даблов, но я его написал для набивания руки
-*/
-class Row { // N на 1 больше, чем вход, т.к. тут я учитываю и ответ (то, что справа от равно)
-	int N;
-	double[] line = new double[N];
-	public Row(int N, double[] row) {
-		this.line = Arrays.copyOf(row, N + 1);
-		this.N = N;
-	}
-
-	double getValue(int i) {
-		return this.line[i];
-	}
-
-	void add(Row other) { //поидее можно сделать private?
-		for (int i = 0; i <= this.N; i++) {
-			this.line[i] += other.line[i];
-		}
-	}
-	void mul(double num) { //умножение строки на константу
-		for (int i = 0; i <= this.N; i++) {
-			this.line[i] = this.line[i] * num;
-		}
-	}
-
-	String getString() {
-		return Arrays.toString(this.line);
-	}
-}
-
-class Matrix {
-/*
-это очередным грабли (с инт Н), т.к. у меня не получилось найти длину массива Row, то я передавал длину из мэина,
-не уверен, что это хорошая практика
-*/
-	int N;
-	Row[] rows = new Row[1];
-	public Matrix(Row[] row, int n) {
-		this.rows = row;
-		this.N = n;
-	}
-
-	boolean checkValue(int i, int j) { // true - значит этот элемент не 0; j строка i столбец 
-		return (this.rows[j].getValue(i) == 0 ? false: true);
-	}
-
-	void diagonalizable() {	
-		this.diagonalizable_down();
-		this.diagonalizable_up();
-	}
-
-	void diagonalizable_down() {
-		for (int i = 0; i < this.N; i++) { 
-			if(!this.checkValue(i, i)) { 
-				for (int k = (i < this.N - 1) ? i + 1: this.N; k < this.N; k++) {
-					if (this.checkValue(i, k)) {
-						this.swap(i, k); 
-					}
-				}
-			}
-			else {
-				double coef = this.rows[i].getValue(i);
-				this.rows[i].mul(1 / coef);
-				for (int j = (i < this.N - 1) ? i + 1: this.N; j < this.N; j++) {
-					coef = (-1) * this.rows[j].getValue(i);
-					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
-					this.rows[i].mul(coef);
-					this.rows[j].add(this.rows[i]);
-					this.rows[i].mul(1 / coef);
-				}
-				
-			}
-		}
-	}
-
-	void diagonalizable_up() {
-		for (int i = this.N - 1; i >= 0; i--) {
-			if(!this.checkValue(i, i)) {
-				for (int k = (i > 0) ? i - 1: -1; k >= 0; k--) {
-					if (this.checkValue(i, k)) {
-						this.swap(i, k);
-					}
-				}
-			}
-			else {
-				double coef = this.rows[i].getValue(i);
-				this.rows[i].mul(1 / coef);
-				for (int j = (i > 0) ? i - 1: -1; j >= 0; j--) {
-					coef = (-1) * this.rows[j].getValue(i);
-					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
-					this.rows[i].mul(coef);
-					this.rows[j].add(this.rows[i]);
-					this.rows[i].mul(1 / coef);
-				}
-			}
-		}
-	}
-/*
-тут свап работает так, как бы я этого хотел, но не так, как я думаю, что он должен работать ((
-т.е. когда я пробовал так манипулировать с arrays, я увидел, что массивы записываются по ссылке
-а тут происходит что-то в стиле arr1.copyOf(arr2), не совсем понимаю почему так
-*/
-	void swap(int i, int j) { 
-		Row row = this.rows[i];
-		this.rows[i] = this.rows[j];
-		this.rows[j] = row;
-	}
-	String getString() {
-		String s = "";
-		for (int i = 0; i < this.N; i++) {
-			s += this.rows[i].getString();
-		}
-		return s;
-	}
-}

From f317f77de4820ea652a0450515ec7ad3406c17e0 Mon Sep 17 00:00:00 2001
From: superhakeroftheworld
 <32217428+superhakeroftheworld@users.noreply.github.com>
Date: Thu, 20 Dec 2018 01:13:44 +0300
Subject: [PATCH 4/6] Update Main.java

---
 src/solver/Main.java | 217 +++++++++++++++++++++++++------------------
 1 file changed, 129 insertions(+), 88 deletions(-)

diff --git a/src/solver/Main.java b/src/solver/Main.java
index 322c392..54b44bf 100644
--- a/src/solver/Main.java
+++ b/src/solver/Main.java
@@ -1,48 +1,36 @@
+import java.util.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
 /**
-я тут еще не допилил считывание с файла (и считывание В файл ответов) 
-и не допилил текстовый вид преобразований над строками
-но хотел бы отправить, т.к. понимаю что мой код совершенно ужасен, я уже в нем немного путаюсь
-
+i - неизвестная, j - уравнение
 */
-package solver;
-import java.util.*;
-
-public class Main {
+public class fourth {
 	public static void main(String[] args) {
-		Scanner in = new Scanner(System.in);
-		int n = in.nextInt();
-		double[] line = new double[n + 1];
-/*
-Я не уверен, правильно ли я передаю параметры.
-Т.е. у меня есть класс Row, сначала я хотел зашить получение всей информации 
-о строке внутрь конструктора Row, но проблема, с которой я столкнулся:
-dimension mismatch.
-т.е. мне нужно было в классе Row как-то сделать массив даблов,
-и как-то подгадать его размерность, но размерность я сразу не мог установить
-в итоге получился такой (костыль?), что я в main считываю строку, а потом
-уже полученную строку отправляю в конструктор Row.
-В таком случае, вероятно, мне не нужно передавать параметр N, но я решил
-его пока оставить, не знаю зачем.
-P.s. как минимум мне нужен параметр N для copyOf, в джаве, оказывается, arr1 = arr2 - приравнивание ссылок
-*/		
-		Row[] row = new Row[n];
-		for (int j = 0; j < n; j++) 
-		{	
-			for (int i = 0; i <= n; i++){line[i] = in.nextDouble();}
-			row[j] = new Row(n, line);
+		File file = new File("in.txt");
+		try(Scanner scanner = new Scanner(file)) {
+			int n = scanner.nextInt();
+			int m = scanner.nextInt();
+			// n - число неизвестных, m - число уравнений
+			double[] line = new double[n + 1];
+			Row[] row = new Row[m];
+			for (int j = 0; j < m; j++) 
+			{	
+				for (int i = 0; i <= n; i++){line[i] = scanner.nextDouble();}
+				row[j] = new Row(n, line);
+			}
+			Matrix matrix = new Matrix(row, n, m);
+			matrix.steppedViewDown();
+		} catch (FileNotFoundException e) {
+			System.out.println("I hope that never happen");
 		}
-		Matrix matrix = new Matrix(row, n);
-		System.out.println(matrix.getString());
-		matrix.diagonalizable();
-		System.out.println(matrix.getString());
 	}
 }
-/*
-Я думаю, класс Row (по крайней мере в моей реализации) тут излишен и можно было хранить все
-в массива даблов, но я его написал для набивания руки
-*/
-class Row { // N на 1 больше, чем вход, т.к. тут я учитываю и ответ (то, что справа от равно)
+
+class Row {
 	int N;
+	// N - число неизвестных
 	double[] line = new double[N];
 	public Row(int N, double[] row) {
 		this.line = Arrays.copyOf(row, N + 1);
@@ -53,12 +41,12 @@ public Row(int N, double[] row) {
 		return this.line[i];
 	}
 
-	void add(Row other) { //поидее можно сделать private?
+	void add(Row other) {
 		for (int i = 0; i <= this.N; i++) {
 			this.line[i] += other.line[i];
 		}
 	}
-	void mul(double num) { //умножение строки на константу
+	void mul(double num) {
 		for (int i = 0; i <= this.N; i++) {
 			this.line[i] = this.line[i] * num;
 		}
@@ -70,77 +58,120 @@ String getString() {
 }
 
 class Matrix {
-/*
-это очередным грабли (с инт Н), т.к. у меня не получилось найти длину массива Row, то я передавал длину из мэина,
-не уверен, что это хорошая практика
-*/
 	int N;
+	int M;
 	Row[] rows = new Row[1];
-	public Matrix(Row[] row, int n) {
+	public Matrix(Row[] row, int n, int m) {
 		this.rows = row;
 		this.N = n;
+		this.M = m;
 	}
-
-	boolean checkValue(int i, int j) { // true - значит этот элемент не 0; j строка i столбец 
+// true - ненулевое
+	boolean checkValue(int i, int j) {  
 		return (this.rows[j].getValue(i) == 0 ? false: true);
 	}
 
-	void diagonalizable() {	
-		this.diagonalizable_down();
-		this.diagonalizable_up();
-	}
 
-	void diagonalizable_down() {
-		for (int i = 0; i < this.N; i++) { 
-			if(!this.checkValue(i, i)) { 
-				for (int k = (i < this.N - 1) ? i + 1: this.N; k < this.N; k++) {
-					if (this.checkValue(i, k)) {
-						this.swap(i, k); 
-					}
-				}
+	String resetAllDown(int i, int j) {
+		String s = "";
+		double coef = this.rows[j].getValue(i);		
+		this.rows[j].mul(1 / coef);
+		s = (1 / coef) +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
+		for (int k = j + 1; k < this.M; k++) {
+			coef = this.rows[k].getValue(i);
+			if (coef != 0) {
+				this.rows[k].mul( (-1) / coef);
+				this.rows[k].add(this.rows[j]);
+				s = s + (-1) / coef + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
 			}
-			else {
-				double coef = this.rows[i].getValue(i);
-				this.rows[i].mul(1 / coef);
-				for (int j = (i < this.N - 1) ? i + 1: this.N; j < this.N; j++) {
-					coef = (-1) * this.rows[j].getValue(i);
-					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
-					this.rows[i].mul(coef);
-					this.rows[j].add(this.rows[i]);
-					this.rows[i].mul(1 / coef);
-				}
-				
+		}
+		return s;
+	}
+
+	String resetAllUp(int i, int j) {
+		String s = "";
+		double coef = this.rows[j].getValue(i);
+		this.rows[j].mul(1 / coef);
+		s = (1 / coef) +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
+		for (int k = j - 1; k >= 0; k--) {
+			coef = this.rows[k].getValue(i);
+			if (coef != 0) {
+				this.rows[k].mul( (-1) / coef);
+				this.rows[k].add(this.rows[j]); 
+				s = s + (-1) / coef + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
 			}
 		}
+		return s;
 	}
 
-	void diagonalizable_up() {
-		for (int i = this.N - 1; i >= 0; i--) {
-			if(!this.checkValue(i, i)) {
-				for (int k = (i > 0) ? i - 1: -1; k >= 0; k--) {
+	void steppedViewDown () {
+		int j = 0;
+		int i = 0;
+		String s = "";
+		s += "start solving the equation\n";
+		s += "Rows manipulation\n";
+		for (; i <= this.N && j < this.M; i++) {
+			if (this.checkValue(i, j)) {
+				s += this.resetAllDown(i, j);
+				j += 1;
+			}
+			else { //пробегаю вниз. Если есть ненулевой - свапаю, если нет - перехожу к след i и j;
+				for (int k = j + 1; k < this.M; k++) {
 					if (this.checkValue(i, k)) {
 						this.swap(i, k);
+						s = s + "Swap R" + (i + 1) + " with R" + (k + 1) + "\n";
 					}
 				}
+				if (!this.checkValue(i, j)) {
+					i += 1;
+				}
+				i -= 1;
+			}
+		}
+
+		if (j == 0) {
+			s += "infinity solutions\n";
+		}
+
+		else {
+			if (!this.checkNonzero(0, j - 1)) {
+				s += "no solutions\n";
 			}
 			else {
-				double coef = this.rows[i].getValue(i);
-				this.rows[i].mul(1 / coef);
-				for (int j = (i > 0) ? i - 1: -1; j >= 0; j--) {
-					coef = (-1) * this.rows[j].getValue(i);
-					//тут самое худшее место, но я не знаю как переписать лучше, сначала решу, а потом оптимизирую
-					this.rows[i].mul(coef);
-					this.rows[j].add(this.rows[i]);
-					this.rows[i].mul(1 / coef);
+				if (j != this.N) {
+					s += "infinity solutions\n";
+				}
+				else {
+					s += this.steppedViewUp();
 				}
 			}
 		}
+		File file = new File("out.txt");
+		try (FileWriter writer = new FileWriter(file)) {
+			writer.write(s);
+		} catch (IOException e) {
+			System.out.printf("Exception");
+		}
 	}
-/*
-тут свап работает так, как бы я этого хотел, но не так, как я думаю, что он должен работать ((
-т.е. когда я пробовал так манипулировать с arrays, я увидел, что массивы записываются по ссылке
-а тут происходит что-то в стиле arr1.copyOf(arr2), не совсем понимаю почему так
-*/
+
+	String steppedViewUp () {
+		String s = "";
+		for (int j = this.N - 1; j > 0; j--) {
+			s += this.resetAllUp(j, j);
+		}
+		s += this.solve();
+		return s;
+	}
+// true - есть ненулевой элемент помимо ответа
+	boolean checkNonzero(int i, int j) {
+		if (i < this.N - 1) {
+			return (this.checkNonzero(i + 1, j) || this.checkValue(i, j));
+		}
+		else {
+			return this.checkValue(i, j);
+		}
+	}
+
 	void swap(int i, int j) { 
 		Row row = this.rows[i];
 		this.rows[i] = this.rows[j];
@@ -148,9 +179,19 @@ void swap(int i, int j) {
 	}
 	String getString() {
 		String s = "";
-		for (int i = 0; i < this.N; i++) {
+		for (int i = 0; i < this.M; i++) {
 			s += this.rows[i].getString();
 		}
 		return s;
 	}
+	String solve () {
+		String s = "";
+		s += "The solution is: (";
+		for (int i = 0; i < this.N - 1; i++) {
+			s = s + this.rows[i].getValue(this.N) + ", ";
+		}
+		s = s + this.rows[this.N - 1].getValue(this.N) + ")\n";
+		return s;
+	}
+
 }

From d2b05b2baf8c079382bf7e376083c93ab2270b75 Mon Sep 17 00:00:00 2001
From: superhakeroftheworld
 <32217428+superhakeroftheworld@users.noreply.github.com>
Date: Thu, 20 Dec 2018 23:33:18 +0300
Subject: [PATCH 5/6] Update Main.java

---
 src/solver/Main.java | 207 ++++++-------------------------------------
 1 file changed, 25 insertions(+), 182 deletions(-)

diff --git a/src/solver/Main.java b/src/solver/Main.java
index 54b44bf..d17393b 100644
--- a/src/solver/Main.java
+++ b/src/solver/Main.java
@@ -1,197 +1,40 @@
+import java.util.Scanner;
+import java.util.Arrays;
 import java.util.*;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileWriter;
 import java.io.IOException;
-/**
-i - неизвестная, j - уравнение
-*/
-public class fourth {
-	public static void main(String[] args) {
-		File file = new File("in.txt");
-		try(Scanner scanner = new Scanner(file)) {
-			int n = scanner.nextInt();
-			int m = scanner.nextInt();
-			// n - число неизвестных, m - число уравнений
-			double[] line = new double[n + 1];
-			Row[] row = new Row[m];
-			for (int j = 0; j < m; j++) 
-			{	
-				for (int i = 0; i <= n; i++){line[i] = scanner.nextDouble();}
-				row[j] = new Row(n, line);
-			}
-			Matrix matrix = new Matrix(row, n, m);
-			matrix.steppedViewDown();
-		} catch (FileNotFoundException e) {
-			System.out.println("I hope that never happen");
-		}
-	}
-}
-
-class Row {
-	int N;
-	// N - число неизвестных
-	double[] line = new double[N];
-	public Row(int N, double[] row) {
-		this.line = Arrays.copyOf(row, N + 1);
-		this.N = N;
-	}
-
-	double getValue(int i) {
-		return this.line[i];
-	}
-
-	void add(Row other) {
-		for (int i = 0; i <= this.N; i++) {
-			this.line[i] += other.line[i];
-		}
-	}
-	void mul(double num) {
-		for (int i = 0; i <= this.N; i++) {
-			this.line[i] = this.line[i] * num;
-		}
-	}
 
-	String getString() {
-		return Arrays.toString(this.line);
-	}
-}
-
-class Matrix {
-	int N;
-	int M;
-	Row[] rows = new Row[1];
-	public Matrix(Row[] row, int n, int m) {
-		this.rows = row;
-		this.N = n;
-		this.M = m;
-	}
-// true - ненулевое
-	boolean checkValue(int i, int j) {  
-		return (this.rows[j].getValue(i) == 0 ? false: true);
-	}
-
-
-	String resetAllDown(int i, int j) {
-		String s = "";
-		double coef = this.rows[j].getValue(i);		
-		this.rows[j].mul(1 / coef);
-		s = (1 / coef) +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
-		for (int k = j + 1; k < this.M; k++) {
-			coef = this.rows[k].getValue(i);
-			if (coef != 0) {
-				this.rows[k].mul( (-1) / coef);
-				this.rows[k].add(this.rows[j]);
-				s = s + (-1) / coef + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
-			}
-		}
-		return s;
-	}
-
-	String resetAllUp(int i, int j) {
-		String s = "";
-		double coef = this.rows[j].getValue(i);
-		this.rows[j].mul(1 / coef);
-		s = (1 / coef) +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
-		for (int k = j - 1; k >= 0; k--) {
-			coef = this.rows[k].getValue(i);
-			if (coef != 0) {
-				this.rows[k].mul( (-1) / coef);
-				this.rows[k].add(this.rows[j]); 
-				s = s + (-1) / coef + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
-			}
-		}
-		return s;
-	}
-
-	void steppedViewDown () {
-		int j = 0;
-		int i = 0;
+public class Main {
+	public static void main(String[] args) {
+	
+	makeGood maker = new makeGood();
+
+	File file = new File("in.txt");
+	try(Scanner scanner = new Scanner(file)) {
+		int n = scanner.nextInt();
+		int m = scanner.nextInt();
+		// n - число неизвестных (без ответа), m - число уравнений
+		ComplexNumber[] line = new ComplexNumber[n + 1];
+		Row[] row = new Row[m];
 		String s = "";
-		s += "start solving the equation\n";
-		s += "Rows manipulation\n";
-		for (; i <= this.N && j < this.M; i++) {
-			if (this.checkValue(i, j)) {
-				s += this.resetAllDown(i, j);
-				j += 1;
-			}
-			else { //пробегаю вниз. Если есть ненулевой - свапаю, если нет - перехожу к след i и j;
-				for (int k = j + 1; k < this.M; k++) {
-					if (this.checkValue(i, k)) {
-						this.swap(i, k);
-						s = s + "Swap R" + (i + 1) + " with R" + (k + 1) + "\n";
-					}
-				}
-				if (!this.checkValue(i, j)) {
-					i += 1;
-				}
-				i -= 1;
+		for (int j = 0; j < m; j++) 
+		{	
+			for (int i = 0; i <= n; i++){
+				s = scanner.next();
+				line[i] = maker.stringToComplex(s);
 			}
+			row[j] = new Row(n, line);
 		}
+		Matrix matrix = new Matrix(row, n, m);
 
-		if (j == 0) {
-			s += "infinity solutions\n";
-		}
-
-		else {
-			if (!this.checkNonzero(0, j - 1)) {
-				s += "no solutions\n";
-			}
-			else {
-				if (j != this.N) {
-					s += "infinity solutions\n";
-				}
-				else {
-					s += this.steppedViewUp();
-				}
-			}
-		}
-		File file = new File("out.txt");
-		try (FileWriter writer = new FileWriter(file)) {
-			writer.write(s);
-		} catch (IOException e) {
-			System.out.printf("Exception");
-		}
+		matrix.steppedViewDown();
+	} catch (FileNotFoundException e) {
+		System.out.println("I hope that never happen");
 	}
 
-	String steppedViewUp () {
-		String s = "";
-		for (int j = this.N - 1; j > 0; j--) {
-			s += this.resetAllUp(j, j);
-		}
-		s += this.solve();
-		return s;
-	}
-// true - есть ненулевой элемент помимо ответа
-	boolean checkNonzero(int i, int j) {
-		if (i < this.N - 1) {
-			return (this.checkNonzero(i + 1, j) || this.checkValue(i, j));
-		}
-		else {
-			return this.checkValue(i, j);
-		}
-	}
 
-	void swap(int i, int j) { 
-		Row row = this.rows[i];
-		this.rows[i] = this.rows[j];
-		this.rows[j] = row;
 	}
-	String getString() {
-		String s = "";
-		for (int i = 0; i < this.M; i++) {
-			s += this.rows[i].getString();
-		}
-		return s;
-	}
-	String solve () {
-		String s = "";
-		s += "The solution is: (";
-		for (int i = 0; i < this.N - 1; i++) {
-			s = s + this.rows[i].getValue(this.N) + ", ";
-		}
-		s = s + this.rows[this.N - 1].getValue(this.N) + ")\n";
-		return s;
-	}
-
 }
+

From 6949e5a80601c645250627bba9165aae80c98b60 Mon Sep 17 00:00:00 2001
From: superhakeroftheworld
 <32217428+superhakeroftheworld@users.noreply.github.com>
Date: Thu, 20 Dec 2018 23:34:14 +0300
Subject: [PATCH 6/6] Add files via upload

---
 src/solver/ComplexNumber.java |  61 ++++++++++++++
 src/solver/Matrix.java        | 153 ++++++++++++++++++++++++++++++++++
 src/solver/Row.java           |  42 ++++++++++
 src/solver/makeGood.java      |  45 ++++++++++
 4 files changed, 301 insertions(+)
 create mode 100644 src/solver/ComplexNumber.java
 create mode 100644 src/solver/Matrix.java
 create mode 100644 src/solver/Row.java
 create mode 100644 src/solver/makeGood.java

diff --git a/src/solver/ComplexNumber.java b/src/solver/ComplexNumber.java
new file mode 100644
index 0000000..c59822d
--- /dev/null
+++ b/src/solver/ComplexNumber.java
@@ -0,0 +1,61 @@
+import java.util.Scanner;
+
+
+class ComplexNumber {
+	double re;
+	double im;
+
+	public ComplexNumber(double re, double im) {
+		this.re = re;
+		this.im = im;
+	}
+
+	public double getRe() {
+		return this.re;
+	}
+
+	public double getIm() {
+		return this.im;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {return true;}
+		if (obj == null) {return false;}
+		if (obj instanceof ComplexNumber) {
+			ComplexNumber num = (ComplexNumber) obj;
+			return this.getRe() == num.getRe() && this.getIm() == num.getIm();
+		}
+		return false;
+	} 
+	@Override
+	public int hashCode() {
+		return this.toString().hashCode();
+	}
+	public String toString() {
+		return "" + this.re + " + i*" + this.im;
+	}
+
+	ComplexNumber add(ComplexNumber num) {
+		ComplexNumber result = new ComplexNumber(0, 0);
+		result.re = num.re + this.re;
+		result.im = num.im + this.im;
+		return result;
+	}
+
+	ComplexNumber mul(ComplexNumber num) {
+		ComplexNumber result = new ComplexNumber(0, 0);
+		result.re = num.re * this.re - num.im * this.im;
+		result.im = num.re * this.im + num.im * this.re;
+		return result;
+	}
+
+	ComplexNumber inverse() {
+		ComplexNumber result = new ComplexNumber(0, 0);
+		double module = 0;
+		module = this.re * this.re + this.im * this.im;
+		result.re = this.re / module;
+		result.im = -this.im / module;
+		return result;
+	}
+}
diff --git a/src/solver/Matrix.java b/src/solver/Matrix.java
new file mode 100644
index 0000000..18546b4
--- /dev/null
+++ b/src/solver/Matrix.java
@@ -0,0 +1,153 @@
+import java.util.Scanner;
+import java.util.Arrays;
+import java.util.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+class Matrix {
+	int N;
+	int M;
+	Row[] rows = new Row[1];
+	public Matrix(Row[] row, int n, int m) {
+		this.rows = row;
+		this.N = n;
+		this.M = m;
+	}
+// true - ненулевое
+	boolean checkValue(int i, int j) { 
+		ComplexNumber zero = new ComplexNumber(0, 0); 
+		return (this.rows[j].getValue(i).equals(zero) ? false: true);
+	}
+
+
+	String resetAllDown(int i, int j) {
+		String s = "";
+		ComplexNumber minOne = new ComplexNumber(-1, 0);
+		ComplexNumber zero = new ComplexNumber(0, 0);
+		ComplexNumber coef = this.rows[j].getValue(i);		
+		this.rows[j].mul(coef.inverse());
+		s = (coef.inverse().toString()) +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
+		for (int k = j + 1; k < this.M; k++) {
+			coef = this.rows[k].getValue(i);
+			if (!coef.equals(zero)) {
+				this.rows[k].mul( coef.inverse().mul(minOne));
+				this.rows[k].add(this.rows[j]);
+				s = s + coef.inverse().mul(minOne).toString() + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
+			}
+		}
+		return s;
+	}
+
+	String resetAllUp(int i, int j) {
+		String s = "";
+		ComplexNumber zero = new ComplexNumber(0, 0);
+		ComplexNumber minOne = new ComplexNumber(-1, 0);
+		ComplexNumber coef = this.rows[j].getValue(i);
+		this.rows[j].mul(coef.inverse());
+		s = coef.inverse().toString() +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
+		for (int k = j - 1; k >= 0; k--) {
+			coef = this.rows[k].getValue(i);
+			if (!coef.equals(zero)) {
+				this.rows[k].mul(coef.inverse().mul(minOne));
+				this.rows[k].add(this.rows[j]); 
+				s = s + coef.inverse().mul(minOne).toString() + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
+			}
+		}
+		return s;
+	}
+
+	void steppedViewDown () {
+		int j = 0;
+		int i = 0;
+		String s = "";
+		s += "start solving the equation\n";
+		s += "Rows manipulation\n";
+		for (; i <= this.N && j < this.M; i++) {
+			if (this.checkValue(i, j)) {
+				s += this.resetAllDown(i, j);
+				j += 1;
+			}
+			else { //пробегаю вниз. Если есть ненулевой - свапаю, если нет - перехожу к след i и j;
+				for (int k = j + 1; k < this.M; k++) {
+					if (this.checkValue(i, k)) {
+						this.swap(i, k);
+						s = s + "Swap R" + (i + 1) + " with R" + (k + 1) + "\n";
+					}
+				}
+				if (!this.checkValue(i, j)) {
+					i += 1;
+				}
+				i -= 1;
+			}
+		}
+
+		if (j == 0) {
+			s += "infinity solutions\n";
+		}
+
+		else {
+			if (!this.checkNonzero(0, j - 1)) {
+				s += "no solutions\n";
+			}
+			else {
+				if (j != this.N) {
+					s += "infinity solutions\n";
+				}
+				else {
+					s += this.steppedViewUp();
+				}
+			}
+		}
+		File file = new File("out.txt");
+		try (FileWriter writer = new FileWriter(file)) {
+			writer.write(s);
+		} catch (IOException e) {
+			System.out.printf("Exception");
+		}
+	}
+
+	String steppedViewUp () {
+		String s = "";
+		for (int j = this.N - 1; j > 0; j--) {
+			s += this.resetAllUp(j, j);
+		}
+		s += this.solve();
+		return s;
+	}
+// true - есть ненулевой элемент помимо ответа
+	boolean checkNonzero(int i, int j) {
+		if (i < this.N - 1) {
+			return (this.checkNonzero(i + 1, j) || this.checkValue(i, j));
+		}
+		else {
+			return this.checkValue(i, j);
+		}
+	}
+
+	void swap(int i, int j) { 
+		Row row = this.rows[i];
+		this.rows[i] = this.rows[j];
+		this.rows[j] = row;
+	}
+	String getString() {
+		String s = "";
+		for (int i = 0; i < this.M; i++) {
+			s += this.rows[i].getString();
+			s += "\n";
+		}
+		return s;
+	}
+	String solve () {
+		String s = "";
+		s += "The solution is: (";
+		for (int i = 0; i < this.N - 1; i++) {
+			ComplexNumber now = this.rows[i].getValue(i);
+			now = now.inverse();
+			s = s + this.rows[i].getValue(this.N).mul(now).toString() + ", ";
+		}
+		s = s + this.rows[this.N - 1].getValue(this.N).toString() + ")\n";
+		return s;
+	}
+
+}
diff --git a/src/solver/Row.java b/src/solver/Row.java
new file mode 100644
index 0000000..2b19daa
--- /dev/null
+++ b/src/solver/Row.java
@@ -0,0 +1,42 @@
+/**
+Я решительно не понимаю 1 важную вещь. Сейчас в конструкторе у меня цикл и вроде как лишние приравнения, сделано это потому,
+что иначе при задании массива строк у нас присваивание будет (как я понимаю) по ссылке и в такой ситуации:
+Row[] row = new Row[5]; 
+row[0] = first_row; ... row[4] = fifth_row; в row[0] будет храниться  fifth_row и я не совсем понимаю почему. Точнее, я не понимаю
+почему при таком задании конструктора как тут, все работает правильно.
+*/
+class Row { // N на 1 больше, чем вход, т.к. тут я учитываю и ответ (то, что справа от равно)
+	int N;
+	ComplexNumber[] line = new ComplexNumber[1];
+	public Row(int N, ComplexNumber[] row) {
+		this.line = new ComplexNumber[N + 1];
+		for (int i = 0; i <= N; i++) {
+			this.line[i] = row[i];
+		}
+		this.N = N;
+	}
+
+	ComplexNumber getValue(int i) {
+		return this.line[i];
+	}
+
+	void add(Row other) { //поидее можно сделать private?
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] = this.line[i].add(other.line[i]);
+		}
+	}
+	void mul(ComplexNumber num) { //умножение строки на константу
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] = this.line[i].mul(num);
+		}
+	}
+
+	String getString() {
+		String s = "[";
+		for (int i = 0; i <= this.N - 1; i++) {
+			s = s + this.getValue(i).toString() + ", ";
+		}
+		s = s + this.getValue(this.N).toString() + "]";
+		return s;
+	}
+}
diff --git a/src/solver/makeGood.java b/src/solver/makeGood.java
new file mode 100644
index 0000000..a718b75
--- /dev/null
+++ b/src/solver/makeGood.java
@@ -0,0 +1,45 @@
+class makeGood {
+	ComplexNumber stringToComplex(String s) {
+		ComplexNumber num = new ComplexNumber(0, 0);
+		String[] parts = new String[2];
+		if (s.contains("+")) {
+			parts = s.split("\\+");
+			String re = parts[0];
+			String im = parts[1].substring(0, parts[1].length() -1);
+			double Re = Double.parseDouble(re);
+			double Im = Double.parseDouble(im);
+			num = new ComplexNumber(Re, Im);
+		}
+
+		else if (s.indexOf("-") > 0 || s.substring(1, s.length()).indexOf("-") >= 0)
+		{
+//			System.out.println("Yep, I can parse it too");
+			if (s.indexOf("-") == 0) {
+				parts = s.substring(1, s.length()).split("-");
+				double Re = -Double.parseDouble(parts[0]);
+				double Im = -Double.parseDouble(parts[1].substring(0, parts[1].length() - 1));
+				num = new ComplexNumber(Re, Im);
+			}
+			else {
+				parts = s.substring(0, s.length()).split("-");
+				double Re = Double.parseDouble(parts[0]);
+				double Im = -Double.parseDouble(parts[1].substring(0, parts[1].length() - 1));
+				num = new ComplexNumber(Re, Im);
+			}
+		}
+
+		else {
+			if (s.contains("i")) {
+				double Re = 0;
+				double Im = Double.parseDouble(s.substring(0, s.length() - 1));
+				num = new ComplexNumber(Re, Im);
+			}
+			else {
+				double Re = Double.parseDouble(s);
+				double Im = 0;
+				num = new ComplexNumber(Re, Im);
+			}
+		}
+		return num;
+	}
+}