A704

11.06.2017 by Владислав Козачков

Задача взята отсюда.

Условие

Даны квадратные матрицы с целыми числами $A$, $B$ и $C$ порядка $n$. Получить матрицу $(A+B)*C$.

Входные данные

В первой строке — размерность матриц $n$. Далее вводятся построчно матрицы $A$, $B$ и $C$.

Выходные данные

Вывести построчно результирующую матрицу $(A+B)*C$.

Тесты:

Тесты:

$n$	$A$	$B$	$C$	Output
$3$	$1$ $2$ $3$ $4$ $5$ $6$ $7$ $8$ $9$	$0$ $1$ $0$ $0$ $0$ $0$ $0$ $0$ $0$	$1$ $0$ $0$ $0$ $1$ $0$ $0$ $0$ $1$	$1$ $3$ $3$ $4$ $5$ $6$ $7$ $8$ $9$
$2$	$4$ $6$ $12$ $7$	$3$ $2$ $1$ $1$	$7$ $3$ $2$ $8$	$65$ $85$ $107$ $103$
$3$	$3$ $4$ $1$ $1$ $2$ $1$ $5$ $6$ $7$	$1$ $3$ $1$ $2$ $4$ $5$ $6$ $5$ $1$	$1$ $1$ $0$ $5$ $8$ $1$ $2$ $3$ $2$	$43$ $66$ $11$ $45$ $69$ $18$ $82$ $123$ $27$

Код на Haxe:

package;

import cpp.Lib;
import haxe.io.Input;

class Main 
{
	static function main() 
	{
		var input:Input = Sys.stdin();
		var n:Int = Std.parseInt(input.readLine());
		var ab = new Array<Array<Int>>();
		var c = new Array<Array<Int>>();
		var d = new Array<Array<Int>>();
		var i:Int = 0, j:Int = 0, k:Int = 0;
		var input_str:String;
		var space_loc:Int;
		var arr_temp:Array<Int>;
		for (i in 0...n) {
			arr_temp = new Array<Int>();
			input_str = input.readLine();
			for (j in 0...n) {
				space_loc = input_str.indexOf(" ");
				if (space_loc == 0) {
					space_loc = input_str.length;
				}
				arr_temp.push(Std.parseInt(input_str));
				if (space_loc != input_str.length) {
					input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);
				}
			}
			ab.push(arr_temp);
		}
		for (i in 0...n) {
			input_str = input.readLine();
			for (j in 0...n) {
				space_loc = input_str.indexOf(" ");
				if (space_loc == 0) {
					space_loc = input_str.length;
				}
				ab[i][j] += (Std.parseInt(input_str));
				if (space_loc != input_str.length) {
					input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);
				}
			}
		}
		for (i in 0...n) {
			arr_temp = new Array<Int>();
			input_str = input.readLine();
			for (j in 0...n) {
				space_loc = input_str.indexOf(" ");
				if (space_loc == 0) {
					space_loc = input_str.length;
				}
				arr_temp.push(Std.parseInt(input_str));
				if (space_loc != input_str.length) {
					input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);
				}
			}
			c.push(arr_temp);
		}
		for (i in 0...n) {
			arr_temp = new Array<Int>();
			for (j in 0...n) {
				arr_temp[j] = 0;
				for (k in 0...n) {
					arr_temp[j] += ab[i][k] * c[k][j];
				}
				Sys.stdout().writeString(arr_temp[j] + " ");
			}
			d.push(arr_temp);
			Sys.stdout().writeString("\n");
		}
	}
}

package;

import cpp.Lib;

import haxe.io.Input;

class Main

{

static function main()

{

var input:Input = Sys.stdin();

var n:Int = Std.parseInt(input.readLine());

var ab = new Array<Array<Int>>();

var c = new Array<Array<Int>>();

var d = new Array<Array<Int>>();

var i:Int = 0, j:Int = 0, k:Int = 0;

var input_str:String;

var space_loc:Int;

var arr_temp:Array<Int>;

for (i in 0...n) {

arr_temp = new Array<Int>();

input_str = input.readLine();

for (j in 0...n) {

space_loc = input_str.indexOf(" ");

if (space_loc == 0) {

space_loc = input_str.length;

}

arr_temp.push(Std.parseInt(input_str));

if (space_loc != input_str.length) {

input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);

}

ab.push(arr_temp);

}

for (i in 0...n) {

input_str = input.readLine();

for (j in 0...n) {

space_loc = input_str.indexOf(" ");

if (space_loc == 0) {

space_loc = input_str.length;

}

ab[i][j] += (Std.parseInt(input_str));

if (space_loc != input_str.length) {

input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);

}

for (i in 0...n) {

arr_temp = new Array<Int>();

input_str = input.readLine();

for (j in 0...n) {

space_loc = input_str.indexOf(" ");

if (space_loc == 0) {

space_loc = input_str.length;

}

arr_temp.push(Std.parseInt(input_str));

if (space_loc != input_str.length) {

input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);

}

c.push(arr_temp);

}

for (i in 0...n) {

arr_temp = new Array<Int>();

for (j in 0...n) {

arr_temp[j] = 0;

for (k in 0...n) {

arr_temp[j] += ab[i][k] * c[k][j];

}

Sys.stdout().writeString(arr_temp[j] + " ");

}

d.push(arr_temp);

Sys.stdout().writeString("\n");

}

Ход решения:

В первом цикле читаем матрицу $A$:

for (i in 0...n) {
	arr_temp = new Array<Int>();
	input_str = input.readLine();
	for (j in 0...n) {
		space_loc = input_str.indexOf(" ");
		if (space_loc == 0) {
			space_loc = input_str.length;
		}
		arr_temp.push(Std.parseInt(input_str));
		if (space_loc != input_str.length) {
			input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);
		}
	}
	ab.push(arr_temp);
}

for (i in 0...n) {

arr_temp = new Array<Int>();

input_str = input.readLine();

for (j in 0...n) {

space_loc = input_str.indexOf(" ");

if (space_loc == 0) {

space_loc = input_str.length;

}

arr_temp.push(Std.parseInt(input_str));

if (space_loc != input_str.length) {

input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);

}

ab.push(arr_temp);

}

Во втором цикле считываем элементы матрицы $B$ и сразу прибавляем их к соответствующим элементам матрицы $A$:

for (i in 0...n) {
	input_str = input.readLine();
	for (j in 0...n) {
		space_loc = input_str.indexOf(" ");
		if (space_loc == 0) {
			space_loc = input_str.length;
		}
		ab[i][j] += (Std.parseInt(input_str));
		if (space_loc != input_str.length) {
			input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);
		}
	}
}

for (i in 0...n) {

input_str = input.readLine();

for (j in 0...n) {

space_loc = input_str.indexOf(" ");

if (space_loc == 0) {

space_loc = input_str.length;

}

ab[i][j] += (Std.parseInt(input_str));

if (space_loc != input_str.length) {

input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);

}

В третьем цикле читаем матрицу $C$:

for (i in 0...n) {
	arr_temp = new Array<Int>();
	input_str = input.readLine();
	for (j in 0...n) {
		space_loc = input_str.indexOf(" ");
		if (space_loc == 0) {
			space_loc = input_str.length;
		}
		arr_temp.push(Std.parseInt(input_str));
		if (space_loc != input_str.length) {
			input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);
		}
	}
	c.push(arr_temp);
}

for (i in 0...n) {

arr_temp = new Array<Int>();

input_str = input.readLine();

for (j in 0...n) {

space_loc = input_str.indexOf(" ");

if (space_loc == 0) {

space_loc = input_str.length;

}

arr_temp.push(Std.parseInt(input_str));

if (space_loc != input_str.length) {

input_str = input_str.substr(space_loc + 1, input_str.length - space_loc);

}

c.push(arr_temp);

}

Наконец, в четвертом цикле вычисляем и выводим элементы результирующей матрицы $D = (A + B) * C$:

for (i in 0...n) {
	arr_temp = new Array<Int>();
	for (j in 0...n) {
		arr_temp[j] = 0;
		for (k in 0...n) {
			arr_temp[j] += ab[i][k] * c[k][j];
		}
		Sys.stdout().writeString(arr_temp[j] + " ");
	}
	d.push(arr_temp);
	Sys.stdout().writeString("\n");
}

for (i in 0...n) {

arr_temp = new Array<Int>();

for (j in 0...n) {

arr_temp[j] = 0;

for (k in 0...n) {

arr_temp[j] += ab[i][k] * c[k][j];

}

Sys.stdout().writeString(arr_temp[j] + " ");

}

d.push(arr_temp);

Sys.stdout().writeString("\n");

}

Ссылки:

Рабочий код для тестирования на try.haxe.org: Try Haxe !

a406

18.05.2017 by Дарья Пиндус

Задача. С помощью [latex]x_{ij}, i=1,2; j=1,…,n[/latex] — действительной матрицы на плоскости задано [latex]n[/latex] точек так, что [latex]x_{1j},x_{2j} [/latex] — координаты [latex]j [/latex]— точки. Точки попарно соединены отрезками. Найти длину наибольшего отрезка.

Тест

n	Матрица [latex]x_{ij}, i=1,2[/latex]	Длина наибольшего отрезка	Комментарий
3	2 8 4 9 1 5	10	Пройдено
4	6 14 2 1 9 3 8 0	13.3417	Пройдено
5	1 8 4 3 7 2 9 5 0 11	11.7047	Пройдено

Код программы

class Point {
   public var x:Int; 
   public var y:Int;
   public function new(x,y) {
    this.x = x;
    this.y = y;
  }
}

class Test {
    static function distance(a:Point, b:Point):Float{
            return Math.sqrt((b.x-a.x)*(b.x-a.x) + (b.y - a.y)* (b.y - a.y));
    }
    
    static function main() {
        var n = Std.parseInt(Sys.stdin().readLine()); 
        
        var coords:Array<Array<Int>> = new Array<Array<Int>>();
        var max:Float = 0;
        var curr:Float;
        
        for (i in 0...n){
            for (j in 0...1) {
            	coords[i][j] = Std.parseInt(Sys.stdin().readInt32());
        	}
        }
        
        var a:Point, b:Point;
        for (i in 0...n){
            a = new Point(coords[0][i], coords[1][i]);
        	b = i < n ? new Point(coords[0][i+1], coords[1][i+1]) : new Point(coords[0][0], coords[1][0]);
            curr = distance(a, b);
            if (max < curr) {
                max = curr;
            }
        }
        trace(max);
    }
}

class Point {

public var x:Int;

public var y:Int;

public function new(x,y) {

this.x = x;

this.y = y;

}

class Test {

static function distance(a:Point, b:Point):Float{

return Math.sqrt((b.x-a.x)*(b.x-a.x) + (b.y - a.y)* (b.y - a.y));

}

static function main() {

var n = Std.parseInt(Sys.stdin().readLine());

var coords:Array<Array<Int>> = new Array<Array<Int>>();

var max:Float = 0;

var curr:Float;

for (i in 0...n){

for (j in 0...1) {

coords[i][j] = Std.parseInt(Sys.stdin().readInt32());

}

var a:Point, b:Point;

for (i in 0...n){

a = new Point(coords[0][i], coords[1][i]);

b = i < n ? new Point(coords[0][i+1], coords[1][i+1]) : new Point(coords[0][0], coords[1][0]);

curr = distance(a, b);

if (max < curr) {

max = curr;

}

trace(max);

}

Ход решения:

Вводим матрицу построчно (не очень удобно).
Находим длину наибольшего отрезка.
С помощью вложенных циклов мы находим длины всех отрезков по формуле
По алгоритму нахождения максимума находим длину наибольшего отрезка.
Выводим матрицу.
Выводим длину наибольшего отрезка.

Пример выполнения

Ю 4.25

13.05.2017 by Денис Швецов

Задача

Заполнить матрицу заданного размера [latex]M(k,l)[/latex] числами 1, 2, 3, 4 так, чтобы по горизонтали, вертикали и диагонали не было одинаковых рядом стоящих чисел.

Тесты

[latex]k[/latex]

[latex]l[/latex]

Output

1 2 3 4 1 2
3 4 1 2 3 4
1 2 3 4 1 2
3 4 1 2 3 4
1 2 3 4 1 2
3 4 1 2 3 4

1 2 3 4 1 2

3 4 1 2 3 4

1 2 3 4 1 2

3 4 1 2 3 4

1 2 3 4 1 2

3 4 1 2 3 4

1 2 3 4 1

3 4 1 2 3

1 2 3 4 1

3 4 1 2 3

1 2 3 4 1

Код программы

class Test {
    static function main() {
        //Кол-во строк
        var k:Int = Std.parseInt(Sys.stdin().readLine()); 
        
        //Кол-во столбцов
        var l:Int = Std.parseInt(Sys.stdin().readLine());

        var array:Array<Array<Int>> = [
            for(i in 0...k) [
            	for(j in 0...l) (j + 2 * (i % 2)) % 4 + 1 
        	]
        ];
        
        // Выводим массив
        for (x in 0...k) {
             var line = "";
             for (y in 0...l){
            	line += Std.string(array[x][y]);
           		var addLine = " | ";
            	if (array[x][y] < 10) {
                    addLine = " | ";
                }
                line += addLine;
        	 }
             trace(line);
        }
    }
}

class Test {

static function main() {

//Кол-во строк

var k:Int = Std.parseInt(Sys.stdin().readLine());

//Кол-во столбцов

var l:Int = Std.parseInt(Sys.stdin().readLine());

var array:Array<Array<Int>> = [

for(i in 0...k) [

for(j in 0...l) (j + 2 * (i % 2)) % 4 + 1

]

];

// Выводим массив

for (x in 0...k) {

var line = "";

for (y in 0...l){

line += Std.string(array[x][y]);

var addLine = " | ";

if (array[x][y] < 10) {

addLine = " | ";

}

line += addLine;

}

trace(line);

}

Алгоритм решения

Заполняем массив с помощью формулы (j + 2 * (i % 2)) % 4 + 1. При i четном 2 * (i % 2) будет обращаться в 0. То есть в нечетных строках будут числа 1, 2, 3, 4 подряд, а в четных строках будут меняться цифры 1 на 3, 2 на 4, 3 на 1, 4 на 2.

Решение задачи на Try Haxe !

Решение этой задачи на С++ и Java.

e-olymp 5072. Подсчет количества ребер

13.05.2017 by Денис Швецов

Задача

Ориентированный граф задан матрицей смежности.
Найдите количество ребер в графе.

Входные данные

Входной файл содержит число n (1 ≤ n ≤ 100) — число вершин в графе, и затем n строк по n чисел, каждое из которых равно 0 или 1 — его матрицу смежности.

Выходные данные

Выведите в выходной файл количество ребер заданного графа.

Решение

30 1 11 0 1

0 1 1

50 1 1 1 11 0 0 0 0

1 0 0 0 0

0 0 1 0 1

1 0 0 0 0

21 11 1

class Test 
{
    static function main() 
    {
        // Считываем входные данные
    	var n:Int = Std.parseFloat(Sys.stdin().readline());
    	var k:Int = 0;
        var count:Int = 0;
        
        for(i in 1...n) 
        {
            for(j in 1...n) 
            {
            	k = Std.parseInt(Sys.stdin().readline());
            	if(k == 1)
            	    count++;
            }
        }
        
        trace(count);
    }
}

class Test

{

static function main()

{

// Считываем входные данные

var n:Int = Std.parseFloat(Sys.stdin().readline());

var k:Int = 0;

var count:Int = 0;

for(i in 1...n)

{

for(j in 1...n)

{

k = Std.parseInt(Sys.stdin().readline());

if(k == 1)

count++;

}

trace(count);

}

Алгоритм решения

Количество ребер ориентированного графа равно количеству единиц в его матрице смежности. Поэтому просто считываем, суммируем найденные 1-цы, и выводим ответ.

Выполнение кода на Try Haxe !
Решение задачи на С++.

Алексей Маслеев	Сергей Завада	Анастасия Улановская
Владислав Козачков	Николай Яковлев	Даша Тарабаева
Лена Наумова	Денис Швецов	Артур Тарасов
Евгений Кравчук	Дарья Пиндус	Артём Мисесин
Даша Кивганова	Иоанна Васильева	Алёна Ищук
Кирилл Автомонов	Александр Зайченко	Маша Лукьянова
Игорь Варламов	Геннадий Муржи

haxe

Учебные материалы по программированию

Tag Archives: матрицы

A704

Условие

Входные данные

Выходные данные

Тесты:

Код на Haxe:

Ход решения:

Ссылки:

a406

Ю 4.25

Задача

Тесты

Код программы

Алгоритм решения

e-olymp 5072. Подсчет количества ребер

Задача

Входные данные

Выходные данные

Решение

Алгоритм решения