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

Dim x() As Single

Dim y() As Single

Dim z() As Single

Dim a0 As Single

Dim a1 As Single

Dim a2 As Single

Dim c As Single

Dim f1 As Single

Dim f2 As Single

Dim a As Single

Dim b As Single

Dim e As Single

Dim cont As Integer

Dim n As Integer

Private Sub Command1_Click()

c = 1.5

e = 0.001

n = Val(InputBox(«n=», n))

ReDim x(1 To n)

ReDim y(1 To n)

ReDim z(1 To n)

a0 = 0

a1 = 1.9

Label1.Caption = «A1 = » & Str(a0) + «рад»

Label2.Caption = «A2= » & Str(a1) + «рад»

f1 = f(a0, n)

f2 = f(a1, n)

cont = 0

Do

a2 = (a0 + a1) / 2

If f(a0 – c, n) * (f(a2, n) – c) < 0 Then

a1 = a2

Else

a0 = a2

End If

cont = cont + 1

Label4.Caption = Label4.Caption + «tan(a)=» + Chr$(32) + Chr$(32) + Format(Tan(a2), «0.00000″) + Chr$(13)

Label6.Caption = Label6.Caption + «y(x)=» + Chr$(32) + Chr$(32) + Format(f(a2, n), «0.00000″) + Chr$(13)

Loop While Abs(a0 – a1) > e

t = Atn(z(1))

Label3.Caption = «искомый угол A3 = » & Format(t, «0.00000″)

Label8.Caption = «y(x) = » & Format(f(a2, n), «0.000000″)

Label9.Caption = «погрешность = » & Format(e, «0.0000″)

End Sub

Public Function f(al As Single, n As Integer) As Single

Dim x0 As Single

Dim y0 As Single

Dim i As Integer

Dim h As Single

Dim k1, k2, k3, k4 As Single

Dim l1, l2, l3, l4 As Single

a = 0

b = 3.14 / 2

h = (b – a) / n

x(1) = 0

z(1) = Sin(al) / Cos(al)

y(1) = 0

For i = 1 To n – 1

k1 = z(i)

l1 = -y(i)

k2 = z(i) + l1 * h / 2

l2 = -1 * ((y(i) + k1 * h / 2))

k3 = z(i) + k2 * h / 2

l3 = -(y(i) + k2 * h / 2)

k4 = z(i) + k3 * h

l4 = -(y(i) + k3 * h)

y(i + 1) = y(i) + h / 6 * (k1 + 2 * k2 + 2 * k3 + k4)

z(i + 1) = z(i) + h / 6 * (l1 + 2 * l2 + 2 * l3 + l4)

x(i + 1) = a + h * i

Next i

f = y(n)

Call d1

End Function

Рисование графиков

Private Sub d1()

Dim x0 As Single

Dim y0 As Single

Dim xk As Single

Dim yk As Single

Dim zk As Single

Dim i As Single

With Form2

.Show

x0 = .ScaleWidth / 2 – 4

y0 = .ScaleHeight / 2 – 1

Form2.Line (x0, .ScaleHeight)-(x0, 0)

Form2.Line (.ScaleWidth, y0)-(0, y0)

For i = 1 To 250

‘График ф-ции y(x)

.CurrentX = 5.8

.CurrentY = 3.7

Form2.Print «y=y(x)»

yk = y0 – y(i)

xk = x(i) + x0

Form2.PSet (xk, yk)

Next i

‘Разметка осей координат

For i = 0 To 25 Step 0.5

Form2.Line (x0 + i, y0 – 0.08)-(x0 + i, y0 + 0.1)

.CurrentX = x0 + i – 0.1

.CurrentY = y0 + 0.1

Form2.Print i;

Form2.Line (x0 – i, y0 – 0.08)-(x0 – i, y0 + 0.1)

.CurrentX = x0 – i – 0.1

.CurrentY = y0 + 0.2

Form2.Print «-» & i;

Form2.Line (x0 – 0.08, y0 + i)-(x0 + 0.1, y0 + i)

.CurrentX = x0 + 0.15

.CurrentY = y0 + i – 0.08

Form2.Print «-» & i;

Form2.Line (x0 – 0.08, y0 – i)-(x0 + 0.1, y0 – i)

.CurrentX = x0 + 0.1

.CurrentY = y0 – i – 0.08

Form2.Print i;

Next i

End With

End Sub

—————————————————————————————————————————————————-

Графическая интерпретация:

На отрезке [0; π/2]

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

a=0

b= π/2

Погрешность =0.001

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

α = 0.982 ± 0.001,   (0.981;  0.983)

void SquareTri(

DIGIT C[ ],   /* результат длины 2n цифр */

const DIGIT A[ ],   /* основание длины n цифр */

int n)      /* длина основания */

{

TWODIGIT t,f;

int i,j;

Zero (С, 2*n);

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

{              f=0;

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

{              t = (TWODIGIT)A[i]*(TWODIGIT)A[j];

f += (((TWODIGIT)LODIGIT(t))«1)+C[i+j];

C[i+j] = LODIGIT(f);

f= HIDIGIT(f);

f+= (((TWODIGlT)HIDIGIT(t))«1);

}

t = (TWODIGIT)A[i|*(TWODIGIT)A[i];

f += LODIGIT(t)+C[i+i];

C[i+i] = LODIGIT(i);

f = HIDIGIT(f)+C[i+i+1]+HIDIGIT(t);

C|i+i+1]= LODIGIT(f);

C[i+i+2] = HIDIGIT(f);

}

}

Сложность этого алгоритма O(n2).

{основная программа}

Var A, B, C : Tlong;

Begin

Assign(Input, ‘Input.txt’); Reset(Input);

ReadLong(A); ReadLong(B) ;

Close(Input);

SumLongTwo(A, B, C);

Assign(Output, ‘Output.txt’);

Rewrite(Output);

WriteLong(C);

Close(Output)

End.

{процедура ввода длинного числа}

Procedure ReadLong(Var A : Tlong);

Var ch : char; i : Integer;

Begin

FillChar(A, SizeOf(A), 0) ;

Read(ch);

While Not(ch In ['0'..'9']) Do Read(ch);

{пропуск не цифр во входном файле}

While ch In ['0'..'9'] Do

Begin

For i := A[0] DownTo 1 Do

Begin

{«протаскивание» старшей цифры в числе из A[i]

в младшую цифру числа из A[i+l]}

A[i+l] := A[i+l] + (LongInt(A[i]) * 10) Div Osn;

A[i] := (LongInt(A[i]) * 10) Mod Osn

End;

A[1] := A[l] + Ord(ch) – Ord(’0′);

{добавляем младшую цифру к числу из А[1]}

If A[A[0]+1] > 0 Then Inc(A[0]);

{изменяем длину, число задействованных элементов массива А}

Read(ch)

End

End;

{процедура вывода длинного числа}

Procedure WriteLong(Const A : Tlong);

Var          ls, s : String; i : Integer;

Begin

Str(Osn Div 10, Is);

Write(A[A[0]]; {выводим старшие цифры числа}

For i := A[0] – l DownTo 1 Do

Begin

Str(A[i], s);

While Length(s) < Length(Is) Do s := ’0′ + s;

{дополняем незначащими нулями}

Write(s)

End;

WriteLn

End;

{процедура сложения двух длинных чисел}

Procedure SumLongTwo(A, B : Nlong; Var C : Tlong);

Var i, k : Integer;

Begin

FillChar(C, SizeOf (C), 0) ;

If A[0] > B[0] Then k := A[0] Else k :=B[0];

For i := l To k Do

Begin     С [i+1] := (C[i] + A[i] + B[i]) Div Osn;

C[i] := (C[i] + A[i] + B[i]) Mod Osn

End;

If C[k+l] = 0 Then C[0] := k Else C[0] := k + l

End;

int Cmp(

const DIGIT A[ ], /* первое число */

const DIGIT B[ ], /* второе число */

int n) /* длина чисел */

{

int i;

for(i=n-1; (i>=0)&&(A[i]==B[i]); i–);

if (i<0) return 0;

if(A[i]>B[i]) return +1;

return -1;

}

DIGIT Аdd(

DIGIT C[ ], // результат

const DIGIT A[ ], // первое слагаемое

const DIGIT B[ ], // второе слагаемое

int n) // длина слагаемых

{              TWODIGIT T;

DIGIT d=0;

int i;

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

{              T = (TWODIGIT)A[i]+B[i]+d;

C[i] = LODIGIT(T);

d = HIDIGIT(T);

}

return d;

}

Сложность данного алгоритма O(n). Реализация этого алгоритма проста, так как он имитирует известную всем процедуру сложения в «столбик».

Умножить двумерный массив на число

Код программы на Visual Basic

Const N = 4

Const M = 3

Dim A(1 To N, 1 To M) As Integer

Dim B(1 To N, 1 To M) As Integer

Dim C As Integer

C = Val(InputBox(«c=», C))

Print «Умножить на «; C

Print «исходная матрица»

For i = 1 To N

For j = 1 To M

A(i, j) = Int(Rnd * 34 – 10)

Print A(i, j);

Next j

Print

Next i

Print «полученная матрица»

For i = 1 To N

For j = 1 To M

B(i, j) = C * A(i, j)

Print B(i, j);

Next j

Print

Next i

End Sub

Написать программу, демонстрирующую работу с объектами двух типов: SymbString (символьная строка) DecString (десятичная строка).  Каждый объект должен иметь идентификатор(в виде произвольной строки символов) и одно или несколько полей для хранения состояния(текущего значения) объекта.

Клиенту (функции main)  должны  быть доступны следующие основные операции:

• Создать объект
• Удалить объект
• Показать значение объекта

И следующие дополнительные операции:

Для объектов класса DecString:

• Показать значение двоичного значения объекта  ShowBin();
• Показать значение восьмеричного значения объекта ShowOct;
• Показать значение шестнадцатеричного значения объекта. ShowHex;

Операции по созданию и удалению объектов инкапсулировать в классе Factory. Предусмотреть меню, позволяющее продемонстрировать заданные операции.

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

Main.cpp

#include <iostream.h>// библиотека ввода/вывода

#include «AString.h» // основной класс  строка

#include «SymbString.h» // наследуемый класс класса AString – символьная строка

#include «DecString.h»  // наследуемый класс класса AString – десятичная строка

#include «Action.h»   // базовый класс действие

#include «ShowStr.h» // показать значение строки

#include «ShowHex.h» //  показать в шестнадцатеричной форме

#include «ShowOct.h» //  показать в восьмеричной форме

#include «ShowBin.h» //  показать в двоичной форме

#include «Factory.h» //

#include «Menu.h»   // класс меню

using namespace std;

Action* pActs[] = {&show_str, &show_hex, &show_oct, &show_bin}; // массив действий

vector<Action*> actionList(pActs, pActs+sizeof(pActs)/sizeof(Action*));

int main()

{    Factory factory;

Menu menu(actionList);

JobMode jobMode;

while((jobMode = menu.SelectJob())!=Exit){

switch(jobMode){

case AddObj: factory.AddObject();

break;

case DelObj: factory.DeletObject();

break;

case WorkWithObj:

AString* pObj = menu.SelectObject(factory);

Action* pAct = menu.SelectAction(pObj);

if(pAct)

pAct->Operate(pObj);

break;

}

cin.get();

}

return 0;

}

AString.h

#ifndef ASTRING_H

#define ASTRING_H

#include <string.h>

class AString{

public:

virtual ~AString() {}

virtual const std::string& GetName() const = 0; // получить название

virtual const std::string& GetVal() const = 0; // значение

virtual int GetSize() const = 0; // размер

};

#endif

SymbString.h

#include <string.h>

#include «AString.h» // базовый класс AString

class SymbString : public AString{

public:

SymbString(std::string _name) : name(_name){}

SymbString(std::string _name, std::string _val) :

name(_name), val(_val){}

const std::string& GetName() const{return name;}

const std::string& GetVal() const{return val;}

int GetSize() const{return val.size();}

private:

std::string name;

std::string val;

};

DecString.h

#include <string.h>

#include «AString.h»// базовый класс AString

const std::string alph = «0123456789″; // массив возможных значений

bool IsDecStrVal(std::string);

class DecString : public AString{

public:

DecString(std::string _name) : name(_name){}

DecString(std::string, std::string);

const std::string& GetName() const {return name;}

const std::string& GetVal() const {return val;}

int GetSize() const {return val.size();}

private:

std::string name;

std::string val;

};

Action.h

#ifndef ACTION_H

#define ACTION_H

#include «AString.h»

class Action{

public:

virtual ~Action() {}

virtual void Operate(AString*) = 0;

virtual const std::string& GetName() const = 0;

protected:

long GetDecimal(AString* pObj) const;

};

#endif

Action.cpp

#include <iostream.h>

#include «Action.h»

#include «AString.h»

#include «DecString.h«// десятичная строка

using namespace std;

// получение десятичного числа

long Action::GetDecimal(AString* pObj) const{

if (reinterpret_cast<DecString*>(pObj)) {

long dest;

string source=pObj->GetVal();

sscanf(source.c_str(),»%i», &dest);

return dest;

}

else{

cout<<»Action not supported»<<endl;

return -1;

}}

Factory.h

#define FACTORY_H

#include <vector.h> // класс вектор

#include «AString.h»

class Factory{

friend class Menu;

public:

Factory() {}

void AddObject(); // метод добавить объект

void DeletObject(); // метод удаления объекта

private:

std::vector<AString*> pObj;

};

#endif

Factory.cpp

#include <iostream.h>

#include «Factory.h»

#include «Menu.h»   // класс меню

#include «SymbString.h» //класс символьная строка

#include «DecString.h» //класс десятичная строка

using namespace std;

#define MAX_LEN_STR 100

// Добавление объекта

void Factory::AddObject(){

cout<<»——————\n»;

cout<<»Select object type:\n»;

cout<<»1.Symbolic string»<<endl;

cout<<»2.Dec string»<<endl;

int item = Menu::SelectItem(2);

string name;

cout<<»Enter object name:»;

cin>>name;

cin.get();

cout<<»Enter object value:»;

char buf[MAX_LEN_STR];

cin.getline(buf, MAX_LEN_STR);

string value = buf;

AString* pNewObj;

switch(item){

case 1:

pNewObj = new SymbString(name, value);

break;

case 2:

if(!IsDecStrVal(value)){    // проверка является ли введенная строка десятичной

cout<<»Error!»<<endl; return;

}

pNewObj = new DecString(name, value);

break;

}

pObj.push_back(pNewObj);

cout<<»Object added.»<<endl;

}

// Удаление объекта

void Factory::DeletObject(){

int nItem = pObj.size();

if(!nItem){

cout<<»There are no object.»<<endl;

cin.get();

return;

}

cout<<»…………………………….\n»;

cout<<»Delete one of the folloowing Object:\n»;

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

cout<<i+1<<».»<<pObj[i]->GetName()<<endl;

int item = Menu::SelectItem(nItem);

string objName = pObj[item-1]->GetName();

pObj.erase(pObj.begin()+item-1);

cout<<»Object»<<objName<<»deleted.»<<endl;

cin.get();

}

ShowBin.h

#include «Action.h»

class ShowBin : public Action{

public:

ShowBin() : name(«Show binary value»){}

void Operate(AString*);

const std::string& GetName() const {return name;}

private:

std::string GetBinary(AString*) const;

std::string name;

};

extern ShowBin show_bin;

ShowBin.cpp

#include <iostream.h>

#include «AString.h» //основной класс строка

#include «ShowBin.h»

using namespace std;

void ShowBin::Operate(AString* pObj){

cout<<pObj->GetName()<<»: «;

cout<< pObj->GetVal();

cout<<» in binary is: «<< GetBinary(pObj)<<endl;

cin.get();

}

// Вычисление двоичного числа

string ShowBin::GetBinary(AString* pObj) const{

int nBinDigit=4*pObj->GetSize();

char* binStr=new char[nBinDigit+1];

for(int k=0; k<nBinDigit;++k) binStr[k]= ’0′;

binStr[nBinDigit]=0;

long decVal=GetDecimal(pObj); // Вычисление десятичного значения

if(-1==decVal)

return string(«»);

int i=nBinDigit-1;

// формирования массива символов 0 1 представляющих двоичное число

while (decVal>0) {

binStr[i--]=48+(decVal%2);

decVal>>=1;

}

string temp(binStr);

delete [] binStr;

return temp;

}

ShowBin show_bin;

ShowHex.h

#include «Action.h»

class ShowHex : public Action {

public:

ShowHex() : name(«Show hex value») {}

void Operate(AString*);

const std::string& GetName() const {return name;}

private:

std::string name;

};

extern ShowHex show_hex;

ShowHex.cpp

#include <iostream.h>

#include «AString.h»  // основной класс строк

#include «ShowHex.h»

using namespace std;

// операция получение шестнадцатиричного числа

void ShowHex::Operate(AString* pObj) {

cout<<pObj->GetName()<< «: «;

cout<<pObj->GetVal();

int decVal=GetDecimal(pObj);// получение десятичного числа

if(decVal !=-1)

cout<<» in hexadecimal is: «;

cout <<hex<<GetDecimal(pObj); // вывод шестнадцатиричного числа

cout<<endl;

cin.get();

}

ShowHex show_hex;

ShowOct.h

#include «Action.h»

class ShowOct : public Action {

public:

ShowOct() : name(«Show oct value») {}

void Operate(AString*);

const std::string& GetName() const {return name;}

private:

std::string name;

};

extern ShowOct show_oct;

ShowOct.cpp

#include <iostream.h>

#include «AString.h» // основной класс строка

#include «ShowOct.h»

using namespace std;

// Показать число в восьмеричной форме

void ShowOct::Operate(AString* pObj) {

cout<<pObj->GetName()<< «: «;

cout<<pObj->GetVal() ;

int decVal=GetDecimal(pObj); // получение десятичного значения

if(decVal !=-1)

cout <<» in octal is: «;

cout <<oct<<GetDecimal(pObj); //получение и вывод восьмеричного значения

cout<<endl;

cin.get();

}

ShowOct show_oct;

ShowStr.h

#include «Action.h»

class ShowStr : public Action{

public:

ShowStr() : name(«Show string value»){}

void Operate(AString*);

const std::string& GetName() const{return name;}

private:

std::string name;

};

extern ShowStr show_str;

ShowStr.cpp

#include <iostream.h>

#include «ShowStr.h»

using namespace std;

void ShowStr::Operate(AString* pObj){

cout<<pObj->GetName()<<»:»; // вывод имени строки

cout<<pObj->GetVal()<<endl; // вывод значениястроки

cout<<endl;

cin.get();

}

ShowStr show_str;

Menu.h

#include «Action.h»

#include «Factory.h»

typedef enum{AddObj, DelObj, WorkWithObj, Exit} JobMode;

class Menu{

public:

Menu(std::vector<Action*>);

JobMode SelectJob() const;

AString* SelectObject(const Factory&) const;

Action*  SelectAction(const AString*) const;

static int SelectItem(int);

private:

std::vector<Action*> pAct;

};

Menu.cpp

#include <iostream.h>

#include «AString.h» // основной класс строка

#include «SymbString.h» // класс символьная строка

#include «DecString.h» // класс десятичная строка

#include «Menu.h»

using namespace std;

Menu::Menu(vector<Action*> _pAct) : pAct(_pAct){}

JobMode Menu::SelectJob() const{

cout<<»=======================\n»;

cout<<»Select one of the following job modes:\n»;

cout<<»1. Add object»<<endl;

cout<<»2. Delet object»<<endl;

cout<<»3. Work with object»<<endl;

cout<<»4. Exit»<<endl;

int item = SelectItem(4);

return(JobMode)(item-1);

}

// Выбор объекта

AString* Menu::SelectObject(const Factory& fctry) const{

int nItem = fctry.pObj.size();

if(!nItem){

cout<<»There are no object.»<<endl;

cin.get();

return 0;

}

cout<<»………………………….\n»;

cout<<»Select one of the following Object:\n»;

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

cout<<i+1<<».»;

cout<<fctry.pObj[i]->GetName()<<endl;

}

int item = SelectItem(nItem);

return fctry.pObj[item-1];

}

// Выбор действия

Action* Menu::SelectAction(const AString* pObj) const{

if(!pObj) return 0;

int nItem = pAct.size();

cout<<»…………………………..\n»;

cout<<»Select one of the following Actions:\n»;

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

cout<<i+1<<».»;

cout<<pAct[i]->GetName()<<endl;

}

int item = SelectItem(nItem);

return pAct[item-1];

}

// Выбор пункта

int Menu::SelectItem(int nItem){

cout<<»——————–\n»;

int item;

while(true){

cin>>item;

if((item>0) && (item<=nItem) && (cin.peek() == ‘\n’)){

cin.get(); break;

}

else{

cout<<»Error (must be number from 1 to»<<nItem<<»):»<<endl;

cin.clear();

while(cin.get() !=’\n’){};

} }

return item;

}

Пример работы программы:

Добавление объекта

Удаление объекта

Работа с объектом

• Показать значение строки

• Показать изображение двоичного, шестнадцатеричного, восьмеричного  значения объекта

Матрицу А(m, n) заполнить следующим образом. Для заданных  k и l элементу a_kl присвоить значение 1; элементам, окаймляющим его (соседним с ним по вертикали, горизонтали и диагоналям) – значение 2; элементам следующего окаймления – значение 3 и так далее до заполнения всей матрицы.

Решение:

Формула  A[i][j]=max(abs(i-k),abs(j-l))+1; определяет положение элемента a_ij относительно элемента a_kl=1 (круг окаймления) и присваивает ему соответствующее значение, где

K – номер строки, k=0…m-1

L – номер столбца, l=0…n-1

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

#include <stdlib.h>

#include <iostream.h> // библиотеки ввода вывода

#include <conio.h>

#include <math.h> // математическая библиотека

void main()

{

const int m=13;   // максимальная граница ввода

const int n=10;

int i, j, k, l;

int A[m][n];

m1:cout << «Input  0<=k<=» << m-1 << «\n\r»;  // номер строки

cin >> k;

if ((k>m-1)||(k<0)) goto m1;    //Контроль ввода k

m2:cout << «Input  0<l<=» << n-1 << «\n\r»;  // номер столбца

cin >> l;

if ((l>n-1)||(l<0)) goto m2;    //Контроль ввода l

// Заполнение матрицы элементами, окаймляющими элемент A_kl

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

{

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

{

A[i][j]=max(abs(i-k),abs(j-l))+1;

}

}

printf(«\n»);            // Вывод матрицы

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

{

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

{

cout<<A[i][j]<<»\t»;

}

printf(«\n»);

}

getch();

return ;   }

Пример работы программы:

Два отрезка на прямой  заданы координатами своих концов. Определить,  имеют ли эти отрезки общие точки, и если имеют, то длину общей части. Замечание. Необходимо рассмотреть различные слу­чаи взаимной ориентации отрезков. Тестирование должно предусмотреть все такие ситуации.

Решение:

Пусть А и В – два отрезка, с координатами своих концов  [а1, а2] и [b1, b2] соответственно. a1, b1 –левые координаты, a2, b2 – правые координаты отрезков А и В.

Возможные случаи взаимной ориентации отрезков:

1. отрезки не имеют общих точек.
2. отрезки  частично  совпадают.
3. отрезки могут лежать внутри друг друга.
4. Могут иметь одну общую точку, в этом случае длина общей части будет равна нулю.
5. отрезки совпадают.

Алгоритм построен на сравнении координат концов заданных отрезков:

1. В случае если ни одна из координат одного отрезка не лежит между концевыми координатами другого, то эти отрезки не имеют общих точек;
2. В случае если одна из координат одного отрезка лежит между концевыми координатами второго, то эти отрезки имеют общую часть;
3. В случае если обе концевые координаты одного отрезка лежат между концевыми координатами второго отрезка, то один отрезок лежит внутри другого;
4. Если одна из  концевых координат одного отрезка совпадает с начальной координатой второго, то отрезки имеют одну общую точку.
5. Если левые и правые концевые координаты одного отрезка совпадают соответственно с координатами другого отрезка, то эти отрезки совпадают.

Ограничения:

Прямая ограничена интервалом от -10 до 10, в случае если  задаваемые координаты выходят за пределы заданного интервала выводится приглашение ввести их повторно. Так как правые координаты не могут быть расположены левее левых, то при их вводе b2<=b1, a2<=a1    приглашение ввести их повторно.

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

#include <iostream.h>

#include <conio.h>

void main()

{

const int NMIN=-10;   // минимальная граница ввода

const int NMAX=10;  // максимальная граница ввода

double a1,a2,b1, b2, dlina;

m1:cout << «Input level coordinate otrezka a: «<<NMIN<<»<=a1<=»<<NMAX<< «\n\r»;

cin >>a1;

if ((a1<NMIN)||(a1>NMAX)) goto m1; //Контроль ввода a1

m2:cout << «Input right coordinate otrezka a: » <<a1<<»<a2<=»<<NMAX<< «\n\r»;

cin >>a2;

if ((a2<=a1)||(a1>NMAX)) goto m2;  //Контроль ввода a2

m3: cout << «Input level coordinate otrezka b: «<<NMIN<<»<=b1<=»<<NMAX<<»\n\r»;

cin >>b1;

if ((b1<NMIN)||(b1>NMAX)) goto m3;  //Контроль ввода b1

m4:cout << «Input right coordinate otrezka b: » <<b1<<»<b2<=»<<NMAX<< «\n\r»;

cin >>b2;

if ((b2<=b1)||(b1>NMAX)) goto m4; //Контроль вводa b2

// проверка пересечения отрезков

if (((a1<=b1)&&(b1<=a2))||((a1<=b2)&&(b2<=a2))||

((a1<=b1)&&(a1<=b2)&&(b1<=a2)&&(b2<=a2))||

((b1<=a1)&&(b1<=a2)&&(a1<=b2)&&(a2<=b2)))

{

if ((b1>=a1)&&(b2>a1)&&(b1<a2)&&(b2<=a2)) dlina=b2-b1; //отрезок B лежит внутри A

else if ((b1<=a1)&&(b1<=a2)&&(a1<=b2)&&(a2<=b2)) dlina=a2-a1; //отрезок A лежит внутри B

else if ((a1<=b1)&&(b1<=a2)) dlina=a2-b1; //  a1<=b1<=a2

else if ((b2>=a1)&&(b2<=a2)) dlina=b2-a1;   // a1<=b2<=a2

cout << «\n\rotrezki are crossed\n\r»;

cout << «\n\rLENGTH of COMMON PART :»<<dlina;

}

else

cout << «\n\rotrezki are not crossed\n\r»;

getch();

}

Найти наибольший общий делитель (НОД) двух введенных натуральных чисел, используя алгоритм Евклида (алгоритм Евклида: вычитаем из  большего меньшее до тех пор, пока они не сравняются, полученное в результате число и есть НОД).

Решение:

Наибольшим общим делителем (НОД) двух целых чисел называется такое наибольшее по модулю число, которое делит эти два числа. Так как  натуральные числа это положительные целые числа, то при вводе двух чисел а и b должно проверяться условие, что они больше нуля.Программный код:

#include <iostream.h> // библиотеки ввода вывода

#include <conio.h>

void main()

{

const int nmax=500;   //  максимальная граница ввода

int a, b;  // натуральные числа

int result; // НОД

m:cout << «Input  0<a<=» << nmax << «\n\r»;

cin >> a;

if ((a>nmax)||(a<=0)) goto m;    //контроль ввода a

m1:cout << «Input  0<b<=» << nmax << «\n\r»;

cin >> b;

if ((b>nmax)||(b<=0)) goto m1;    //контроль ввода b

// Нахождение НОД по Алгоритму Евклида

while(a!=b)

{

if( a>b )

{

a = a-b;

}

else

{

b = b-a;

}

}

result = b;

cout <<»result:» <<   result<< «\n\r»;

getch();

return;

}