Лабиринт представляет собой квадрат, состоящий из N×N сегментов. Каждый из сегментов может быть либо пустым, либо заполненным камнем. Гарантируется, что левый верхний и правый нижний сегменты пусты. Лабиринт обнесен снизу, сверху, слева и справа стенами, оставляющими свободными только левый верхний и правый нижний углы. Директор лабиринта решил покрасить стены лабиринта, видимые изнутри. Помогите ему рассчитать количество краски, необходимой для этого.
Входные данные
В первой строке находится число N, затем идут N строк по N символов: точка обозначает пустой сегмент, решетка — сегмент со стеной.
3 ≤ N ≤ 33, размер сегмента 3×3, высота стен 3 метра.
Выходные данные
Вывести одно число — площадь видимой части внутренних стен лабиринта в квадратных метрах.
Пример
Входные данные
Выходные данные
5
. . . . .
. . . # #
. . # . .
. . # # #
. . . . .
198
C++:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <iostream>
#include <queue>
usingnamespacestd;
intcheck(introw,intcol,char**lab,int**visited,queue<int>&plan){//находим количество стен рядом с каждой клеткой
visited[row][col]=1;//отмечаем, что клетка пройдена
return4-empty;//количество стен рядом с клеткой
}
return0;
}
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
intN=in.nextInt();
char[][]lab=newchar[N+2][];
int[][]visited=newint[N+2][];
for(inti=0;i<N+2;i++){
lab[i]=newchar[N+2];
visited[i]=newint[N+2];
for(intj=0;j<N+2;j++){
visited[i][j]=0;//массив для проверки посещённости клеток
if(i==0||i==N+1||j==0||j==N+1){
lab[i][j]='*';//вокруг данного лабиринта делаем стену
}
}
}
Stringline;
for(inti=1;i<N+1;i++){
line=in.next();
for(intj=1;j<N+1;j++){
lab[i][j]=line.charAt(j-1);//заполняем лабиринт
}
}
ArrayDeque<Integer>plan=newArrayDeque<Integer>();
plan.offer(1);//начинаем считать с левой верхней клетки
plan.offer(1);
intwalls=0;
while(!plan.isEmpty()){
introw=plan.poll();
intcol=plan.poll();
walls+=check(row,col,lab,visited,plan);
}
if(visited[N][N]!=1){//если не попали в правую нижнюю клетку
plan.offer(N);//считаем начиная с неё
plan.offer(N);
while(!plan.isEmpty()){
introw=plan.poll();
intcol=plan.poll();
walls+=check(row,col,lab,visited,plan);
}
}
walls-=4;//стены у левого верхнего и правого нижнего угла отсутствуют
intmeters=walls*9;
System.out.println(meters);
}
}
Для решения задачи я использовала алгоритм поиска в ширину: начиная с левой верхней клетки, которая гарантированно пуста, проверяю все смежные с ней и заношу их в план проверки. Для каждой клетки считаю количество пустых смежных клеток и получаю число стен рядом с ней. Чтобы было удобно проверять смежные клетки на пустоту, я сделала «стену» вокруг данного лабиринта. После проверки клетки отмечаю, что она просмотрена.
Так как в условии не гарантируется, что есть проход от левой верхней до правой нижней клетки, проверяю, посещена ли последняя. Если нет, снова запускаю поиск, начиная с неё.
Задача: В строке вставить после предпоследнего символа первый и второй символ строки. Если длина строки меньше четырех, то вывести, что это сделать невозможно.
Дана строка [latex]s1[/latex]. Переписываем из неё в строку [latex]s2[/latex] все символы, кроме последнего. Добавляем первый, второй и последний символ строки [latex]s1[/latex] в строку [latex]s2[/latex].
Задача: Для двух заданных строк символов найти самую длинную общую подстроку. Пробелы и знаки препинания игнорировать, строчные и прописные буквы считать неразличимыми. Например, строки: «Дай вилку! Бок севрюжий кончается» и «Чемпионский кубок достался не нам» содержат общую подстроку «кубок».
Строка а
Строка b
Результат
Комментарий
Q_+wer ty
q!w ert) q
qwert
Тест пройден
`Curiouser and curiouser!’ cried Alice (she was so much surprised, that for the moment she quite forgot how to speak good English); `now I’m opening out like the largest telescope that ever was!
Good-bye, feet!’ (for when she looked down at her feet, they seemed to be almost out of sight, they were getting so far off). `Oh, my poor little feet, I wonder who will put on your shoes and stockings for you now, dears?
tfor good
Тест пройден
Qwe^r ty
qwE r!ty
qwerty
Тест пройден
C++:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#include <iostream>
#include <string>
#include <cctype>
usingnamespacestd;
intmain(){
stringa,b;
getline(cin,a);
getline(cin,b);
stringa2,b2;
for(autoi:a){
if(isalpha(i)){
a2.push_back(tolower(i));//Избавляемся от всех знаков кроме букв и понижаем регистр.
}
}
for(autoi:b){
if(isalpha(i)){
b2.push_back(tolower(i));
}
}
if(a2==b2){
cout<<a2;//Если строки равны, сразу возвращаем значение одной из них.
return0;
}
stringc;
for(unsignedinti=0;i<a2.size();i++){//Сравниваем символы в строках.
c+=a2.charAt(k);//Те, которые совпали, записываем в новую строку.
}else{
break;
}
}
c+=' ';
}
}
}
intr=0,max=0;//В получившейся строке считаем, сколько букв в самом большом слове.
Stringc2=newString();
Stringmaxstr=newString();
for(inti=0;i<c.length();i++){
if(c.charAt(i)!=' '){
r++;
}else{
if(r>max){
max=r;
}
r=0;
}
}
for(inti=0;i<c.length();i++){//Ищем слова такой же длины и записываем их в строку для вывода черех пробел.
if(c.charAt(i)!=' '){
c2+=c.charAt(i);
}else{
if(c2.length()==max){
for(intj=0;j<c2.length();j++){
maxstr+=c2.charAt(j);
}
maxstr+=' ';
}
c2=newString();
}
}
System.out.println(maxstr);
}
}
}
Даны строки [latex]a[/latex] и [latex]b[/latex]. Сначала переписываем их в строки [latex]a2[/latex] и [latex]b2[/latex], при этом избавляясь от всех символов, кроме букв, и понижая их регистр.
Чтобы выделить все совпадающие комбинации букв, сравниваем каждый символ из [latex]a2[/latex] подряд со всеми символами из [latex]b2[/latex]. Когда находим одинаковые буквы, проверяем уже следующий символ в [latex]a2[/latex] и в [latex]b2[/latex]. Все общие подстроки записываем в строку [latex]c[/latex] через пробел.
Так как в строках может быть несколько общих подстрок наибольшей длины, сначала в строке [latex]c[/latex] считаем, сколько букв в самой длинной подстроке. А после этого ищем слова такой длины и записываем их в строку для вывода через пробел.
Метод Симпсона. Вычислить определённый интеграл [latex]I=\int_{a}^{b}{f\left(x \right)}dx[/latex] по формуле Симпсона: [latex]I\approx \frac{b-a}{6n}\left(y_{0}+4y_{1}+2y_{2}+\cdot \cdot \cdot +4y_{2n-1}+y_{2n} \right)[/latex], где [latex]2n[/latex] — количество отрезков разбиения, [latex]y_{0}[/latex], [latex]y_{1}[/latex], …, [latex]y_{2n}[/latex] — значение функции [latex]f\left(x \right)[/latex] на концах отрезков.
В задачах на численное интегрирование определённый интеграл требуется найти с заданной точностью, для чего вычисление по формуле метода рекомендуется проводить многократно, каждый раз уменьшая шаг интегрирования в два раза, пока разница между соседними приближениями не станет меньше заданной погрешности.
doublea,b,eps;//Нижний и верхний пределы интегрирования (a, b), погрешность (eps).
cin>>a>>b>>eps;
doubleI=eps+1,I1=0;//I-предыдущее вычисленное значение интеграла, I1-новое, с большим N.
for(intN=2;(N<=4)||(fabs(I1-I)>eps);N*=2)
{
doubleh,sum2=0,sum4=0,sum=0;
h=(b-a)/(2*N);//Шаг интегрирования.
for(inti=1;i<=2*N-1;i+=2)
{
sum4+=f(a+h*i);//Значения с нечётными индексами, которые нужно умножить на 4.
sum2+=f(a+h*(i+1));//Значения с чётными индексами, которые нужно умножить на 2.
}
sum=f(a)+4*sum4+2*sum2-f(b);//Отнимаем значение f(b) так как ранее прибавили его дважды.
I=I1;
I1=(h/3)*sum;
}
cout<<I1<<endl;
return0;
}
Java:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
importjava.util.*;
importjava.lang.*;
importjava.io.*;
classIdeone
{
publicstaticdoublef(doublex){
returnMath.sin(x*x+2*x);
}
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
doublea=in.nextDouble();//Нижний и верхний пределы интегрирования (a, b), погрешность (eps).
doubleb=in.nextDouble();
doubleeps=in.nextDouble();
doubleI=eps+1,I1=0;//I-предыдущее вычисленное значение интеграла, I1-новое, с большим N.
for(intN=2;(N<=4)||(Math.abs(I1-I)>eps);N*=2){
doubleh,sum2=0,sum4=0,sum=0;
h=(b-a)/(2*N);//Шаг интегрирования.
for(inti=1;i<=2*N-1;i+=2){
sum4+=f(a+h*i);//Значения с нечётными индексами, которые нужно умножить на 4.
sum2+=f(a+h*(i+1));//Значения с чётными индексами, которые нужно умножить на 2.
}
sum=f(a)+4*sum4+2*sum2-f(b);//Отнимаем значение f(b) так как ранее прибавили его дважды.
I=I1;
I1=(h/3)*sum;
}
System.out.println(I1);
}
}
С помощью программы можно вычислить интеграл любой непрерывной на [latex]\left[a;b \right][/latex] функции, для этого нужно изменить 7 строку.
В условии главного цикла [latex]N\leq 4[/latex], так как важно, чтобы цикл выполнился хотя бы дважды. Потому что первый раз мы сравниваем новое значение интеграла не с предыдущим вычисленным, а с нулём, и если новое значение интеграла будет меньше погрешности, то цикл прекратится после первого же выполнения (без условия [latex]N\leq 4[/latex]).
Задача: Дана целочисленная квадратная матрица порядка [latex]n[/latex]. Найти номера строк, все элементы которых — нули.
[latex]n[/latex]
[latex]M[/latex]
[latex]v[/latex]
Комментарий
4
0
0
0
0
0
-290
56
48
0
0
0
0
1
2
3
4
1 3
—
3
0
0
0
0
0
0
0
0
0
1 2 3
—
3
1
2
3
4
5
6
7
8
9
—
Таких строк нет.
C++:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <vector>
usingnamespacestd;
intmain(){
intn;
cin>>n;
intM[n][n];
vector<int>v;
for(inti=0;i<n;i++)
{
for(intj=0;j<n;j++)
{
cin>>M[i][j];
}
}
for(inti=0;i<n;i++)
{
intk=0;
for(intj=0;(j<n)&&(M[i][j]==0);j++)
{
k++;
}
if(k==n)
{
v.push_back(i);
}
}
for(inti:v)
{
cout<<i+1<<" ";
}
if(v.empty())
{
cout<<"Таких строк нет."<<endl;
}
return0;
}
Java:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
importjava.util.*;
importjava.lang.*;
importjava.io.*;
classIdeone
{
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
intn=in.nextInt();
intM[][]=newint[n][n];
Vector<Integer>v=newVector<Integer>();
for(inti=0;i<n;i++){
for(intj=0;j<n;j++){
M[i][j]=in.nextInt();
}
}
for(inti=0;i<n;i++){
intk=0;
for(intj=0;(j<n)&&(M[i][j]==0);j++){
k++;
}
if(k==n){
v.add(i);
}
}
for(inti:v){
System.out.print(i+1+" ");
}
if(v.isEmpty()){
System.out.print("Таких строк нет.");
}
}
}
Пусть дана квадратная матрица [latex]M[/latex], количество строк и столбцов — [latex]n[/latex].
Заводим дополнительную переменную [latex]k[/latex]. При вводе элементов матрицы, проверяем, равны ли они нулю. Если элемент равен нулю, прибавляем к значению [latex]k[/latex] единицу. При первом ненулевом элементе переходим к другой строке. Если после прочтения строки [latex]k=n[/latex], то все элементы строки были нулевыми (перед прочтением каждой новой строки в [latex]k[/latex] записывается ноль). Записываем номер строки в заранее созданный вектор [latex]v[/latex]. Выводим элементы вектора, увеличивая их на единицу, чтобы получилась правильная нумерация строк.
У переменных [latex]l[/latex], [latex]m[/latex] (количество строк и столбцов соответственно) — тип int, т.к. это целые числа.
Массив для данной матрицы [latex]q\left[l \right]\left[m \right][/latex] и массивы элементов суммы [latex]sum\left[l \right][/latex] и среднего арифметического [latex]sr\left[l \right][/latex] каждой строки имеют тип double, так как могут содержать вещественные числа.
В первом цикле инициализируем элементы массива [latex]sum\left[l \right][/latex] нулями, чтобы там не лежал мусор.
Во втором цикле, который перебирает все элементы матрицы, вводятся эти элементы, считается их сумма и среднее арифметическое для каждой строки.
В третьем цикле вычитаем из каждого элемента среднее арифметическое строки, в которой он находится, и выводим новое значение элемента на экран.
Задача: Среднегодовая производительность труда. За первый год производительность труда на предприятии возросла на [latex]p_{1}[/latex]%, за второй и третий — соответственно на [latex]p_{2}[/latex]% и [latex]p_{3}[/latex]%. Найти среднегодовой прирост производительности (в процентах).
[latex]p_{1}[/latex]%
[latex]p_{2}[/latex]%
[latex]p_{3}[/latex]%
sp%
15
30
50
30.8913
5
5
5
5
-10
60
45
27.8135
0
0
0
0
C++:
C++
1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <cmath>
usingnamespacestd;
intmain(){
doublep1,p2,p3,op,sp;
cin>>p1>>p2>>p3;
op=(1+p1/100)*(1+p2/100)*(1+p3/100);
sp=(pow(op,1.0/3.0)-1)*100;
cout<<sp<<endl;
return0;
}
Java:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
importjava.util.*;
importjava.lang.*;
importjava.io.*;
classIdeone
{
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
doublep1=in.nextDouble();
doublep2=in.nextDouble();
doublep3=in.nextDouble();
doubleop=(1+p1/100)*(1+p2/100)*(1+p3/100);
doublesp;
sp=(Math.pow(op,1.0/3.0)-1)*100;
System.out.println(sp);
}
}
Для всех переменных используем тип double, так как они могут быть вещественными числами.
Сначала найдем общий прирост за 3 года (обозначен переменной [latex]op[/latex]), воспользовавшись формулой:
Тогда для того, чтобы найти среднегодовой прирост за 3 года (обозначен переменной [latex]sp[/latex]), надо извлечь корень третьей степени из общего прироста.
Задача: Даны натуральное число [latex]n[/latex], действительные числа [latex]a_{1},\cdot \cdot \cdot ,a_{n}[/latex]. Вычислить: [latex]\sqrt{\left|a_{1}a_{2}\cdot \cdot \cdot a_{n} \right|}[/latex].
[latex]n[/latex]
[latex]a_{1}[/latex]
[latex]a_{2}[/latex]
[latex]a_{3}[/latex]
[latex]a_{4}[/latex]
[latex]a_{5}[/latex]
[latex]a_{6}[/latex]
[latex]a_{7}[/latex]
[latex]a_{8}[/latex]
[latex]k[/latex]
4
-5
2
4
-3.6
—
—
—
—
12
8
-5
0.2
-3.2
0.5
-1.25
20
2
80
80
3
4
4
0
—
—
—
—
—
0
5
3
8
6
2.8
1.3
—
—
—
22.894541
С++:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <math.h>
intmain(void){
intn;
scanf("%d",&n);
doublea,p=1,k;
for(inti=1;i<=n;i++)
{
scanf("%lf",&a);
p*=a;
}
k=sqrt(fabs(p));
printf("%lf",k);
return0;
}
Java:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
importjava.util.*;
importjava.lang.*;
importjava.io.*;
classIdeone
{
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
intn=in.nextInt();
doublea,p=1,k;
for(inti=1;i<=n;i++){
a=in.nextDouble();
p*=a;
}
k=Math.sqrt(Math.abs(p));
System.out.println(k);
}
}
Объявляем переменную [latex]n[/latex] (количество элементов — это целое число, поэтому используем тип int) и переменные a (элементы произведения), p (произведение), k (корень из модуля произведения элементов), они могут быть вещественными, поэтому выбираем тип double.
В цикле for считываются элементы [latex]a_{1},a_{2},\cdot \cdot \cdot ,a_{n}[/latex], где[latex]i[/latex] — индекс элемента, и вычисляется их произведение.
После цикла вычисляется корень из модуля произведений элементов.
Задача: Численно убедиться в справедливости равенства, для чего для заданного значения аргумента [latex]x[/latex] вычислить левую его часть и разложение, стоящее в правой части с заданной погрешностью [latex]\varepsilon [/latex]. Испытать разложение на сходимость при разных значениях аргумента, найти скорость сходимости, для чего вывести число итераций [latex]n[/latex] (слагаемых или сомножителей), необходимых для достижения заданной точности. В некоторых задачах указан интервал допустимых значений аргумента [latex]x[/latex], при которых сходимость гарантируется.
printf("Введите аргумент x<1 и погрешность eps.\n");
scanf("%lf %lf\n",&x,&eps);
a=log(1-x);
for(inti=1;fabs(a-b)>=eps;i++,n++)
{
c=c*x;//Степени х.
b=b-c/i;//Сумма.
}
printf("Результат в левой части: %lf.\n",a);
printf("Результат в правой части: %lf.\n",b);
printf("Количество шагов: %d.\n",n);
return0;
}
Java:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
importjava.util.*;
importjava.lang.*;
importjava.io.*;
classIdeone
{
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
doublex,eps;//Вводит пользователь.
doublea,b=0,c=1;//Используются для вычислений.
intn=1;
System.out.println("Введите аргумент x<1 и погрешность eps.");
x=in.nextDouble();
eps=in.nextDouble();
a=Math.log(1-x);
for(inti=1;Math.abs(a-b)>=eps;i++,n++)
{
c=c*x;//Степени х.
b=b-c/i;//Сумма.
}
System.out.println("Результат в левой части: "+a);
System.out.println("Результат в правой части: "+b);
System.out.println("Количество шагов: "+n);
}
}
Для переменных [latex]x, eps, a, b, c[/latex] я использовала double, так как [latex]x<1[/latex] и [latex]eps[/latex] ([latex]\varepsilon [/latex]) — вещественные числа, которые вводит пользователь, [latex]a, b, c[/latex] используются для вычислений, поэтому тоже вещественные. Для переменной [latex]n[/latex] (в неё записывается количество шагов цикла) я использовала тип int, т.к. это целые числа.
Сперва вычисляем значение переменной [latex]a[/latex] — левую часть равенства.
Для вычисления правой части используем цикл for, который работает пока [latex]\left|a-b \right|\geq eps[/latex] (т.е. различие между правой и левой частью больше, чем погрешность, заданная пользователем).
При каждом шаге переменная [latex]n[/latex] увеличивается на единицу для подсчёта скорости сходимости.
Переменная [latex]c[/latex] обозначает элемент суммы, а [latex]b[/latex] — сумму элементов в правой части равенства.
Задача: Треугольник задаётся координатами своих вершин на плоскости: [latex]A\left(x_{1};y_{1} \right), B\left(x_{2};y_{2} \right), C\left(x_{3};y_{3} \right)[/latex] . Найти точку [latex]D[/latex], симметричную точке [latex]A[/latex] относительно стороны [latex]BC[/latex].
[latex]a_{x}[/latex]
[latex]a_{y}[/latex]
[latex]b_{x}[/latex]
[latex]b_{y}[/latex]
[latex]c_{x}[/latex]
[latex]c_{y}[/latex]
[latex]d_{x}[/latex]
[latex]d_{y}[/latex]
2
2
0
0
1
0
2
-2
-4
5
-2
3
-2
2
0
5
-3
-3
-4
-1
-1
-4
-2
-2
5
2
3.5
1
4.5
4
2.9
2.7
C++:
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <math.h>
intmain(void){
doubleax,ay,bx,by,cx,cy,dx,dy;//Даны по условию или нужно найти.
doubleA1,B1,C1,A2,B2,C2,ox,oy;//Используются для вычислений.
ox=(B1*C2-B2*C1)/(A1*B2-A2*B1);//Координаты точки О.
oy=(C1*A2-C2*A1)/(A1*B2-A2*B1);
dx=2*ox-ax;//Координаты точки D.
dy=2*oy-ay;
printf("D(%lf;%lf)\n",dx,dy);
return0;
}
Java:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
importjava.util.*;
importjava.lang.*;
importjava.io.*;
classIdeone
{
publicstaticvoidmain(String[]args)
{
Scanner in=newScanner(System.in);
doubleax,ay,bx,by,cx,cy,dx,dy;//Даны по условию или нужно найти.
doubleA1,B1,C1,A2,B2,C2,ox,oy;//Используются для вычислений.
System.out.println("Введите координаты точек A, B, C.");
ax=in.nextDouble();
ay=in.nextDouble();
bx=in.nextDouble();
by=in.nextDouble();
cx=in.nextDouble();
cy=in.nextDouble();
A1=cy-by;//Постоянные из уравнения прямой BC.
B1=bx-cx;
C1=by*(cx-bx)-bx*(cy-by);
A2=-B1;//Постоянные из уравнения прямой a.
B2=A1;
C2=B1*ax-A1*ay;
ox=(B1*C2-B2*C1)/(A1*B2-A2*B1);//Координаты точки О.
oy=(C1*A2-C2*A1)/(A1*B2-A2*B1);
dx=2*ox-ax;//Координаты точки D.
dy=2*oy-ay;
System.out.println("D("+dx+";"+dy+")");
}
}
Для всех переменных ([latex]a_{x}[/latex], [latex]a_{y}[/latex], [latex]b_{x}[/latex], [latex]b_{y}[/latex], [latex]c_{x}[/latex], [latex]c_{y}[/latex] — координаты точек [latex]A, B, C[/latex], даны по условию; [latex]d_{x}[/latex], [latex]d_{y}[/latex] — координаты точки [latex]D[/latex] — нужно найти) я использовала тип double, так как они могут быть вещественными числами.
Найдём уравнение прямой [latex]BC[/latex] по формуле [latex]\frac{\left(x-x_{1} \right)}{\left(x_{2}-x_{1} \right)}=\frac{\left(y-y_{1} \right)}{\left(y_{2}-y_{1} \right)}[/latex]. Подставляем значения: [latex]\frac{\left(x-b_{x} \right)}{\left(c_{x}-b_{x} \right)}=\frac{\left(y-b_{y} \right)}{\left(c_{y}-b_{y} \right)}[/latex]. Приводим к виду: [latex]x\left(c_{y}-b_{y} \right)-y\left(c_{x}-b_{x} \right)+b_{y}\left(c_{x}-b_{x} \right)-b_{x}\left(c_{y}-b_{y} \right)=0[/latex].
Переменными [latex]A_{1}[/latex], [latex]B_{1}[/latex], [latex]C_{1}[/latex] я обозначила постоянные при [latex]x, y[/latex] и свободный член, чтобы уравнение приняло вид: [latex]A_{1}\cdot x+B_{1}\cdot y+C_{1}=0[/latex].
Проведём прямую через точку [latex]A[/latex] перпендикулярно прямой [latex]BC[/latex]. Составим её уравнение по формуле: [latex]A\left(y-a_{y} \right)-B\left(x-a_{x} \right)=0[/latex]. Получим: [latex]A_{1}\cdot y-B_{1}\cdot x+B_{1}\cdot a_{x}-A_{1}\cdot a_{x}=0[/latex]. Аналогично для постоянных в этом уравнении я использовала переменные [latex]A_{2}[/latex], [latex]B_{2}[/latex], [latex]C_{2}[/latex]. Соответственно, [latex]A_{2}=-B_{1}[/latex], [latex]B_{2}=A_{1}[/latex], [latex]C_{2}=B_{1}\cdot a_{x}-A_{1}\cdot a_{y}[/latex].
Теперь найдём точку пересечения этой прямой и прямой [latex]BC[/latex] — точку [latex]O\left(o_{x};o_{y} \right)[/latex]. Получим: [latex]o_{x}=\frac{B_{1}\cdot C_{2}-B_{2}\cdot C_{1}}{A_{1}\cdot B_{2}-A_{2}\cdot B_{1}}[/latex] и [latex]o_{y}=\frac{C_{1}\cdot A_{2}-C_{2}\cdot A_{1}}{A_{1}\cdot B_{2}-A_{2}\cdot B_{1}}[/latex].
Так как точка [latex]D[/latex] симметрична точке [latex]A[/latex] относительно [latex]BC[/latex], и [latex]AD[/latex] пересекается с [latex]BC[/latex] в точке [latex]O[/latex]: точка [latex]O[/latex] — середина [latex]AD[/latex]. Из формулы координаты середины отрезка ( [latex]o_{x}=\frac{a_{x}+d_{x}}{2}[/latex] и [latex]o_{y}=\frac{a_{y}+d_{y}}{2}[/latex] ) находим [latex]d_{x}=2\cdot o_{x}-a_{x}[/latex] и [latex]d_{y}=2\cdot o_{y}-a_{y}[/latex].
Для переменных [latex]a, b[/latex] я использовала тип double, так как они они используются для вычислений и являются вещественными числами. Для переменной [latex]i[/latex] — тип int, так как [latex]i[/latex] — это целые числа от 1 до 10.
Чтобы решить задачу, воспользуемся циклом for, который работает при [latex]1\leq i\leq 10[/latex] и каждый раз прибавляет к [latex]i[/latex] единицу. Переменную [latex]i[/latex] я объявила в цикле, так как вне цикла она не нужна.
Сначала найдём [latex]a[/latex] — элемент суммы, который зависит от выбранного [latex]i[/latex]. После сложим [latex]a[/latex] и переменную [latex]b[/latex], которая обозначает сумму предыдущих элементов, a результат запишем снова в переменную [latex]b[/latex].
Когда цикл дойдёт до 11, его условие перестанет выполняться и напечатается последнее значение, присвоенное переменной [latex]d[/latex].
Задача: Числа [latex]a, b, c[/latex] тогда и только тогда являются сторонами треугольника, когда существуют такие положительные [latex]x, y, z[/latex], что:
System.out.println("Не является треугольником.\n");
}
}
}
Для всех переменных ( [latex]a, b, c[/latex] — даны по условию, [latex]x, y, z[/latex] — нужно найти) я использовала тип данных double, так как числа могут быть вещественными.
[latex]a, b, c[/latex] — стороны треугольника, поэтому они не могут быть отрицательными. И по соотношениям между сторонами треугольника каждая сторона меньше суммы двух других сторон. В противном случае [latex]a, b, c[/latex] не являются сторонами треугольника.
Чтобы получить значения [latex]x, y, z[/latex], решаем систему, данную в условии. Из первого уравнения: [latex]x=a-y[/latex]. Из второго: [latex]z=b-y[/latex]. Подставляем [latex]x=a-y[/latex] и [latex]z=b-y[/latex] в третье уравнение: [latex]c=a+b-2\cdot y[/latex]. Находим [latex]y=\frac{a+b-c}{2}[/latex], [latex]x=a-y[/latex], [latex]z=b-y[/latex].
Задача А59е. Даны действительные числа [latex]x[/latex], [latex]y[/latex]. Определить, принадлежит ли точка [latex]x[/latex], [latex]y[/latex] заштрихованной части плоскости.
System.out.println("Точка D принадлежит заштрихованной части плоскости.");
}
else{
System.out.println("Точка D не принадлежит заштрихованной части плоскости.");
}
}
}
}
Если точка [latex]D[/latex] лежит справа от оси [latex]OY[/latex], ищем расстояние от неё до точки [latex]O\left(0,0 \right)[/latex]. Если оно меньше либо равно [latex]1[/latex], точка [latex]D[/latex] принадлежит полукругу.
Если точка [latex]D[/latex] лежит слева от оси [latex]OY[/latex], будем проводить прямые через каждые две вершины треугольника [latex]ABC[/latex], где [latex]A\left(-2,0 \right)[/latex], [latex]B\left(0,1 \right)[/latex], [latex]C\left(1,0 \right)[/latex].
Прямая разделит плоскость на две части. При подстановке в уравнение точек из одной части плоскости, левая часть уравнения даст значение одного знака.
Функция dotLine определяет положение точки относительно прямой: она вычисляет значение в уравнении прямой и определяет, к какой части плоскости относится точка.
Для того, чтобы точка [latex]D[/latex] принадлежала треугольнику, она должна с каждой вершиной треугольника находиться по одну сторону от прямой, проходящей через две другие вершины.
Функция dotDot определяет, расположены ли точки в одной части плоскости.
Если уравнение прямой даст 0, то точка [latex]D[/latex] лежит на прямой и принадлежит треугольнику.