А402б

26/11/2014 by Вустянюк Ігор Дмитрович

Задача

Даны натуральное число [latex] n \geq 2 [/latex], действительная квадратная матрица порядка [latex] n [/latex]. Построить последовательность [latex] b_{1}, \ldots, b_{n} [/latex] из нулей и единиц, в которой [latex] b_{i} = 1 [/latex] тогда и только тогда, когда элементы [latex] i [/latex] строки образуют возрастающую или убывающую последовательность.

Тесты

Ввод	Вывод
[latex] \begin{pmatrix} 1 & 2.5 & 3 & -5 & 2 \\ -7 & -4.5 & -2.8 & 0 & 1 \\ 8 & 3 & 0 & -2.9 & -4.62 \\ 8 & 3 & 3 & -2.9 & -4.62 \\ 1 & 2 & 3 & 3 & 4 \end{pmatrix} [/latex]	[latex] \begin{matrix} 0 \\ 1 \\ 1 \\ 0 \\ 0 \end{matrix}[/latex]

Код на С++

#include <iostream>
using namespace std;

int main() {
	int m, n;
	cin >> m >> n;
	double M[m][n];
	bool monotone[m];
	
	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			cin >> M[i][j];
			
	for (int i = 0; i < m; i++) {
		bool check = true, diff;
		if (M[i][0] != M[i][1]) {
			diff = (M[i][1] > M[i][0]);
			for (int j = 2; j < n; j++)
				if ((M[i][j] == M[i][j-1]) || ((M[i][j] > M[i][j-1]) != diff)) {
					check = false;
					break;
				}
		}
		else
			check = false;
		monotone[i] = check;
	}
	
	for (int i = 0; i < m; i++)
		cout << monotone[i] << endl;
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int m, n;

cin >> m >> n;

double M[m][n];

bool monotone[m];

for (int i = 0; i < m; i++)

for (int j = 0; j < n; j++)

cin >> M[i][j];

for (int i = 0; i < m; i++) {

bool check = true, diff;

if (M[i][0] != M[i][1]) {

diff = (M[i][1] > M[i][0]);

for (int j = 2; j < n; j++)

if ((M[i][j] == M[i][j-1]) || ((M[i][j] > M[i][j-1]) != diff)) {

check = false;

break;

}

else

check = false;

monotone[i] = check;

}

for (int i = 0; i < m; i++)

cout << monotone[i] << endl;

return 0;

}

Ideone (C++)

Код на Java

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int m = in.nextInt(), n = in.nextInt();
		double[][] M = new double[m][n];
		boolean[] monotone = new boolean[m];
		
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
				M[i][j] = in.nextDouble();
		
		for (int i = 0; i < m; i++) {
			boolean check = true, diff;
			if (M[i][0] != M[i][1]) {
				diff = (M[i][1] > M[i][0]);
				for (int j = 2; j < n; j++)
					if ((M[i][j] == M[i][j-1]) || ((M[i][j] > M[i][j-1]) != diff)) {
						check = false;
						break;
					}
			}
			else
				check = false;
			monotone[i] = check;
		}
		
		for (int i = 0; i < m; i++)
			System.out.println(monotone[i]);
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

int m = in.nextInt(), n = in.nextInt();

double[][] M = new double[m][n];

boolean[] monotone = new boolean[m];

for (int i = 0; i < m; i++)

for (int j = 0; j < n; j++)

M[i][j] = in.nextDouble();

for (int i = 0; i < m; i++) {

boolean check = true, diff;

if (M[i][0] != M[i][1]) {

diff = (M[i][1] > M[i][0]);

for (int j = 2; j < n; j++)

if ((M[i][j] == M[i][j-1]) || ((M[i][j] > M[i][j-1]) != diff)) {

check = false;

break;

}

else

check = false;

monotone[i] = check;

}

for (int i = 0; i < m; i++)

System.out.println(monotone[i]);

}

Ideone (Java)

Решение

1) Считываем матрицу

2) Просматриваем по очереди строки матрицы. Фиксируем знак разности первых двух элементов строки и пробегаем строку, сравнивая знак соседних элементов со знаком первых двух. Если последовательность убывает/возрастает, знаки всех пар должны совпадать со знаком первой и никакие два подряд идущих элемента не должны совпадать.

Related Images:

А407

26/11/2014 by Бронфен-Бова Роман

Задача:
Даны натуральные числа n и m, действительное число r, действительная матрица размера nxm. Получить значение [latex]{b}_{1}{r}^{n-1}+{b}_{2}{r}^{n-2}+\dots+{b}_{n}[/latex], где [latex]{b}_{k}[/latex] — первый по порядку положительный элемент в k-й строке матрицы [latex](k=1,\dots,n)[/latex]; если в k-строке нет положительных элементов, то [latex]{b}_{k}=0.5[/latex].

Тесты:

nxm	r	Матрица	Результат	Комментарий
2х2	2.5	[latex]\begin{pmatrix} -1 & 1 \\ 1 & 0 \end{pmatrix}[/latex]	3.5	Пройдено
3×4	3.14	[latex]\begin{pmatrix}5.7 & 6.7 & -7.7 & 0.9\\-3.0 & 2.3 & -5.0 & -2.4\\6.7 & 3.5 & 0.0 & 4.4\end{pmatrix}[/latex]	70.1	Пройдено
2×4	2.71	[latex]\begin{pmatrix}-9.0 &-8.8 &-7.3 & 7.5\\-6.3 &-9.7 & 6.8 &-0.5\end{pmatrix}[/latex]	27.1	Пройдено

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

#include <iostream>
#include <math.h>
using namespace std;

int main() {
	int n,m; scanf("%d %d",&n,&m);
	double r; scanf("%lf",&r);
	double a[n][m];
	for(int i = 0; i < n; i++)
		for(int j = 0; j < m; j++)
			scanf("%lf", &a[i][j]);
	double sum = 0;
	for(int i = 0; i < n; i++) {
		double b = 0.5;
		for(int j = 0; j < m; j++)
			if(a[i][j]>0) {
				b = a[i][j];
				break;
			}
		sum += b*pow(r,n-i-1);
	}
	printf("%lf",sum);
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n,m; scanf("%d %d",&n,&m);

double r; scanf("%lf",&r);

double a[n][m];

for(int i = 0; i < n; i++)

for(int j = 0; j < m; j++)

scanf("%lf", &a[i][j]);

double sum = 0;

for(int i = 0; i < n; i++) {

double b = 0.5;

for(int j = 0; j < m; j++)

if(a[i][j]>0) {

b = a[i][j];

break;

}

sum += b*pow(r,n-i-1);

}

printf("%lf",sum);

return 0;

}

Код программы на Java:

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
	static Scanner sc = new Scanner(System.in);
	
	public static void main (String[] args) throws java.lang.Exception
	{
		int n, m;
		n = sc.nextInt();
		m = sc.nextInt();
		double r = sc.nextDouble();
		double[][] a = new double[n][m];
		for(int i = 0; i < n; i++){
			for(int j = 0; j < m; j++){
				a[i][j] = sc.nextDouble();
			}
		}
		double sum = 0;
		for(int i = 0; i < n; i++){
			double b = 0.5;
			for(int j = 0; j < m; j++){
				if(a[i][j] > 0){
					b = a[i][j];
					break;
				}
			}
			sum += b*Math.pow(r, n-i-1);
		}
		System.out.println(sum);
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

static Scanner sc = new Scanner(System.in);

public static void main (String[] args) throws java.lang.Exception

{

int n, m;

n = sc.nextInt();

m = sc.nextInt();

double r = sc.nextDouble();

double[][] a = new double[n][m];

for(int i = 0; i < n; i++){

for(int j = 0; j < m; j++){

a[i][j] = sc.nextDouble();

}

double sum = 0;

for(int i = 0; i < n; i++){

double b = 0.5;

for(int j = 0; j < m; j++){

if(a[i][j] > 0){

b = a[i][j];

break;

}

sum += b*Math.pow(r, n-i-1);

}

System.out.println(sum);

}

Идея решения:
Считать n, m как целочисленные переменные. После этого считать r как переменную типа double. Следующим считать массив nxm созданный благодаря генератору матриц из случайных чисел заданного размера. Завести переменную [latex]sum = 0[/latex] для хранения результата. Проверять построчно каждый столбик на наличие положительного числа и прибавить первое положительное число в строке, умноженное на [latex]{r}^{n-i-1}[/latex], к результаты. В случает отсутствия положительного элемента в строке, брать 0.5. В конце вывести результат.

Related Images:

A403a

22/11/2014 by Фесенко Катерина Володимирівна

Задача

Дана целочисленная квадратная матрица порядка [latex]15[/latex]. Выяснить, имеются ли в матрице ненулевые элементы, и если имеются, указать индекс одного из ненулевых элементов.

Тест

i, j	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	Результат
0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	Index: 0 3
1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	0	0	0	0	9	0	0	0	0	0	0	8	0	0
3	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
4	0	0	0	0	0	0	0	0	0	0	0	0	0	0	2
5	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
6	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
7	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
8	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
9	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
10	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
11	0	0	0	0	0	0	0	0	0	0	0	0	0	0	7
12	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
13	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0
14	8	0	0	0	0	0	0	0	0	0	0	0	0	0	0

i,j	1	2	3	4	5	6	7	8	9	10	11	12	13	14	Результат
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	Ненулевых элементов нет
1	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	0	0	0	0	0	0	0	0	0	0	0	0
4	0	0	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	0	0	0	0	0	0	0	0	0	0	0	0
6	0	0	0	0	0	0	0	0	0	0	0	0	0	0
7	0	0	0	0	0	0	0	0	0	0	0	0	0	0
8	0	0	0	0	0	0	0	0	0	0	0	0	0	0
9	0	0	0	0	0	0	0	0	0	0	0	0	0	0
10	0	0	0	0	0	0	0	0	0	0	0	0	0	0
11	0	0	0	0	0	0	0	0	0	0	0	0	0	0
12	0	0	0	0	0	0	0	0	0	0	0	0	0	0
13	0	0	0	0	0	0	0	0	0	0	0	0	0	0
14	0	0	0	0	0	0	0	0	0	0	0	0	0	0

Код на языке С++ :

#include <iostream>
#include <math.h>
using namespace std;

int main() {
	int n = 15;
	cin >> n;
	double z[n][n];
	for( int i = 0; i < n; i++)
	{
		for( int j = 0; j < n; j++)
		{
			cin >> z[i][j];
			if(z[i][j] > 0)
			{
				cout << "Index: "<< i <<" "<< j << '\n';
				return 0;
			}
		}
	}
	cout <<"Ненулевых элементов нет" <<  endl;
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

int main() {

int n = 15;

cin >> n;

double z[n][n];

for( int i = 0; i < n; i++)

{

for( int j = 0; j < n; j++)

{

cin >> z[i][j];

if(z[i][j] > 0)

{

cout << "Index: "<< i <<" "<< j << '\n';

return 0;

}

cout <<"Ненулевых элементов нет" << endl;

return 0;

}

Ссылка на программу: http://ideone.com/72Gn1G

Решение:

Задача довольно простая.Вводим квадратную матрицу [latex]z(n,n)[/latex] порядка 15. Далее в цикле описываем условие, что если:

if(z[i][j] > 0)

14	if(z[i][j] > 0)

то выводим индекс только одного такого элемента.То есть как только найдется ненулевой элемент, программа выведет его индекс и прекратит работу. Если же такого элемента не найдется, то в ответе мы увидим, что ненулевых элементов нет.

Код на языке Java:

import java.util.*;
import java.lang.*;
import java.io.*;
class Ideone {
	public static void main (String[] args) {
		int n = 15;
		Scanner sc = new Scanner (System.in);
		boolean f = false;
		double[][] A = new double [n][n];
		for ( int i = 0; i < n; i++) {
			for ( int j = 0; j < n; j++) {
				A[i][j] = sc.nextDouble();
				if(A[i][j] != 0) {
					f = true;
					System.out.println ("index: " + i + " " + j);
					break;
				}
			}
		}
		if (!f) System.out.println("Ненулевых элементов нет");
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone {

public static void main (String[] args) {

int n = 15;

Scanner sc = new Scanner (System.in);

boolean f = false;

double[][] A = new double [n][n];

for ( int i = 0; i < n; i++) {

for ( int j = 0; j < n; j++) {

A[i][j] = sc.nextDouble();

if(A[i][j] != 0) {

f = true;

System.out.println ("index: " + i + " " + j);

break;

}

if (!f) System.out.println("Ненулевых элементов нет");

}

Ссылка на программу:http://ideone.com/SiTKYZ

Related Images:

А400

15/11/2014 by Царев Николай Александрович

Задача: Дана действительная квадратная матрица порядка [latex]n[/latex]. Получить [latex]{ x }_{ 1 }{ x }_{ n }+{ x }_{ 2 }{ x }_{ n-1 }+ \dots +{x }_{ n }{ x }_{ 1 }[/latex] , где [latex]{x }_{ k }[/latex] — наибольшее значение элементов [latex]k[/latex]-й строки данной матрицы.

Числа

Результат

Числа

Результат

1 1 1 15 5 5 56 6 6 6

2 2 2 3

1.25 99 45 4.2 5.20.3 0 0.2

86.44

1 2 3 4 19 8 4 3 10 50 9 2 1

1 2 1 1 1

3 1 2 0 5

2576

0 0 0 0 05 9 10008 72 1777799 98 100 10 100

0 0 0 0 0

9.842 8 7 66 54

1000

Код программы на С++

#include <iostream>
using namespace std;

int main() {
	int n; // размер матрицы
	cin >> n;
	double x[n][n]; //объявление матрицы как двухмерного массива
	for (int i=0; i<n; i++) // ввод данных
		for(int j=0; j<n; j++)
			cin >> x[i][j];
			
	/*for(auto &row : x){  //распечатка массива (если понадобится)
		for(auto e:row)
			printf("%.2lf   ", e);
		cout << "\n";
	}
	cout << endl;*/
	double y[n]; //массив в который будут определятся максимумы строк
	
	for (int i=0; i<n; i++){ //находим максимум каждой строки и кладем его в 
		y[i]=x[i][0]; //         соответствующую ячейку массива y
		for(int j=1; j<n; j++)
		 	y[i]= (y[i]>x[i][j])? y[i]:x[i][j];
		
	}
	int str=0, end=n-1; //переменные для контроля симметричности относительно средней строки
	double result=0; // переменная для определения результата
	
	for (int i=0; i<n; i++){ // перемножаем нужные элементы и суммируем
		result+=y[str+i]*y[end-i]; 
		//cout << result << "\t"; //печать суммы каждого шага
	}
	
	cout << result << endl; // вывод результата на экран
	
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int n; // размер матрицы

cin >> n;

double x[n][n]; //объявление матрицы как двухмерного массива

for (int i=0; i<n; i++) // ввод данных

for(int j=0; j<n; j++)

cin >> x[i][j];

/*for(auto &row : x){ //распечатка массива (если понадобится)

for(auto e:row)

printf("%.2lf ", e);

cout << "\n";

}

cout << endl;*/

double y[n]; //массив в который будут определятся максимумы строк

for (int i=0; i<n; i++){ //находим максимум каждой строки и кладем его в

y[i]=x[i][0]; // соответствующую ячейку массива y

for(int j=1; j<n; j++)

y[i]= (y[i]>x[i][j])? y[i]:x[i][j];

}

int str=0, end=n-1; //переменные для контроля симметричности относительно средней строки

double result=0; // переменная для определения результата

for (int i=0; i<n; i++){ // перемножаем нужные элементы и суммируем

result+=y[str+i]*y[end-i];

//cout << result << "\t"; //печать суммы каждого шага

}

cout << result << endl; // вывод результата на экран

return 0;

}

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

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in=new Scanner(System.in);
		int n; // размер матрицы
		n=in.nextInt();
		double x[][]=new double[n][]; //объявление матрицы как двухмерного массива
		for (int i=0; i<n; i++){
			x[i]=new double[n];
		}
		for (int i=0; i<n; i++){ // ввод данных
			for(int j=0; j<n; j++)
				x[i][j]=in.nextDouble();
		}
	double y[]=new double[n]; //массив в который будут определятся максимумы строк
	
	for (int i=0; i<n; i++){ //находим максимум каждой строки и кладем его в 
		y[i]=x[i][0]; //         соответствующую ячейку массива y
		for(int j=1; j<n; j++)
		 	y[i]= (y[i]>x[i][j])? y[i]:x[i][j];
		
	}
	int str=0, end=n-1; //переменные для контроля симметричности относительно средней строки
	double result=0; // переменная для определения результата
	
	for (int i=0; i<n; i++){ // перемножаем нужные элементы и суммируем
		result+=y[str+i]*y[end-i]; 
		//cout << result << "\t"; //печать суммы каждого шага
	}
	
	System.out.println(result); // вывод результата 
	
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in=new Scanner(System.in);

int n; // размер матрицы

n=in.nextInt();

double x[][]=new double[n][]; //объявление матрицы как двухмерного массива

for (int i=0; i<n; i++){

x[i]=new double[n];

}

for (int i=0; i<n; i++){ // ввод данных

for(int j=0; j<n; j++)

x[i][j]=in.nextDouble();

}

double y[]=new double[n]; //массив в который будут определятся максимумы строк

for (int i=0; i<n; i++){ //находим максимум каждой строки и кладем его в

y[i]=x[i][0]; // соответствующую ячейку массива y

for(int j=1; j<n; j++)

y[i]= (y[i]>x[i][j])? y[i]:x[i][j];

}

int str=0, end=n-1; //переменные для контроля симметричности относительно средней строки

double result=0; // переменная для определения результата

for (int i=0; i<n; i++){ // перемножаем нужные элементы и суммируем

result+=y[str+i]*y[end-i];

//cout << result << "\t"; //печать суммы каждого шага

}

System.out.println(result); // вывод результата

}

Суть задачи: находим максимум каждой строки определяем их в отдельный массив. Затем перемножаем симметричные относительно середины массива элементы и суммируем их.

P.S. Простите, таблицу я так и не смог нормально отрегулировать….

Ссылка C++

Ссылка Java

Related Images:

А410б

12/11/2014 by Марченко Філіп Олександрович

Задача: Дана целочисленная матрица [latex][a_{i,j},\ i=1,\ldots,n;\ j=1,\ldots,m][/latex]. Получить [latex]b_{1},\ldots,b_{n}[/latex], где

[latex]{b}_{i}=\sum_{j=1}^{n}(-1)^{i+j}a_{ij}[/latex]

Код на С++:

#include <iostream>
#include <stdio.h>

using namespace std;

int main () {
    int n, m; cin>>n>>m; //вводим размер матрицы
    int A[n][m];    //основная матрица
    int B[n];   //результаты
    for (int i=0; i<n; i++) {
         for (int j=0; j<m; j++) {
            cin>>A[i][j];
         }
    }
    for (int i=0; i<n; i++){
    	B[i]=0;        //обнуляем элементы массива для подсчёта суммы
        for (int j=0; j<m; j++){
            B[i] += ((i+j)%2==0? 1: -1) * A[i][j]; 
        }
    }
    for (int i=0; i<n; i++)
            cout<<B[i]<<" "; //Результаты на экран

    return 0;
}

#include <iostream>

#include <stdio.h>

using namespace std;

int main () {

int n, m; cin>>n>>m; //вводим размер матрицы

int A[n][m]; //основная матрица

int B[n]; //результаты

for (int i=0; i<n; i++) {

for (int j=0; j<m; j++) {

cin>>A[i][j];

}

for (int i=0; i<n; i++){

B[i]=0; //обнуляем элементы массива для подсчёта суммы

for (int j=0; j<m; j++){

B[i] += ((i+j)%2==0? 1: -1) * A[i][j];

}

for (int i=0; i<n; i++)

cout<<B[i]<<" "; //Результаты на экран

return 0;

}

Код на Java:

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Count{
	public static void main (String[] args) {
		int n, m; 
		Scanner sc = new Scanner (System.in);
		n = sc.nextInt();
		m = sc.nextInt();
 
	    int[][] A = new int [n][m];    
	    int[] B;   
	 	B = new int [n];
 
	    for (int i=0; i<n; i++) {
	         for (int j=0; j<m; j++) {
	            A[i][j] = sc.nextInt();
	         }
	    }
	    for (int i=0; i<n; i++){
	    	B[i] = 0;       
	        for (int j=0; j<m; j++){
	            B[i] += ((i+j)%2==0? 1: -1) * A[i][j]; 
	        }
	    }
	    for (int i=0; i<n; i++)
	            System.out.println (B[i] + " "); 
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Count{

public static void main (String[] args) {

int n, m;

Scanner sc = new Scanner (System.in);

n = sc.nextInt();

m = sc.nextInt();

int[][] A = new int [n][m];

int[] B;

B = new int [n];

for (int i=0; i<n; i++) {

for (int j=0; j<m; j++) {

A[i][j] = sc.nextInt();

}

for (int i=0; i<n; i++){

B[i] = 0;

for (int j=0; j<m; j++){

B[i] += ((i+j)%2==0? 1: -1) * A[i][j];

}

for (int i=0; i<n; i++)

System.out.println (B[i] + " ");

}

Тесты:

[latex]n*m[/latex]	[latex]\begin{bmatrix}{a}_{ij}\end{bmatrix}[/latex]	[latex]b_{i}[/latex]
3*3	1 2 3 4 5 6 7 8 9	2 -5 8
1*6	2 -4 6 -8 10 -12	42
3*5	1 3 5 7 9 11 13 15 17 19 21 23 25 27 29	5 -15 25

Алгоритм: Чтобы решить эту задачу, необходимо было создать два массива: входной массив (матрицу) и массив результатов (который надо инициализировать нулями). Далее, необходимо завести цикл, в котором будет проводится, собственно говоря, подсчёт. В зависимости от суммы номеров строки и столбца исходной матрицы, -1 в степени этой суммы будет принимать положительное или отрицательное значение. Соответственно, к результату будет прибавляться или отниматься значение, стоящее на i-том j-том месте.

Для проверки правильности работы программы, воспользуйтесь ссылкой.

Related Images:

А402а

12/11/2014 by Калачьов Андрій Сергійович

Задача: Даны натуральное число [latex]n\geqslant 2 [/latex] , действительная квадратная матрица порядка [latex]n [/latex]. Построить последовательность [latex]b_{1}, \ldots, b_{n} [/latex] из нулей и единиц, в которой [latex]b_{i}=1 [/latex] тогда и только тогда, когда элементы строки матрицы образуют возрастающую последовательность.

Ввод:

1	2	3	4	5
6	5	4	3	2
0	1	2	3	4
-5	1	3	4	0
1	3	3.5	4.3	5

Вывод:

Решение:

Ссылка на ideone C++: http://ideone.com/RrsF1f

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int n,k=0; 
		n=in.nextInt();
		double a[][] = new double [n][n];
		int b[] = new int [n];
		for (int i=0; i<n; i++){
			for (int j=0; j<n; j++){
				a[i][j]=in.nextDouble();
			}
		}
		for (int i=0; i<n; i++){
			b[i]=1;
			for (int j=0; j<n-1; j++){
				if (a[i][j]>a[i][j+1]){b[i]=0; break;}
			}
		}
		for (int i=0; i<n; i++){System.out.printf("%d ",b[i]);}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

int n,k=0;

n=in.nextInt();

double a[][] = new double [n][n];

int b[] = new int [n];

for (int i=0; i<n; i++){

for (int j=0; j<n; j++){

a[i][j]=in.nextDouble();

}

for (int i=0; i<n; i++){

b[i]=1;

for (int j=0; j<n-1; j++){

if (a[i][j]>a[i][j+1]){b[i]=0; break;}

}

for (int i=0; i<n; i++){System.out.printf("%d ",b[i]);}

}

Ссылка на ideone Java: http://ideone.com/eW8wJS

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int n,k=0; 
		n=in.nextInt();
		double a[][] = new double [n][n];
		int b[] = new int [n];
		for (int i=0; i<n; i++){
			for (int j=0; j<n; j++){
				a[i][j]=in.nextDouble();
			}
		}
		for (int i=0; i<n; i++){
			b[i]=1;
			for (int j=0; j<n-1; j++){
				if (a[i][j]>a[i][j+1]){b[i]=0; break;}
			}
		}
		for (int i=0; i<n; i++){System.out.printf("%d ",b[i]);}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

int n,k=0;

n=in.nextInt();

double a[][] = new double [n][n];

int b[] = new int [n];

for (int i=0; i<n; i++){

for (int j=0; j<n; j++){

a[i][j]=in.nextDouble();

}

for (int i=0; i<n; i++){

b[i]=1;

for (int j=0; j<n-1; j++){

if (a[i][j]>a[i][j+1]){b[i]=0; break;}

}

for (int i=0; i<n; i++){System.out.printf("%d ",b[i]);}

}

Вводим матрицу [latex]a[n][n] [/latex]. Заранее присваиваем всем элементам матрицы [latex]b[n] [/latex] единицу. если условие не выполняется (элементы с строке введенной матрицы расположены не по возрастанию), то меняет единицу на ноль в матрице [latex]b[n] [/latex]

Related Images:

А394г

12/11/2014 by Іванов Вячеслав Володимирович

Задача
Дана целочисленная квадратная матрица порядка [latex]n[/latex]. Найти номера строк, элементы каждой из которых образуют образуют монотонную последовательность (монотонно убывающую или монотонно возрастающую).

*Строки матрицы нумеруются с единицы, потому их номера в выводе больше соответствующих индексов в массиве на единицу.
Тесты

[latex]n[/latex]

Матрица

Результат

Комментарий

Квадратная матрица первого порядка состоит из одного элемента, следовательно, является и монотонно возрастающей, и монотонно убывающей.

1	1	1
2	2	2
3	3	3

—

Все элементы каждой строки попарно равны.

1	2	2	1
0	1	2	3
0.3	11	-2	3
0	0	1	1

В прочих строках монотонность нарушается

1	2	2
-1	10	15
3	2	1

2, 3

В первой строке последовательность возрастает нестрого.

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

Анализировать строку на монотонность можно при помощи знака разности соседних элементов. Если при движении по строке слева направо знак изменяется, последовательность не может быть монотонной (дополнительное ограничение для строгой монотонности: разность не должна равняться нулю).
Отдельно следует рассматривать случай [latex]n \le 1[/latex]. По определению, последовательность [latex]\left\{ { a }_{ n } \right\}[/latex] — монотонна [latex]\Leftrightarrow \forall i,j\in N, j>i: a_{ i }\prec a_{ j } (a_{ i }\succ a_{ j })[/latex]. Последовательность из одного элемента имеет вид [latex]\left\{a_{n}\right\} = a_{1}[/latex], следовательно, невозможно выбрать такие [latex]i,j \in N ,j>i[/latex], чтобы выполнилось условие строгой монотонности. Рассмотренный пример является частным случаем понятия «vacuous truth», часто применяемого при доказательстве теорем.

Программный код

#include <cstdio>
int sign(double x){
	return (x > 0) - (x < 0);
}

int main() {
	size_t n; scanf("%d", &n);
	double x[n][n];
	for(size_t i = 0; i < n; i++)
		for(size_t j = 0; j < n; j++)
			scanf("%lf", &x[i][j]);
			
	if(n >= 1) {
		for(size_t i = 0; i < n; i++){
			/*последовательность монотонна, если сохраняет знак разность
			между N-м и (N-1)-м членом последовательности.*/
			int prev_sign = sign(x[i][1] - x[i][0]); //знак разности первой пары чисел
			bool monotonic = true;
			for(size_t j = 1; j < n; j++){
				int new_sign = sign(x[i][j] - x[i][j - 1]); //знак разности следующей пары
				if(prev_sign * new_sign <= 0){
					monotonic = false; 
					j = n;
				}
				prev_sign = new_sign; //новая пара для сравнения
			}
			if(monotonic) printf("%d ", i + 1);
		}
	}
	else printf("1\n");
	return 0;
}

#include <cstdio>

int sign(double x){

return (x > 0) - (x < 0);

}

int main() {

size_t n; scanf("%d", &n);

double x[n][n];

for(size_t i = 0; i < n; i++)

for(size_t j = 0; j < n; j++)

scanf("%lf", &x[i][j]);

if(n >= 1) {

for(size_t i = 0; i < n; i++){

/*последовательность монотонна, если сохраняет знак разность

между N-м и (N-1)-м членом последовательности.*/

int prev_sign = sign(x[i][1] - x[i][0]); //знак разности первой пары чисел

bool monotonic = true;

for(size_t j = 1; j < n; j++){

int new_sign = sign(x[i][j] - x[i][j - 1]); //знак разности следующей пары

if(prev_sign * new_sign <= 0){

monotonic = false;

j = n;

}

prev_sign = new_sign; //новая пара для сравнения

}

if(monotonic) printf("%d ", i + 1);

}

else printf("1\n");

return 0;

}

import java.util.*;
import java.io.*;
import java.math.*;
 
class Ideone { 
    public static void main(String args[]) {
 		Scanner in = new Scanner(System.in);
 		int n = in.nextInt();
 		double[][] x = new double[n][n];
 		for(int i = 0; i < n; i++)   		
 			for(int j = 0; j < n; j++)
 				x[i][j] = in.nextDouble();
 		if(n >= 1){
 			for(int i = 0; i < n; i++){
 				/*последовательность монотонна, если сохраняет знак разность
            	между N-м и (N-1)-м членом последовательности.*/
            	double prevSign = Math.signum(x[i][1] - x[i][0]); //знак разности первой пары чисел
            	boolean monotonic = true;
            	for(int j = 1; j < n; j++){
	                double newSign = Math.signum(x[i][j] - x[i][j-1]); //знак разности следующей пары
                	if(prevSign * newSign <= 0){
	                    monotonic = false; 
                    	j = n;
                	}
                	prevSign = newSign; //новая пара для сравнения
            	}
            	if(monotonic) System.out.println(i+1);
	        }
    	}
    	else System.out.println(1);
	}
}

import java.util.*;

import java.io.*;

import java.math.*;

class Ideone {

public static void main(String args[]) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

double[][] x = new double[n][n];

for(int i = 0; i < n; i++)

for(int j = 0; j < n; j++)

x[i][j] = in.nextDouble();

if(n >= 1){

for(int i = 0; i < n; i++){

/*последовательность монотонна, если сохраняет знак разность

между N-м и (N-1)-м членом последовательности.*/

double prevSign = Math.signum(x[i][1] - x[i][0]); //знак разности первой пары чисел

boolean monotonic = true;

for(int j = 1; j < n; j++){

double newSign = Math.signum(x[i][j] - x[i][j-1]); //знак разности следующей пары

if(prevSign * newSign <= 0){

monotonic = false;

j = n;

}

prevSign = newSign; //новая пара для сравнения

}

if(monotonic) System.out.println(i+1);

}

else System.out.println(1);

}

Детали реализации

Считывание элементов строки может прекратиться в трех случаях: если монотонность сменяется с возрастания на убывание (или наоборот), или если найдены два равных соседних элемента. Для выхода из внутреннего цикла применяется присваивание [latex]j = n[/latex].
Для корректной работы внутреннего цикла первый элемент строки считывается перед ним.
Проверить, изменяется ли знак разности соседних элементов последовательности можно двумя способами: первый подразумевает умножение двух разностей, второй — реализацию функции signum(). Так как при умножении можно выйти за границы типа, выбран был второй способ.

Программа доступна для тестирования по ссылке: http://ideone.com/n60As6.
Реализация на Java: http://ideone.com/CnFow1

Related Images:

А412в

12/11/2014 by Карагяур Мілан Сергійович

Задача: Даны две целочисленные квадратные матрицы порядка 6. Найти последовательность из нулей и единиц [latex]b_{1},\ldots,b_{6}[/latex] такую, что [latex]b_{i}=1[/latex], когда:

в)[latex]i[/latex]-e строки первой и второй матриц содержат вместе не более трех положительных элементов;

Первая матрица	Вторая матрица	[latex]b_{1},\ldots,b_{6}[/latex]
2 4 5 -1 -2 -3 -1 -2 -3 1 -3 -2 2 4 5 -1 -2 -3 2 4 5 -1 -2 -3 -1 -2 -3 1 -3 -2 2 4 5 -1 -2 -3	2 4 5 -1 -2 -3 -1 -2 -3 1 -3 -2 2 4 5 -1 -2 -3 2 4 5 -1 -2 -3 -1 -2 -3 1 -3 -2 2 4 5 -1 -2 -3	010010
8 5 -2 -4 -2 -1 -1 -2 0 1 0 2 11 -4 6 0 0 -3 1 3 -5 0 2 -3 -11 0 -3 1 -3 -2 1 -4 4 0 0 0	0 0 0 0 0 0 -7 -4 -5 1 -4 -2 2 -4 0 -1 -2 -3 3 1 -5 9 -6 -7 -1 -2 -3 0 -3 2 2 4 5 5 7 8	111010

#include <iostream>
using namespace std;

const int n = 6 ;
 
int Read(int a[n][n])
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cin >> a[i][j];
		}	
	}
}
 
int main() {
	int a[n][n];
	int b[n][n];
	int c[n];
	int count = 0;
	Read(a);
	Read(b);
	for (int i = 0; i < n; i++)
	{
		count = 0;
		for (int j = 0; j < n; j++)
		{
			if (a[i][j]>0) count++;
			if (b[i][j]>0) count++;
		}	
		c[i] = count <= 3? 1: 0;
	}
	for (int j = 0; j < n; j++)
		{
			cout<<c[j];
		}	
	
	return 0;
}

#include <iostream>

using namespace std;

const int n = 6 ;

int Read(int a[n][n])

{

for (int i = 0; i < n; i++)

{

for (int j = 0; j < n; j++)

{

cin >> a[i][j];

}

int main() {

int a[n][n];

int b[n][n];

int c[n];

int count = 0;

Read(a);

Read(b);

for (int i = 0; i < n; i++)

{

count = 0;

for (int j = 0; j < n; j++)

{

if (a[i][j]>0) count++;

if (b[i][j]>0) count++;

}

c[i] = count <= 3? 1: 0;

}

for (int j = 0; j < n; j++)

{

cout<<c[j];

}

return 0;

}

Вводим две матрицы 6×6. Создаем одномерный массив с шестью элементами. В цикле просматриваем одновременно обе строки каждого массива и если находим положительный элемент то увеличиваем счетчик на один. Проверяем значение счетчика, если оно меньше трех, то в одномерный массив записываем 1, если больше, то 0.

Код программы на Java:

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{

	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int n = 6 ;
		int[][]a=new int[n][n];
		int[][]b=new int[n][n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				a[i][j]=in.nextInt();
			}	
		}
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				b[i][j]=in.nextInt();
			}	
		}
		int[]c=new int[n];
		int count = 0;
		for (int i = 0; i < n; i++)
		{
			count = 0;
			for (int j = 0; j < n; j++)
			{
				if (a[i][j]>0) count++;
				if (b[i][j]>0) count++;
			}	
			c[i] = count <= 3? 1: 0;
		}
		for (int j = 0; j < n; j++)
			{
				System.out.print(c[j]);
			}	
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

int n = 6 ;

int[][]a=new int[n][n];

int[][]b=new int[n][n];

for (int i = 0; i < n; i++)

{

for (int j = 0; j < n; j++)

{

a[i][j]=in.nextInt();

}

for (int i = 0; i < n; i++)

{

for (int j = 0; j < n; j++)

{

b[i][j]=in.nextInt();

}

int[]c=new int[n];

int count = 0;

for (int i = 0; i < n; i++)

{

count = 0;

for (int j = 0; j < n; j++)

{

if (a[i][j]>0) count++;

if (b[i][j]>0) count++;

}

c[i] = count <= 3? 1: 0;

}

for (int j = 0; j < n; j++)

{

System.out.print(c[j]);

}

Ideone.

Related Images:

А412б

11/11/2014 by Зелінський Вячеслав Олександрович

Задача. Даны две целочисленные квадратные матрицы порядка 6.
Найти последовательность из нулей и единиц [latex]b_{1}[/latex], \ldots, [latex]b_{6}[/latex] такую, что [latex]b_{i} = 1[/latex], когда
б) все элементы i-х строк первой и второй матриц
отрицательны;

[latex]M_1[/latex]	[latex]M_2[/latex]	[latex]b_1, \dots, b_6[/latex]
-2 -3 -4 -5 -6 -7 1 2 3 3 3 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1	-1 -2 -3 -6 -7 -2 1 2 2 2 2 2 4 4 4 4 4 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1	1 0 0 0 0 0
-7 -31 -4 -9 -8 -7 5 3 2 9 5 3 -4 -1 -1 -2 -8 -5 1 2 1 3 1 1 1 7 1 1 4 1 1 23 1 8 1 1	-1 -2 -3 -6 -7 -2 1 2 2 2 2 2 -4 -9 -4 -12 -7 -4 3 1 1 5 1 1 6 13 11 1 19 1 24 1 5 7 1 9	1 0 1 0 0 0
4 -37 12 -5 8 -7 -16 -8 -9 -3 -2 -3 -4 -1 -1 -2 -8 -5 -3 -2 -1 -2 -1 -7 3 7 1 1 4 1 1 23 1 8 8 1	-1 -2 -3 -6 -7 -2 -1 -2 -2 -2 -2 -2 -8 7 -4 15 -6 -4 -3 -7 -1 -5 -22 -1 6 13 11 12 19 1 24 1 5 7 1 11	0 1 0 1 0 0

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

#include <iostream>
using namespace std;
 
int main() 
{
 	const int n=6;
	int M1[n][n], M2[n][n], B[n];  
	for(int i=0; i<n; i++) {
		for(int j=0; j<n; j++) {
			cin >> M1[i][j];  //Чтение из стандартного потока.
		}
	}
    for(int i=0; i<n; i++) {
		for(int j=0; j<n; j++) {
			cin >> M2[i][j];  //Чтение из стандартного потока.
		}
	}
    for(int i=0; i<n; i++) {
		B[i]=1;
	}
	for(int i=0; i<n; i++) {
		for(int j=0; j<n; j++) {
			if (M1[i][j]>=0 || M2[i][j]>=0) {
				B[i]=0;  
				break;
			}
		}
	}
    for(int i=0; i<n; i++) {
	     cout << B[i]<< " ";
	}
    return 0;
}

#include <iostream>

using namespace std;

int main()

{

const int n=6;

int M1[n][n], M2[n][n], B[n];

for(int i=0; i<n; i++) {

for(int j=0; j<n; j++) {

cin >> M1[i][j]; //Чтение из стандартного потока.

}

for(int i=0; i<n; i++) {

for(int j=0; j<n; j++) {

cin >> M2[i][j]; //Чтение из стандартного потока.

}

for(int i=0; i<n; i++) {

B[i]=1;

}

for(int i=0; i<n; i++) {

for(int j=0; j<n; j++) {

if (M1[i][j]>=0 || M2[i][j]>=0) {

B[i]=0;

break;

}

for(int i=0; i<n; i++) {

cout << B[i]<< " ";

}

return 0;

}

По условию задачи необходимо вывести последовательность [latex]b_{1}, \ldots, b_{6}[/latex] из «1» и «0», при том «1» выводится если в соответствующих строках двух вводимых с клавиатуры матриц все элементы отрицательные. Для этого опишем две матрицы порядка 6 на 6 и два счетчика. Затем создадим циклы для ввода элементов матриц. Потом присваиваем элементам последовательности [latex]b_{1}, \ldots, b_{6}[/latex] 1. Затем в цикле при условии, что элементы матрицы не отрицательные присваиваем [latex]B[i][/latex] 0 и выходим из цикла. Если в строке двух матриц не встретилось ни одного числа большего либо равного 0, то [latex]b_{i}[/latex] осталось равным 1. И выводим массив [latex]b[i][/latex].
Для проверки работы программы можно воспользоваться объектом.

Код на Java:

import java.util.*;
import java.lang.*;
import java.io.*;


class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int n=6;
		int []B = new int[n];
		int [][]M1 = new int[n][n];
		int [][]M2 = new int[n][n];
		for(int i=0; i<n; i++) {
			for(int j=0; j<n; j++) {
				M1[i][j]=in.nextInt(); 
			}
		}
	    for(int i=0; i<n; i++) {
			for(int j=0; j<n; j++) {
				M2[i][j] = in.nextInt();  
			}
		}
	    for(int i=0; i<n; i++) {
				B[i]=1;
		}
		for(int i=0; i<n; i++) {
			for(int j=0; j<n; j++) {
				if (M1[i][j]>=0 || M2[i][j]>=0) {
					B[i]=0;  
					break;
				}
			}
		}
	    for(int i=0; i<n; i++) {
		     System.out.println(B[i]+" ");
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static void main (String[] args) throws java.lang.Exception

{

Scanner in = new Scanner(System.in);

int n=6;

int []B = new int[n];

int [][]M1 = new int[n][n];

int [][]M2 = new int[n][n];

for(int i=0; i<n; i++) {

for(int j=0; j<n; j++) {

M1[i][j]=in.nextInt();

}

for(int i=0; i<n; i++) {

for(int j=0; j<n; j++) {

M2[i][j] = in.nextInt();

}

for(int i=0; i<n; i++) {

B[i]=1;

}

for(int i=0; i<n; i++) {

for(int j=0; j<n; j++) {

if (M1[i][j]>=0 || M2[i][j]>=0) {

B[i]=0;

break;

}

for(int i=0; i<n; i++) {

System.out.println(B[i]+" ");

}

Related Images:

А401

10/11/2014 by Ілларіонова Марія Валеріївна

Дана действительная квадратная матрица порядка [latex]n[/latex], натуральные числа [latex]i, j \left(1\leq i\leq n, 1\leq j\leq n \right)[/latex]. Из матрицы удалить [latex]i[/latex]-строку и [latex]j[/latex]-столбец.

[latex]n[/latex]	Матрица.	[latex]i[/latex]	[latex]j[/latex]	Полученная матрица.	Комментарий.
3	1 2 3 4 5 6 7 8 9	2	1	2 3 8 9	Тест пройден.
4	0,5 1 6 0 3 8 12 0,3 10 4,6 8 9 0 3,5 6,4 10	4	3	0,5 1 0 3 8 0,3 10 4,6 9	Тест пройден.
2	-40 87 9 -3	1	1	-3	Тест пройден.

Код программы (C++):

#include <iostream>
using namespace std;
 
int main() {
	int n;
	cin >> n;
	double **m;
	m=new double *[n];
	for (int i=0; i<n; i++)	m[i]=new double [n];
	double **m1;
	m1=new double *[n-1];
	for (int i=0; i<n-1; i++)	m1[i]=new double [n-1];
	for (int i=0; i<n; i++) {
		for (int j=0; j<n; j++) {
			cin >> m[i][j];
		}
	}
	int i0, j0;
	cin >> i0 >> j0;
	for (int i=0, tr=0; tr<n-1;) {
		if (i!=i0-1) {
			for (int j=0, td=0; td<n-1; j++, td++) {
				if (j==j0-1) j++;
				m1[tr][td]=m[i][j];
			}
			i++;
			tr++;
		}
		else i++;
	}
	delete []m;
	m=m1;
	for (int i=0; i<n-1; i++) {
		for (int j=0; j<n-1; j++) {
			printf ("%5.3lf\t", m[i][j]);
		}
		cout << endl;
	}
	return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

cin >> n;

double **m;

m=new double *[n];

for (int i=0; i<n; i++) m[i]=new double [n];

double **m1;

m1=new double *[n-1];

for (int i=0; i<n-1; i++) m1[i]=new double [n-1];

for (int i=0; i<n; i++) {

for (int j=0; j<n; j++) {

cin >> m[i][j];

}

int i0, j0;

cin >> i0 >> j0;

for (int i=0, tr=0; tr<n-1;) {

if (i!=i0-1) {

for (int j=0, td=0; td<n-1; j++, td++) {

if (j==j0-1) j++;

m1[tr][td]=m[i][j];

}

i++;

tr++;

}

else i++;

}

delete []m;

m=m1;

for (int i=0; i<n-1; i++) {

for (int j=0; j<n-1; j++) {

printf ("%5.3lf\t", m[i][j]);

}

cout << endl;

}

return 0;

}

Java:

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone {
	public static void main (String[] args) {
		Scanner in = new Scanner (System.in);
		int n;
		n = in.nextInt();
		double [][]m = new double[n][n];
		double [][]m1 = new double[n-1][n-1];
		for (int i=0; i<n; i++) {
			for (int j=0; j<n; j++) {
				m[i][j] = in.nextDouble();
			}
		}
		int i0, j0;
		i0 = in.nextInt();
		j0 = in.nextInt();
		for (int i=0, tr=0; tr<n-1;) {
			if (i!=i0-1) {
				for (int j=0, td=0; td<n-1; j++, td++) {
					if (j==j0-1) j++;
					m1[tr][td]=m[i][j];
				}
				i++;
				tr++;
			}
			else i++;
		}
		m=m1;
		for (int i=0; i<n-1; i++) {
			for (int j=0; j<n-1; j++) {
				System.out.print(m[i][j]+"    ");
			}
			System.out.println();
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone {

public static void main (String[] args) {

Scanner in = new Scanner (System.in);

int n;

n = in.nextInt();

double [][]m = new double[n][n];

double [][]m1 = new double[n-1][n-1];

for (int i=0; i<n; i++) {

for (int j=0; j<n; j++) {

m[i][j] = in.nextDouble();

}

int i0, j0;

i0 = in.nextInt();

j0 = in.nextInt();

for (int i=0, tr=0; tr<n-1;) {

if (i!=i0-1) {

for (int j=0, td=0; td<n-1; j++, td++) {

if (j==j0-1) j++;

m1[tr][td]=m[i][j];

}

i++;

tr++;

}

else i++;

}

m=m1;

for (int i=0; i<n-1; i++) {

for (int j=0; j<n-1; j++) {

System.out.print(m[i][j]+" ");

}

System.out.println();

}

Сначала пользователю предлагается ввести порядок матрицы, затем элементы этой матрицы. После чего, по условию задачи, пользователь должен задать [latex]i[/latex]-строку и [latex]j[/latex]-столбец, которые программа должна изъять из матрицы.

Протестировать программу можно здесь (C++) и здесь (Java).

Related Images:

Ю4.7

03/11/2014 by Фесенко Катерина Володимирівна

Задача. В матрице [latex] z(n,n)[/latex] каждый элемент разделить на диагональный, стоящий в том же столбце.

Тест

при [latex] n=3[/latex] (элементы главной диагонали выделены )

5	4	9
3	1	7
8	6	2

↓

1	4	4.5
0.6	1	3.5
1.6	6	1

Проверим совсем простой вариант, для наглядности:

при [latex] n=2[/latex]

4	5
2	10

↓

1	0.5
0.5	1

Код на языке С++ :

#include <iostream>
# include <math.h>
using namespace std;


int main() {
	int n;
	cin >> n;
	double z[n][n], c;
	
	// Ввод матрицы z
	for( int i = 0; i < n; i++)
	{
		for( int j = 0; j < n; j++)
		{
			cin >> z[i][j];
		}
	}
			
		
		// Вывод матрицы z
		for (int  j = 0; j < n; j++)
    	{
			c = z[j][j];
			for (int i = 0; i < n; i++)
			{
				z[i][j] = z [i][j] / c;
				cout << z[i][j] << " ";
			}
			cout << endl;
		}
	
	return 0;
 }

#include <iostream>

# include <math.h>

using namespace std;

int main() {

int n;

cin >> n;

double z[n][n], c;

// Ввод матрицы z

for( int i = 0; i < n; i++)

{

for( int j = 0; j < n; j++)

{

cin >> z[i][j];

}

// Вывод матрицы z

for (int j = 0; j < n; j++)

{

c = z[j][j];

for (int i = 0; i < n; i++)

{

z[i][j] = z [i][j] / c;

cout << z[i][j] << " ";

}

cout << endl;

}

return 0;

}

Ссылка на программу: http://ideone.com/ecqIxL

Решение:

Вводим квадратную матрицу [latex] z(n,n)[/latex].Потом описываем элемент, который будет делиться диагональным:

for( int i = 0; i < n; i++)
	{
		for( int j = 0; j < n; j++)
		{
			cin >> z[i][j];
		}
	}

for( int i = 0; i < n; i++)

{

for( int j = 0; j < n; j++)

{

cin >> z[i][j];

}

Следующим шагом будет описание диагонального элемента во вложенном цикле, который определяет элемент в столбце и непосредственно деление диагонального элемента на элемента, стоящий в том же столбце.

for (int  j = 0; j < n; j++)
    	{
			c = z[j][j];
			for (int i = 0; i < n; i++)
			{
				z[i][j] = z [i][j] / c;
				cout << z[i][j] << " ";
			}
			cout << endl;
		}

for (int j = 0; j < n; j++)

{

c = z[j][j];

for (int i = 0; i < n; i++)

{

z[i][j] = z [i][j] / c;

cout << z[i][j] << " ";

}

cout << endl;

}

Выводим значение полученной матрицы.

Код на языке Java:

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Ideone
{
	public static void main (String[] args) {
		int n;
		double c;
	    Scanner sc = new Scanner (System.in);
		n = sc.nextInt();	
		double[][] z = new double [n][n];
	for( int i = 0; i < n; i++)
	{
		for( int j = 0; j < n; j++)
		{
		 	z[i][j] = sc.nextInt();
		}
	}	
	for (int  j = 0; j < n; j++)
    	{
    		System.out.println();
			c = z[j][j];
			for (int i = 0; i < n; i++)
			{
				z[i][j] = z [i][j] / c;
				System.out.print(z[i][j]+" ");
			}
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static void main (String[] args) {

int n;

double c;

Scanner sc = new Scanner (System.in);

n = sc.nextInt();

double[][] z = new double [n][n];

for( int i = 0; i < n; i++)

{

for( int j = 0; j < n; j++)

{

z[i][j] = sc.nextInt();

}

for (int j = 0; j < n; j++)

{

System.out.println();

c = z[j][j];

for (int i = 0; i < n; i++)

{

z[i][j] = z [i][j] / c;

System.out.print(z[i][j]+" ");

}

Ссылка на программу: http://ideone.com/dT5GVl

Related Images:

Ю11.16

24/10/2014 by Іванов Вячеслав Володимирович

Задача:
Для заданной матрицы [latex]A(n, n)[/latex] найти обратную [latex]A^{-1}[/latex], используя итерационную формулу:
[latex]A_{k}^{-1} = A_{k-1}^{-1}(2E-A A_{k}^{-1}),[/latex] где [latex]E[/latex] — единичная матрица, [latex]A_{0}^{-1} = E[/latex]. Итерационный процесс заканчивается, если для заданной погрешности [latex]\varepsilon[/latex] справедливо:
[latex]\left| det(A A_{k}^{-1})-1 \right| \le \varepsilon[/latex]

Анализ задачи:
Прежде чем приступать к решению средствами языка C++, я создал прототип в системе компьютерной алгебры Wolfram Mathematica, с которым планировал сверяться при тестировании программы. Тем не менее, внимательный анализ показал, что с таким выбором начального приближения процесс уже на пятом шаге в значительной мере расходится даже для матриц размера 2*2. После уточнения условий и анализа дополнительного материала, посвященного методу Ньютона-Шульца, исходное приближение было изменено (по результатам исследования «An Improved Newton Iteration for the Generalized Inverse of a Matrix, with Applications», Victor Pan, Robert Schreiber, стр. 8):
[latex]A_{0}^{-1} =\frac { A }{ \left\| A \right\|_{1} \left\| A \right\| _{\infty } }[/latex], где [latex]{ \left\| A \right\| }_{ 1 }=\max _{ i }{ \sum _{ j=0 }^{ n-1 }{ \left| { a }_{ ij } \right| } } [/latex], [latex]{ \left\| A \right\| }_{ \infty }=\max _{ j }{ \sum _{ i=0 }^{ n-1 }{ \left| { a }_{ ij } \right| } }[/latex].
Эффективность предложенного подхода иллюстрируют результаты работы прототипа:

Следовательно, из пространства задачи можно переместиться в пространство решения и составить алгоритм реализации предложенного метода на языке C++.

Тесты:

[latex]n[/latex]	[latex]A[/latex]	[latex]A^{-1}[/latex]	Результат
3	1 2 3 5 5 7 11 13 7	-0.964771 0.430661 -0.017183 0.723533 -0.447973 0.137884 0.172358 0.155200 -0.086211	Пройден
2	1 2 2 1	-0.333067 0.666400 0.666400 -0.333067	Пройден
5	1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1	1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1	Пройден
3	1 2 3 4 5 6 7 8 9	Матрица вырождена	Пройден

Программный код:

#include <cstdio>
#include <algorithm>
#include <cmath>
//очистить выделенную память
void clear(double **arr, int n)
{
    for(int i = 0; i < n; i++)
        delete[] arr[i];
    delete[] arr;
}
//создать копию массива
double** clone(double **arr, int n)
{
    double **newArr = new double*[n];
    for(int row = 0; row < n; row++)
    {
        newArr[row] = new double[n];
        for(int col = 0; col < n; col++)
            newArr[row][col] = arr[row][col];
    }
    return newArr;
}
//print the matrix
void show(double **matrix, int n)
{
    for(int row = 0; row < n; row++){
            for(int col = 0; col < n; col++)
                printf("%lf\t", matrix[row][col]);
            printf("\n");
    }
    printf("\n");
}
//матричное умножение матриц
double** matrix_multi(double **A, double **B, int n)
{
    double **result = new double*[n];
    //заполнение нулями
    for(int row = 0; row < n; row++){
        result[row] = new double[n];
        for(int col = 0; col < n; col++){
            result[row][col] = 0;
        }
    }

    for(int row = 0; row < n; row++){
        for(int col = 0; col < n; col++){
            for(int j = 0; j < n; j++){
                result[row][col] += A[row][j] * B[j][col];
            }
        }
    }
    return result;
}
//умножение матрицы на число
void scalar_multi(double **m, int n, double a){
    for(int row = 0; row < n; row++)
        for(int col = 0; col < n; col++){
            m[row][col] *= a;
        }
}
//вычисление суммы двух квадратных матриц
void sum(double **A, double **B, int n)
{
    for(int row = 0; row < n; row++)
        for(int col = 0; col < n; col++)
            A[row][col] += B[row][col];
}

//вычисление определителя
double det(double **matrix, int n) //квадратная матрица размера n*n
{
    double **B = clone(matrix, n);
    //приведение матрицы к верхнетреугольному виду
    for(int step = 0; step < n - 1; step++)
        for(int row = step + 1; row < n; row++)
        {
            double coeff = -B[row][step] / B[step][step]; //метод Гаусса
            for(int col = step; col < n; col++)
                B[row][col] += B[step][col] * coeff;
        }
    //Рассчитать определитель как произведение элементов главной диагонали
    double Det = 1;
    for(int i = 0; i < n; i++)
        Det *= B[i][i];
    //Очистить память
    clear(B, n);
    return Det;
}

int main()
{
    //Исходная матрица, динамический двухмерный массив
    int n; scanf("%d", &n);
    double **A = new double*[n];
    for(int row = 0; row < n; row++)
    {
        A[row] = new double[n];
            for(int col = 0; col < n; col++)
                scanf("%lf", &A[row][col]);
    }

    /* Численное вычисление обратной матрицы по методу Ньютона-Шульца
        1. Записать начальное приближение [Pan, Schreiber]:
            1) Транспонировать данную матрицу
            2) Нормировать по столбцам и строкам
        2. Повторять процесс до достижения заданной точности.
    */

    double N1 = 0, Ninf = 0; //норма матрицы по столбцам и по строкам
    double **A0 = clone(A, n);       //инициализация начального приближения
    for(size_t row = 0; row < n; row++){
        double colsum = 0, rowsum = 0;
        for(size_t col = 0; col < n; col++){
            rowsum += fabs(A0[row][col]);
            colsum += fabs(A0[col][row]);
        }
        N1 = std::max(colsum, N1);
        Ninf = std::max(rowsum, Ninf);
    }
    //транспонирование
    for(size_t row = 0; row < n - 1; row++){
        for(size_t col = row + 1; col < n; col++)
            std::swap(A0[col][row], A0[row][col]);
    }
    scalar_multi(A0, n, (1 / (N1 * Ninf))); //нормирование матрицы
    //инициализация удвоенной единичной матрицы нужного размера
    double **E2 = new double*[n];
    for(int row = 0; row < n; row++)
    {
        E2[row] = new double[n];
            for(int col = 0; col < n; col++){
                if(row == col)
                    E2[row][col] = 2;
                else
                    E2[row][col] = 0;
            }
    }
    double **inv = clone(A0, n); //A_{0}
    double EPS = 0.001;   //погрешность
    if(det(A, n) != 0){ //если матрица не вырождена
        while(fabs(det(matrix_multi(A, inv, n), n) - 1) >= EPS) //пока |det(A * A[k](^-1)) - 1| >= EPS
        {
            double **prev = clone(inv, n); //A[k-1]
            inv = matrix_multi(A, prev, n);   //A.(A[k-1]^(-1))
            scalar_multi(inv, n, -1);         //-A.(A[k-1]^(-1))
            sum(inv, E2, n);                   //2E - A.(A[k-1]^(-1))
            inv = matrix_multi(prev, inv, n); //(A[k-1]^(-1)).(2E - A.(A[k-1]^(-1)))
            clear(prev, n);
        }
        //вывод матрицы на экран
        show(inv, n);
    }
    else
        printf("Impossible\n");
    clear(A, n);
    clear(E2, n);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

#include <cstdio>

#include <algorithm>

#include <cmath>

//очистить выделенную память

void clear(double **arr, int n)

{

for(int i = 0; i < n; i++)

delete[] arr[i];

delete[] arr;

}

//создать копию массива

double** clone(double **arr, int n)

{

double **newArr = new double*[n];

for(int row = 0; row < n; row++)

{

newArr[row] = new double[n];

for(int col = 0; col < n; col++)

newArr[row][col] = arr[row][col];

}

return newArr;

}

//print the matrix

void show(double **matrix, int n)

{

for(int row = 0; row < n; row++){

for(int col = 0; col < n; col++)

printf("%lf\t", matrix[row][col]);

printf("\n");

}

printf("\n");

}

//матричное умножение матриц

double** matrix_multi(double **A, double **B, int n)

{

double **result = new double*[n];

//заполнение нулями

for(int row = 0; row < n; row++){

result[row] = new double[n];

for(int col = 0; col < n; col++){

result[row][col] = 0;

}

for(int row = 0; row < n; row++){

for(int col = 0; col < n; col++){

for(int j = 0; j < n; j++){

result[row][col] += A[row][j] * B[j][col];

}

return result;

}

//умножение матрицы на число

void scalar_multi(double **m, int n, double a){

for(int row = 0; row < n; row++)

for(int col = 0; col < n; col++){

m[row][col] *= a;

}

//вычисление суммы двух квадратных матриц

void sum(double **A, double **B, int n)

{

for(int row = 0; row < n; row++)

for(int col = 0; col < n; col++)

A[row][col] += B[row][col];

}

//вычисление определителя

double det(double **matrix, int n) //квадратная матрица размера n*n

{

double **B = clone(matrix, n);

//приведение матрицы к верхнетреугольному виду

for(int step = 0; step < n - 1; step++)

for(int row = step + 1; row < n; row++)

{

double coeff = -B[row][step] / B[step][step]; //метод Гаусса

for(int col = step; col < n; col++)

B[row][col] += B[step][col] * coeff;

}

//Рассчитать определитель как произведение элементов главной диагонали

double Det = 1;

for(int i = 0; i < n; i++)

Det *= B[i][i];

//Очистить память

clear(B, n);

return Det;

}

int main()

{

//Исходная матрица, динамический двухмерный массив

int n; scanf("%d", &n);

double **A = new double*[n];

for(int row = 0; row < n; row++)

{

A[row] = new double[n];

for(int col = 0; col < n; col++)

scanf("%lf", &A[row][col]);

}

/* Численное вычисление обратной матрицы по методу Ньютона-Шульца

1. Записать начальное приближение [Pan, Schreiber]:

1) Транспонировать данную матрицу

2) Нормировать по столбцам и строкам

2. Повторять процесс до достижения заданной точности.

double N1 = 0, Ninf = 0; //норма матрицы по столбцам и по строкам

double **A0 = clone(A, n); //инициализация начального приближения

for(size_t row = 0; row < n; row++){

double colsum = 0, rowsum = 0;

for(size_t col = 0; col < n; col++){

rowsum += fabs(A0[row][col]);

colsum += fabs(A0[col][row]);

}

N1 = std::max(colsum, N1);

Ninf = std::max(rowsum, Ninf);

}

//транспонирование

for(size_t row = 0; row < n - 1; row++){

for(size_t col = row + 1; col < n; col++)

std::swap(A0[col][row], A0[row][col]);

}

scalar_multi(A0, n, (1 / (N1 * Ninf))); //нормирование матрицы

//инициализация удвоенной единичной матрицы нужного размера

double **E2 = new double*[n];

for(int row = 0; row < n; row++)

{

E2[row] = new double[n];

for(int col = 0; col < n; col++){

if(row == col)

E2[row][col] = 2;

else

E2[row][col] = 0;

}

double **inv = clone(A0, n); //A_{0}

double EPS = 0.001; //погрешность

if(det(A, n) != 0){ //если матрица не вырождена

while(fabs(det(matrix_multi(A, inv, n), n) - 1) >= EPS) //пока |det(A * A[k](^-1)) - 1| >= EPS

{

double **prev = clone(inv, n); //A[k-1]

inv = matrix_multi(A, prev, n); //A.(A[k-1]^(-1))

scalar_multi(inv, n, -1); //-A.(A[k-1]^(-1))

sum(inv, E2, n); //2E - A.(A[k-1]^(-1))

inv = matrix_multi(prev, inv, n); //(A[k-1]^(-1)).(2E - A.(A[k-1]^(-1)))

clear(prev, n);

}

//вывод матрицы на экран

show(inv, n);

}

else

printf("Impossible\n");

clear(A, n);

clear(E2, n);

return 0;

}

Программа доступна для тестирования по ссылке: http://ideone.com/7YphoX.

Алгоритм решения
При решении данной задачи оправдывает себя подход «разделяй и властвуй»: вычисление обратной матрицы подразумевает промежуточные этапы, корректной реализации которых следует уделить особое внимание. Наверняка стоило бы написать класс matrix и реализовать перегрузку операций, но задачу можно решить и без применения объектно-ориентированных средств, пусть от этого решение и потеряет в изящности.
Можно выделить следующие подзадачи:

Инициализация динамического двухмерного массива и передача его в функцию.
Вычисление определителя матрицы (с применением метода Гаусса).
Вычисление нормы матрицы.
Транспонирование матрицы.
Умножение матрицы на скаляр.
Матричное умножение матриц.
Сложение двух матриц.
Непосредственно итерационный процесс Ньютона-Шульца

Ниже приведено пояснение к подходу к реализации некоторых подзадач:

Выделение памяти для хранения массива происходит не на этапе запуска программы, после компиляции. Для инициализации использован конструктор new
Вычисление определителя можно разбить на два последовательных шага:
1. Приведение матрицы к верхнетреугольному виду (методом Гаусса).
2. Вычисление определителя как произведения элементов главной диагонали.
Нормы матрицы вычисляются как максимальные значения суммы элементов по столбцам и строкам соответственно.
При транспонировании обмениваются местами элементы, симметричные главной диагонали.
При умножении матрицы на скаляр каждый элемент матрицы умножается на соответствующее вещественное число.
При перемножении двух квадратных матриц используется промежуточный массив для хранения результата вычислений.
Сложение двух матриц аналогично попарному сложению элементов, расположенных на соответствующих позициях.
Максимально допустимая погрешность для метода Ньютона-Шульца [latex]\varepsilon = 0.001[/latex]. Программа использует локальный массив для хранения [latex]A_{k}^{-1}[/latex], инициализация которого происходит в теле цикла.

Технические детали реализации:
При выполнении подзадач часто приходится использовать локальные массивы, так что для очистки выделенной под них памяти создана отдельная функция clear().