e-olymp 7258. Числовые операции

12/04/2021 by Філіпенко Микита

Условие

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

Задание
Напишите программу, которая для заданного натурального числа определяет, за какое наименьшее число операций Петя может, начав с единицы, дойти до этого числа.

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

Первая строка входного файла содержит число $T (1 \leqslant T < 10^4),$ которое задает количество чисел во входном файле, для которых требуется найти ответ. В последующих $T$ строках задано по одному натуральному числу $N_i$,$2\leqslant N_i < 10^9$, $1 \leqslant i \leqslant T$. Известно, что среди чисел $N_i, 1 \leqslant i \leqslant T$, нет одинаковых.

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

Выходной файл должен содержать $T$ чисел по одному в строке — в $i$-й строке должно быть записано наименьшее количество секунд, которое понадобится истратить Пете, чтобы, начав с единицы, записать на доске соответствующее число $N_i$.

Тесты

№

Ввод

Вывод

955

4

137

318

3028

300

39

40

71

50

Код

#include <iostream>

using namespace std;

int nonzero(int number) //функция, которая считает количество цифр, не равных нулю, кроме последней
{
  int count = 0;
  number /= 10;
  while (number != 0) {
    if (number % 10 != 0) count++;
    number /= 10;
  }
  return count;
}
int summa(int number) //функция, которая возвращает сумму цифр числа
{
  int sum = 0;
  while (number != 0) {
    sum += number % 10;
    number /= 10;
  }
  return sum;
}
bool edinica(int number) //функция, которая проверяет есть ли среди цифр числа, кроме последней, единица
{
  number /= 10;
  bool ok = false;
  while (number != 0) {
    if (number % 10 == 1) ok = true;
    number /= 10;
  }
  return ok;
}
int kol_vo(int number) //функция, вычисляющая кол-во цифр числа
{
  int count = 0;
  while (number != 0) {
    count++;
    number /= 10;
  }
  return count;
}
int formula(int number) //формула, по которой можно дойти от 1 до 10^(a-1),где a- кол-во цифр числа
{
  int a = kol_vo(number);
  return (5 * a - 1) * (a - 1);
}

int main() {
  //инициализируем переменную t и считываем ее с клавиатуры
  int t;
  cin >> t;
  //инициализируем переменную ni и задаем цикл, который будет работать пока мы вводим значения ni и t>0
  int ni;
  while (cin >> ni and t > 0) {
    //кладем в переменную kol_vo1 значение функции kol_vo от значения ni
    int kol_vo1 = kol_vo(ni);
    //появляется необходимость создать переменную, которая будет равна значению ni,так как с этим значением
    //в дальнейшем будут проводится операции, а в конце программы нам нужно будет обратиться к исходному значению ni 
    int a = ni;
    //задаем массив, размерность которого равна кол-ву цифр числа
    int b[kol_vo1];
    for (int i = 0; i < kol_vo1; i++) {
      b[i] = a % 10;
      a /= 10;
    }
    //далее производим проверку условия №2,которое описано в решении. Если число проходит условие, то 
    //выводим соответствующую формулу, указанную в условии №2
    bool ok = false;
    for (int i = 0; i < kol_vo1 - 1; i++) {
      if (b[i] == 0) ok = true;
      else {
        ok = false;
        break;
      }
    }
    if (b[kol_vo1 - 1] > 1 and ok == true) {
      cout << summa(--ni) + nonzero(--ni) - edinica(--ni) + formula(ni) << endl;
    }
    //далее производим проверку условия №1,которое описано в решении. Если число проходит условие, то 
    //выводим соответствующую формулу, указанную в условии №1
    bool ok2 = false;
    for (int i = 0; i < kol_vo1 - 1; i++) {
      if (b[i] != 0) ok2 = true;
    }
    if (ok2 == true) cout << summa(ni) + nonzero(ni) - edinica(ni) - 1 + formula(ni) << endl;
    //остались крайние случаи, когда число однозначное или кратное 10^n.Проверяем число на эти условия
    //и если оно является таковым, выводим соответствующие значения
    if (kol_vo1 == 1) cout << ni - 1 << endl;
    if (ni == 10 or ni == 100 or ni == 1000 or ni == 10000 or ni == 100000 or ni == 1000000 or ni == 10000000 or ni == 100000000 or ni == 1000000000) cout << formula(ni) << endl;
    //декрементируем переменную t
    t--;
  }
}

#include <iostream>

using namespace std;

int nonzero(int number) //функция, которая считает количество цифр, не равных нулю, кроме последней

{

int count = 0;

number /= 10;

while (number != 0) {

if (number % 10 != 0) count++;

number /= 10;

}

return count;

}

int summa(int number) //функция, которая возвращает сумму цифр числа

{

int sum = 0;

while (number != 0) {

sum += number % 10;

number /= 10;

}

return sum;

}

bool edinica(int number) //функция, которая проверяет есть ли среди цифр числа, кроме последней, единица

{

number /= 10;

bool ok = false;

while (number != 0) {

if (number % 10 == 1) ok = true;

number /= 10;

}

return ok;

}

int kol_vo(int number) //функция, вычисляющая кол-во цифр числа

{

int count = 0;

while (number != 0) {

count++;

number /= 10;

}

return count;

}

int formula(int number) //формула, по которой можно дойти от 1 до 10^(a-1),где a- кол-во цифр числа

{

int a = kol_vo(number);

return (5 * a - 1) * (a - 1);

}

int main() {

//инициализируем переменную t и считываем ее с клавиатуры

int t;

cin >> t;

//инициализируем переменную ni и задаем цикл, который будет работать пока мы вводим значения ni и t>0

int ni;

while (cin >> ni and t > 0) {

//кладем в переменную kol_vo1 значение функции kol_vo от значения ni

int kol_vo1 = kol_vo(ni);

//появляется необходимость создать переменную, которая будет равна значению ni,так как с этим значением

//в дальнейшем будут проводится операции, а в конце программы нам нужно будет обратиться к исходному значению ni

int a = ni;

//задаем массив, размерность которого равна кол-ву цифр числа

int b[kol_vo1];

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

b[i] = a % 10;

a /= 10;

}

//далее производим проверку условия №2,которое описано в решении. Если число проходит условие, то

//выводим соответствующую формулу, указанную в условии №2

bool ok = false;

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

if (b[i] == 0) ok = true;

else {

ok = false;

break;

}

if (b[kol_vo1 - 1] > 1 and ok == true) {

cout << summa(--ni) + nonzero(--ni) - edinica(--ni) + formula(ni) << endl;

}

//далее производим проверку условия №1,которое описано в решении. Если число проходит условие, то

//выводим соответствующую формулу, указанную в условии №1

bool ok2 = false;

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

if (b[i] != 0) ok2 = true;

}

if (ok2 == true) cout << summa(ni) + nonzero(ni) - edinica(ni) - 1 + formula(ni) << endl;

//остались крайние случаи, когда число однозначное или кратное 10^n.Проверяем число на эти условия

//и если оно является таковым, выводим соответствующие значения

if (kol_vo1 == 1) cout << ni - 1 << endl;

if (ni == 10 or ni == 100 or ni == 1000 or ni == 10000 or ni == 100000 or ni == 1000000 or ni == 10000000 or ni == 100000000 or ni == 1000000000) cout << formula(ni) << endl;

//декрементируем переменную t

t--;

}

Решение

Количество цифр в числе никогда не уменьшается, а может увеличиться только при добавлении к числу, состоящее только из девяток и единицы. Поэтому, для достижения числа $N$ сначала нужно дойти до числа $10$, потом до чисел $99$ и $100$ и так далее, пока количество цифр в числе не будет таким, какое требуется.
Наименьшее количество операций, необходимое для того, чтобы перейти от числа $10^{n-1}$ до заданного $n$ -значного числа $N$ можно посчитать следующим образом:
1. Если число $N$ содержит хотя бы одну цифру, отличную от нуля, кроме первой, то количество операций можно посчитать по формуле summa(N) + nonzero(N) – edinica(N) - 1, где summa(N) — сумма цифр числа, nonzero(N) — количество цифр, отличных от нуля, на всех позициях числа $N$, кроме последней, edinica(N) — число, которое равно единице, если хотя бы на одной позиции числа $N$, кроме последней, есть единица, или равна нулю, если единиц на этих позициях нет.
2. Если все цифры числа $N$, кроме первой, нулевые, а первая цифра больше единицы, то количество операций можно посчитать по формуле summa(N-1)+nonzero(N-1) – edinica(N-1).

Доказательство формул

Для дальнейшего удобства обозначим перестановку цифр числа через $\Rightarrow$.
Число $N$ -заданное число, число $n$ -количество цифр числа $N$. Если $n=1$, $N=7$, то для того, чтобы дойти от единицы до заданного числа, потребуется $N-1$ операций. В нашем случае $6$ операций
($1+1=2,
2+1=3,
…
6+1=7$)
Если $n\geq2$, то для этого достаточно привести пример цепочки, подсчитывающая количество операций, которая число $10^{n-1}$ превращает в $N$. Но вместо прямого порядка действий будем делать обратный эквивалентный. $N \Rightarrow 10^{n-1}$. За одну операцию мы можем или уменьшить число на единицу, или переставить в нем цифры так, чтобы на первом месте оказался не нуль. Могут возникнуть следующие случаи:
1. Если $N=10^{n-1}$, то количество операций равно summa(N) + nonzero(N) - edinica(N) - 1 $= $ $0$.
Например, возьмем число $1000$. Сумма цифр $= 1$, количество ненулевых цифр $= 1$, количество единиц $= 1$, соответственно значение $= 1+1-1-1 =0$.

2. Если $N!=10^{n-1}$ и первая цифра числа $N$ равна единице, то проводим следующие операции:
Сначала отнимаем от числа $N$ столько единиц, чтобы последняя цифра стала нулем, далее переставим местами последнюю цифру с какой-нибудь другой, отличной от нуля, кроме первой, и опять отнимем количество единиц, чтобы последняя цифра стала нулевой. Повторять будем до тех пор, пока все цифры, кроме первой, не станут нулями.
Например, возьмем число $137$.
$137-1=136$, $136-1=135$, $135-1=134$, $134-1=133$ ,$133-1=132$ ,$132-1=131$, $131-1=130$ ,$130 \Rightarrow 103$ , $103-1=102$, $102-1=101$, $101-1=100$
Количество операций $= 11$. Проверяем по формуле. summa(137)=11, nonzero(137)=2, edinica(137)=1. Итого получаем $11+2-1-1=11$

3. Если первая цифра числа $N$ больше единицы, но хотя бы на одной позиции числа, кроме последней, есть единица, то проводим следующие операции:
Сначала уменьшаем последнюю цифру, пока она не станет нулем, затем переставляем цифры: поставим на место первой цифры единицу, а первую цифру сделаем последней, а нуль, который стоял в конце числа, поставим на место бывшей первой цифры. После этого будем действовать согласно алгоритму пункта №2.
Например, число $318$.
$318-1=317$, $317-1=316$, $316-1=315$, $315-1=314$, $314-1=313$, $313-1=312$, $312-1=311$, $311-1=310$, $310 \Rightarrow 103$, $103-1=102$, $102-1=101$, $101-1=100$
Итого $12$ операций. Просчитываем по формуле summa(318)+nonzero(318)-edinica(318)-1.
Получаем $12+2-1-1=12$.

4. Если ни на одной из позиций числа $N$, кроме, возможно, последней, нет единиц, но в числе есть хотя бы одна ненулевая цифра, кроме первой, то проводим следующие операции:
Последнюю цифру делаем нулевой, переставляем последний нуль с любой ненулевой цифрой, кроме первой, пока на последнем месте не окажется последняя ненулевая цифра (не считая первую), последнюю ненулевую уменьшаем не до нуля, а до единицы, переставим единицу с первой цифрой, новую последнюю цифру сделаем нулевой.
Например, число $3028$.
$3028-1=3027$, $3027-1=3026$, $3026-1=3025$, $3025-1=3024$, $3024-1=3023$, $3023-1=3022$, $3022-1=3021$, $3021-1=3020$, $3020 \Rightarrow 3002$, $3002-1=3001$, $3001 \Rightarrow 1003$, $1003-1=1002$, $1002-1=1001$, $1001-1=1000$
Получаем $14$ операций. Проверяем по формуле summa(3028)+nonzero(3028)-edinica(3028)-1 $= 13+2-0-1=14$.

5. Если первая цифра числа $N$ больше единицы, а все другие цифры — нулевые, то проводим следующие операции:
Отнимем от числа $N$ единицу, а дальше будем использовать один из раннее написанных алгоритмов в пунктах 2-4.
Например, число $300$.
$300-1=299$, $299-1=298$, $298-1=297$, $297-1=296$, $296-1=295$ $=$ … $291-1=290$, $290 \Rightarrow 209$, $209-1=208$ $=$ … $202-1=201$, $201 \Rightarrow 102$, $102-1=101$, $101-1=100$
Итого $22$ операции. summa(300-1)+nonzero(300-1)-edinica(300-1) $= 20+2-0=22$.

6. Подсчет операций от $1$ до $10^{n-1}$.
Для того, чтобы перейти от числа $10^{n-1}$ к $10^n$, понадобится число $10^n – 1$,которое равно $k$. По предыдущим алгоритмам, понадобится:
summa(k)+ nonzero(k) – edinica(k) - 1 $=$ $9 \cdot n + (n-1) -0 -1=10 \cdot n – 2$ операций, где $n > 1$.
Если $n=1$, то количество операций $= 10 \cdot n – 2 =8$.

Количество операций можно посчитать по формуле $(5 \cdot n -1) \cdot (n – 1)$ ,где $n$- количество цифр заданного числа.

Ссылки

Related Images:

e-olymp 4739. Решето Эратосфена

08/12/2020 by Oleksandr.Ivanov

Задача

По заданным числам $a$ и $b$ вывести все простые числа в интервале от $a$ до $b$ включительно.

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

Два числа $a$ и $b \ (1 \leqslant a \leqslant b \leqslant 100000)$.

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

Вывести в одной строке все простые числа в интервале от $a$ до $b$ включительно.

Тесты

№	Входные данные	Выходные данные	Объяснение
1	2 2	2
2	1 100	2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
3	50 100	53 59 61 67 71 73 79 83 89 97
4	10 2		Неправильно, так как противоречит условию ($a \leqslant b$)
5	99900 100000	99901 99907 99923 99929 99961 99971 99989 99991
6	-15 -6	-13 -11 -7	Неправильно, так как противоречит условию ($1 \leqslant a \leqslant b \leqslant 100000$)

Код

#include <iostream>
#include <cmath>

using namespace std;


bool eratosthenesSieve(int currentNumber) {
    /*
    Describe the function that checks if the number is prime and returns a boolean value.
    This function is based on the "sieve of Eratosthenes" algorithm.
    True - if the number is prime, false - normal.
    */
    
    // If the number equals to 1 or if it even, return false. And if it equals to 2, return true.
    if (currentNumber == 2 or currentNumber == 3) {
        return true;
    } else if (!(currentNumber % 2) or !(currentNumber % 3) or currentNumber == 1) {
        return false;
    }
    
    // If the number has the divider from 5 to the root of this number with the second step return false.
    for (int divider = 5; divider <= sqrt(currentNumber); divider += 2) {
        if (!(currentNumber % divider)) {
            return false;
        }
    }
    
    // In all other situations, return true.
    return true;
}


void printSequenceOfPrimeNumbers(int beginning, int ending) {
    /*
    This function prints all prime numbers in a line.
    It contains a loop that starts and ends with the given values.
    */

    for (int sequenceElement = beginning; sequenceElement <= ending; sequenceElement += 1) {
        if (eratosthenesSieve(sequenceElement)) {
            cout << sequenceElement << " ";
        }
    }
}


int main() {
    /*
    Receive the beginning and end of the sequence.
    */
    
    int beginning, ending;
    cin >> beginning >> ending;
    
    // Calling the function.
    printSequenceOfPrimeNumbers(beginning, ending);

    return 0;
}

#include <iostream>

#include <cmath>

using namespace std;

bool eratosthenesSieve(int currentNumber) {

Describe the function that checks if the number is prime and returns a boolean value.

This function is based on the "sieve of Eratosthenes" algorithm.

True - if the number is prime, false - normal.

// If the number equals to 1 or if it even, return false. And if it equals to 2, return true.

if (currentNumber == 2 or currentNumber == 3) {

return true;

} else if (!(currentNumber % 2) or !(currentNumber % 3) or currentNumber == 1) {

return false;

}

// If the number has the divider from 5 to the root of this number with the second step return false.

for (int divider = 5; divider <= sqrt(currentNumber); divider += 2) {

if (!(currentNumber % divider)) {

return false;

}

// In all other situations, return true.

return true;

}

void printSequenceOfPrimeNumbers(int beginning, int ending) {

This function prints all prime numbers in a line.

It contains a loop that starts and ends with the given values.

for (int sequenceElement = beginning; sequenceElement <= ending; sequenceElement += 1) {

if (eratosthenesSieve(sequenceElement)) {

cout << sequenceElement << " ";

}

int main() {

Receive the beginning and end of the sequence.

int beginning, ending;

cin >> beginning >> ending;

// Calling the function.

printSequenceOfPrimeNumbers(beginning, ending);

return 0;

}

Решение

Решето Эратосфена это алгоритм поиска простых чисел.
Решение данной задачи сводится к тому, чтобы воплотить данный алгоритм. По мере прохождения перечня, нужные числа остаются, а ненужные (составные) исключаются.

Это решето подразумевает фильтрацию, в данном случае фильтрацию всех чисел за исключением простых.

Рассуждение:
— Все четные числа, не считая двойки, — составные, то есть не являются простыми, так как делятся не только на себя и единицу, а также еще на $2$.
— Все числа кратные трем, кроме самой тройки, — составные, так как делятся не только на самих себя и единицу, а также еще на $3$.
— Число $4$ уже выбыло из игры, так как делится на $2$.
— Число $5$ простое, так как его не делит ни один простой делитель, стоящий до него.
— Если число не делится ни на одно простое число, стоящее до него, значит оно не будет делиться ни на одно сложное число, стоящее до него.

В моем коде, указанном выше, была реализована функция-фильтр, которая, по большей части, реализовывает метод перебора делителей и проверяет: есть ли делители числа, кроме его самого, вплоть до корня из этого числа. И если остатки от деления не равны $0$, то мы возвращаем истину, что означает: число простое.

Таким же образом, проверяем все остальные числа из промежутка от $n$ до $m$ и выводим полученную последовательность на экран.

Ссылки

Related Images:

Ю11.3

20/12/2014 by Янішевська Альона Русланівна

Задача. Метод Эйткена-Стеффенсона (развитие метода простой итерации). Найти решение уравнения [latex]x=\varphi(x)[/latex] методом Эйткена-Стеффенсона, в котором от заданного начального [latex]x_{0}[/latex] три очередных приближения находятся по формулам: [latex]x_{n+1}=\varphi (x_{n})[/latex]; [latex]x_{n+2}=\varphi (x_{n+1})[/latex]; [latex]x_{n+3}=\frac{x_{n}x_{n+2}-x_{n+1}^{2}}{x_{n}-2x_{n+1}+x_{n+2}}[/latex]. Процесс продолжается до достижения одного из условий: [latex]\left | x_{n+3}-x_{n+2} \right |<\varepsilon[/latex] или [latex]x_{n}-2x_{n+1}+x_{n+2}=0[/latex].

Решение. В начале мы задаем начальное приближение [latex]x=x_{0}[/latex] и [latex]\varepsilon[/latex]. Нам понадобится цикл с постусловием. Далее вычисляем первое приближение [latex]x_{1}=\varphi (x_{0})[/latex] и второе приближение [latex]x_{2}=\varphi (x_{1})[/latex]. Находим по формуле [latex]x=\frac{x_{0}x_{2}-x_{1}^{2}}{x_{0}-2x_{1}+x_{2}}[/latex]. Далее мы проверяем выполнение условия выхода из цикла: если [latex]\left | x-x_{0} \right |>\varepsilon[/latex] (нужно проверять разность [latex]\left | x-x_{0} \right |>\varepsilon[/latex], а не [latex]\left | x-x_{2} \right |>\varepsilon[/latex]) и [latex]x_{0}-2x_{1}+x_{2}\neq 0[/latex] тогда цикл продолжается, но если хотя бы одно из условий выполнено, то мы получаем, что [latex]x[/latex] — решение уравнения [latex]x=\varphi(x)[/latex].

Данная программа написана для функции [latex]9.2x^{3}+3.3x^{2}+4x-1[/latex].

Тесты:

x	[latex]\varepsilon[/latex]	Корень уравнения	Комментарий
2	0.005	1.99889	Пройден
1	0.00002	0.233905	Пройден
-4	0.0005	-3.99981	Пройден

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

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

double f(double x)
{
	return 9.2*x*x*x+3.3*x*x+4*x-1; //задаем уравнение
}

double es(double x, double eps) //с помощью метода Эйтнена-Стеффенсона считаем приближения
{
	double x0, x1, x2, d;
	do
	{
		x0=x;
		x1=f(x0);
		x2=f(x1);
		d=x0-2*x1+x2;
		if (d!=0)
		{
			x=(x0*x2-x1*x1)/d;
		}
		else return x;
	}
	while(fabs(x-x0)>eps); //условие окончания подсчета 
	return x;
}

int main() {
	double x, eps;
	cin >> x >> eps;
	cout << es(x, eps);
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

double f(double x)

{

return 9.2*x*x*x+3.3*x*x+4*x-1; //задаем уравнение

}

double es(double x, double eps) //с помощью метода Эйтнена-Стеффенсона считаем приближения

{

double x0, x1, x2, d;

{

x0=x;

x1=f(x0);

x2=f(x1);

d=x0-2*x1+x2;

if (d!=0)

{

x=(x0*x2-x1*x1)/d;

}

else return x;

}

while(fabs(x-x0)>eps); //условие окончания подсчета

return x;

}

int main() {

double x, eps;

cin >> x >> eps;

cout << es(x, eps);

return 0;

}

Код программы можно проверить здесь.

Решение на Java:

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

class Ideone
{
	static double f(double x)
	{
	   return 9.2*x*x*x+3.3*x*x+4*x-1; 
	}
	
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner  in = new Scanner(System.in);
		double x, eps, x0, x1, x2, d;
		x = in.nextDouble();
		eps = in.nextDouble();
		do{
			x0=x;
			x1=f(x0);
			x2=f(x1);
			d=x0-2*x1+x2;
			if (d!=0)
			{
				x=(x0*x2-x1*x1)/d;
			}
			else break;
    	} 	
    	while(Math.abs(x-x0)>eps);
    	System.out.print(x+" "); 
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

static double f(double x)

{

return 9.2*x*x*x+3.3*x*x+4*x-1;

}

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

{

Scanner in = new Scanner(System.in);

double x, eps, x0, x1, x2, d;

x = in.nextDouble();

eps = in.nextDouble();

do{

x0=x;

x1=f(x0);

x2=f(x1);

d=x0-2*x1+x2;

if (d!=0)

{

x=(x0*x2-x1*x1)/d;

}

else break;

}

while(Math.abs(x-x0)>eps);

System.out.print(x+" ");

}

Ссылка на решение.

Related Images:

Ю11.8

29/11/2014 by Сорокина Полина

Метод Симпсона. Вычислить определённый интеграл [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] на концах отрезков.
В задачах на численное интегрирование определённый интеграл требуется найти с заданной точностью, для чего вычисление по формуле метода рекомендуется проводить многократно, каждый раз уменьшая шаг интегрирования в два раза, пока разница между соседними приближениями не станет меньше заданной погрешности.

Функция	[latex]a[/latex]	[latex]b[/latex]	[latex]eps[/latex]	Интеграл	Комментарий
[latex]f\left(x \right)=\sin \left(x^{2}+2x \right)[/latex]	1	3	0.0001	-0.143058	Тест пройден.
[latex]\ln \left(1+x \right)[/latex]	1	3	0.0001	2.15888	Тест пройден.
[latex]\tan \left(3x^{3} \right)[/latex]	2	15	0.01	0.0256033	Тест пройден.
[latex]x\left( x^{2}-1\right)\left(x+1 \right)[/latex]	-1	1	0.3	-0.265625	Тест пройден.

C++:

#include <iostream>
#include <math.h>
using namespace std;
 
double f(double x)
{
	return sin(x*x+2*x);	
}
 
int main() {
	double a, b, eps;//Нижний и верхний пределы интегрирования (a, b), погрешность (eps).
	cin >> a >> b >> eps;
	double I=eps+1, I1=0;//I-предыдущее вычисленное значение интеграла, I1-новое, с большим N.
	for (int N=2; (N<=4)||(fabs(I1-I)>eps); N*=2)
	{
		double h, sum2=0, sum4=0, sum=0;
		h=(b-a)/(2*N);//Шаг интегрирования.
		for (int i=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;
	return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

double f(double x)

{

return sin(x*x+2*x);

}

int main() {

double a, b, eps;//Нижний и верхний пределы интегрирования (a, b), погрешность (eps).

cin >> a >> b >> eps;

double I=eps+1, I1=0;//I-предыдущее вычисленное значение интеграла, I1-новое, с большим N.

for (int N=2; (N<=4)||(fabs(I1-I)>eps); N*=2)

{

double h, sum2=0, sum4=0, sum=0;

h=(b-a)/(2*N);//Шаг интегрирования.

for (int i=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;

return 0;

}

Java:

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

class Ideone
{
	public static double f (double x) {
			return Math.sin(x*x+2*x);	
	}

	public static void main (String[] args)
	{
		Scanner in = new Scanner(System.in);
		
		double a = in.nextDouble();//Нижний и верхний пределы интегрирования (a, b), погрешность (eps).
		double b = in.nextDouble();
		double eps = in.nextDouble();
		
		double I=eps+1, I1=0;//I-предыдущее вычисленное значение интеграла, I1-новое, с большим N.
			
		for (int N=2; (N<=4)||(Math.abs(I1-I)>eps); N*=2){
			double h, sum2=0, sum4=0, sum=0;
			h=(b-a)/(2*N);//Шаг интегрирования.
			for (int i=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);
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static double f (double x) {

return Math.sin(x*x+2*x);

}

public static void main (String[] args)

{

Scanner in = new Scanner(System.in);

double a = in.nextDouble();//Нижний и верхний пределы интегрирования (a, b), погрешность (eps).

double b = in.nextDouble();

double eps = in.nextDouble();

double I=eps+1, I1=0;//I-предыдущее вычисленное значение интеграла, I1-новое, с большим N.

for (int N=2; (N<=4)||(Math.abs(I1-I)>eps); N*=2){

double h, sum2=0, sum4=0, sum=0;

h=(b-a)/(2*N);//Шаг интегрирования.

for (int i=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]).

Задача на Ideone:
C++
Java

Related Images:

Ю11.13

23/11/2014 by Байков Дмитро

Задача

Метод Рунге-Кутта. Найти приближенное решение обыкновенного дифференциального уравнения [latex]y^\prime=f(x,y), y(a)=y_{0}[/latex] методом Рунге-Кутта пятого порядка на отрезке [latex][a,b][/latex] с заданным шагом [latex]h[/latex]. Значения функции [latex]y(x)[/latex] в узловых точках вычисляется по формуле: [latex]y_{i+1}=y_{i}+\frac{h}{6}(k_{1}+2k_{2}+2k_{3}+k_{4}), i=0,1,2,\cdots[/latex], где [latex]k_{1}=f(x_{i},y_{i}); k_{2}=f(x_{i}+\frac{h}{2},y_{i}+\frac{h}{2}k_{1});[/latex][latex]k_{3}=f(x_{i}+\frac{h}{2},y_{i}+\frac{h}{2}k_{2}); k_{4}=f(x_{i}+h,y_{i}+hk_{3})[/latex].

Решим дифференциальное уравнение такого вида: [latex]y^\prime=x+y[/latex] при начальном условии [latex]y(0)=1[/latex] на отрезке [latex][0, 0.5][/latex] с шагом интегрирования [latex]h=0.1[/latex]

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

#include <iostream>
using namespace std;

double fdif(double x,double y)
{
	return x+y;
}

int main() 
{
	double k1, k2, k3, k4, dy, x, y0, a, b, h;
	scanf("%lf %lf %lf %lf", &a, &b, &h, &y0);
	for ( x ; x <= b ; x += h )
	{		
		k1 = fdif (x , y0);
		k2 = fdif (x + h / 2 , y0 + h / 2 * k1);
		k3 = fdif (x + h / 2 , y0 + h / 2 * k2);
		k4 = fdif (x + h , y0 + h * k3);
		y0 += h * ( k1 + 2 * k2 + 2 * k3 + k4 ) / 6;
	}
	printf("%lf", y0);
	return 0;
}

#include <iostream>

using namespace std;

double fdif(double x,double y)

{

return x+y;

}

int main()

{

double k1, k2, k3, k4, dy, x, y0, a, b, h;

scanf("%lf %lf %lf %lf", &a, &b, &h, &y0);

for ( x ; x <= b ; x += h )

{

k1 = fdif (x , y0);

k2 = fdif (x + h / 2 , y0 + h / 2 * k1);

k3 = fdif (x + h / 2 , y0 + h / 2 * k2);

k4 = fdif (x + h , y0 + h * k3);

y0 += h * ( k1 + 2 * k2 + 2 * k3 + k4 ) / 6;

}

printf("%lf", y0);

return 0;

}

Для решения примера введем данные во входной поток в таком порядке: [latex]0.0[/latex], [latex]0.5[/latex], [latex]0.1[/latex], [latex]1.0[/latex], где первое и второе число — начало и конец отрезка интегрирования соответственно, третье — шаг интегрирования и четвертое — значение [latex]y[/latex] в точке [latex]a[/latex] (в начале отрезка), т.е. [latex]y(a)=y(0)[/latex].

В программе присутствует функция, которой мы передаем параметры [latex]x, y[/latex] и которая возвращает само дифференциальное уравнение. Далее, в цикле высчитываем значения [latex]k_{1},k_{2},k_{3},k_{4}[/latex], передавая каждый раз параметры в функцию с шагом [latex]h[/latex] до тех пор пока не дойдем до конца промежутка. После завершения цикла выводим значение [latex]y_{0}[/latex].

Related Images:

Ю11.6

13/11/2014 by Кваша Дар`я Михайлівна

Задача. Метод прямоугольников. Вычислить определенный интеграл [latex]I=\int_{a}^{b}{f(x)dx}[/latex] методом прямоугольников: [latex]\int^b_a f(x)\,dx \approx h (\frac{y_0}{2} + y_1 + \ldots + y_{n-1}+\frac{y_{n}}{2})[/latex], где [latex]n[/latex] — количество отрезков разбиения; [latex]y_{0},y_{1},…,y_{n}[/latex] — значения функции на концах отрезков.

Вычислим для функции [latex] f(x)=2x^{3}-7x+4[/latex]:

[latex] \int_{0}^{2}{(2x^{3}-7x+4)dx}=2[/latex]

#include <iostream>
using namespace std;

double f(double x)
{
	return (2*x*x*x-7*x+4);
}
int main() 
{
	double a,b;
	int n;
	cin>>a>>b>>n;
	double s=(f(a)+f(b))/2;
	double h=(b-a)/n;
	for (int i=1; i<=n-1; i++)
	{ 
		s+=f(a+i*h);
	}
	double I=h*s;
	cout<<setprecision(10)<<I<<endl;
	
	return 0;
}

#include <iostream>

using namespace std;

double f(double x)

{

return (2*x*x*x-7*x+4);

}

int main()

{

double a,b;

int n;

cin>>a>>b>>n;

double s=(f(a)+f(b))/2;

double h=(b-a)/n;

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

{

s+=f(a+i*h);

}

double I=h*s;

cout<<setprecision(10)<<I<<endl;

return 0;

}

Решение:

Введена функция, которая подсчитывает значение в точке. Согласно формуле в условии, вычисляем требуемое значение.

В условии приведена более точная формула, чем в учебнике.

С помощью программы можем наблюдать увеличение точности при увеличении количества отрезков разбиения. Сведем некоторые результаты в таблицу:

Количество отрезков разбиения на [a,b]	Результат
50	2.0032
500	2.000032
1000	2.000008
5000	2.00000032

С работой программы можно ознакомиться здесь.

Related Images:

Ю11.7

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

Метод трапеций. Вычислить определенный интеграл [latex]I=\int_{b}^{a}f(x)dx [/latex] методом трапеций:[latex] I\approx \frac{b-a}{2n}(y_{0}+2y_{1}+\dots+2y_{n-1}+y_{n}), [/latex] где [latex] n [/latex] — количество отрезков разбиения; [latex]y_{0},y_{1},\ldots,y_{n} [/latex] — значения функции [latex]f(x) [/latex] на концах отрезков.

Вычислим определенный интеграл для функции [latex]y=-3x^2+2x+9[/latex] [latex] \int_{-1}^{2}(-3x^2+2x+9)dx=21 [/latex]

Решение:

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

#include <iostream>
#include <math.h>
using namespace std;
	double f(double x){return (-3*x*x+2*x+9);}
	double I(double a,double b,int n,double y){return ((b-a)/(2*n)*y);}
int main() {
	int n; double a,b,y,dy,In;
	cin>>a>>b>>n;
	if (n>1){
		dy=(b-a)/n;
		y+=f(a)+f(b);
		for (int i=1; i<n; i++) {y+=2*(f(a+dy*i));}
		In=I(a,b,n,y);
		cout << In;
	}
	else {cout << "Wrong data";}
}

#include <iostream>

#include <math.h>

using namespace std;

double f(double x){return (-3*x*x+2*x+9);}

double I(double a,double b,int n,double y){return ((b-a)/(2*n)*y);}

int main() {

int n; double a,b,y,dy,In;

cin>>a>>b>>n;

if (n>1){

dy=(b-a)/n;

y+=f(a)+f(b);

for (int i=1; i<n; i++) {y+=2*(f(a+dy*i));}

In=I(a,b,n,y);

cout << In;

}

else {cout << "Wrong data";}

}

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

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

class Ideone
{
	public static double f(double x){return (-3*x*x+2*x+9);}
	public static double I(double a,double b,int n,double y){return ((b-a)/(2*n)*y);}
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in = new Scanner(System.in);
		int n; double a,b,dy,In,y=0;
		a = in.nextDouble();
		b = in.nextDouble();
		n = in.nextInt();
		if (n>1){
			dy=(b-a)/n;
			y+=f(a)+f(b);
			for (int i=1; i<n; i++) {y+=2*(f(a+dy*i));}
			In=I(a,b,n,y);
			System.out.printf("%f", In);
		}
		else {System.out.printf("Wrong Data");}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static double f(double x){return (-3*x*x+2*x+9);}

public static double I(double a,double b,int n,double y){return ((b-a)/(2*n)*y);}

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

{

Scanner in = new Scanner(System.in);

int n; double a,b,dy,In,y=0;

a = in.nextDouble();

b = in.nextDouble();

n = in.nextInt();

if (n>1){

dy=(b-a)/n;

y+=f(a)+f(b);

for (int i=1; i<n; i++) {y+=2*(f(a+dy*i));}

In=I(a,b,n,y);

System.out.printf("%f", In);

}

else {System.out.printf("Wrong Data");}

}

В условии самой задачи весь алгоритм решения расписан.

Related Images:

Ю11.15

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

Метод парабол. Найти минимум заданной функции [latex]y=f(x)[/latex], двигаясь от заданной точки [latex]x_{0}[/latex] по методу парабол:

[latex]x_{i+1}=x_{i}-\frac{h}{2}\frac{f\left( x_{i}+h\right)-f\left( x_{i}-h\right)}{f\left( x_{i}+h\right)-2f\left( x_{i}\right)+f\left( x_{i}-h\right)}, i=0,1,\ldots[/latex], пока не будет достигнута заданная точность.

Функция [latex]x^{3}+10\sin (5x)[/latex]:

[latex]x_{0}[/latex]	[latex]\varepsilon[/latex]	Точка минимума по графику.	Точка минимума по программе.	Комментарий.
0	0,001	-0,315353	-0,315353	Тест пройден.
1	0,0001	0,932048	0,932048	Тест пройден.
2	0,0001	2,14327	2,14327	Тест пройден.
-3	0,01	-2,93616	-2,93616	Тест пройден.
-2	0,0001	-1,6017	-1,6017	Тест пройден.

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

Для функции [latex]x^{3}+10\sin (5x)[/latex] (функцию всегда можно изменить, достаточно исправить строку 6):

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

double f(double x) {
    return x*x*x+10*sin(5*x);
}

int main() {
    double h=0.001;
    double x, pogr;
    cin >> x >> pogr;
    if (x==0) x+=0.1;
    while ((f(x+h)-2*f(x)+f(x-h))/(h*h)<=0) x+=0.1;
    double x1;
    x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));
    while (fabs(x1-x)>pogr) {
        x=x1;
        x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));
    }
    cout << x1;
    return 0;
}

#include <iostream>

#include <math.h>

using namespace std;

double f(double x) {

return x*x*x+10*sin(5*x);

}

int main() {

double h=0.001;

double x, pogr;

cin >> x >> pogr;

if (x==0) x+=0.1;

while ((f(x+h)-2*f(x)+f(x-h))/(h*h)<=0) x+=0.1;

double x1;

x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));

while (fabs(x1-x)>pogr) {

x=x1;

x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));

}

cout << x1;

return 0;

}

Java:

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Ideone
{
    public static double f (double x) {
        return x*x*x+10*Math.sin(5*x);
    }
    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner in =  new Scanner (System.in);
        double h=0.001;
        double x, pogr;
        x=in.nextDouble();
        pogr=in.nextDouble();
        if (x==0) x+=0.1;
        while ((f(x+h)-2*f(x)+f(x-h))/(h*h)<=0) x+=0.1;
        double x1;
        x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));
        while (Math.abs(x1-x)>pogr) {
            x=x1;
            x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));
        }
        System.out.format ("%f%n", x1);
    }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Ideone

{

public static double f (double x) {

return x*x*x+10*Math.sin(5*x);

}

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

{

Scanner in = new Scanner (System.in);

double h=0.001;

double x, pogr;

x=in.nextDouble();

pogr=in.nextDouble();

if (x==0) x+=0.1;

while ((f(x+h)-2*f(x)+f(x-h))/(h*h)<=0) x+=0.1;

double x1;

x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));

while (Math.abs(x1-x)>pogr) {

x=x1;

x1=x-0.5*h*(f(x+h)-f(x-h))/(f(x+h)-2*f(x)+f(x-h));

}

System.out.format ("%f%n", x1);

}

Чтобы сделать программу, я почитала “Численные методы” Н. Н. Калиткина, где и было сказано, что в качестве вспомогательного шага [latex]h[/latex] при расчётах на ЭВМ обычно выбирают значение 0,001.

Далее пользователю предоставляется возможность ввести значение [latex]x_{0}[/latex] и задать точность [latex]\varepsilon[/latex]. Корень [latex]x[/latex] является минимумом функции тогда и только тогда, когда вторая производная этой функции больше 0. Поэтому мы запускаем цикл, который будет сдвигать наше [latex]x_{0}[/latex] в положительном направлении оси [latex]x[/latex], пока вторая производная функции не будет удовлетворять условию задачи.

Далее мы вычисляем значение [latex]x_{i+1}[/latex], и запускаем цикл, который будет продолжаться до тех пор, пока разница между [latex]x_{i}[/latex] и [latex]x_{i+1}[/latex] не будет меньше заданной погрешности [latex]\varepsilon[/latex].

Затем на экран выводится сама точка минимума функции.

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

Related Images:

Ю3.33

25/10/2014 by Швандт Максим Альбертович

Задача: В задаче задана функция и её разложение в ряд или произведение. Численно убедится в справедливости равенства, для чего для заданного значения аргумента [latex] x [/latex] вычислить левую его часть и разложение, стоящее в правой части, с заданной погрешностью [latex]\varepsilon\[/latex]. Испытать разложение на сходимость при разных значениях аргумента, оценить скорость сходимости, для чего вывести число итераций [latex] n [/latex] (слагаемых или сомножателей), необходимых для достижения заданной точности.
[latex]\sin \left(x \right) = x \left(1 — \frac{x^{2}}{\pi^{2}} \right) \left( 1 — \frac{x^{2}}{4\pi^{2}} \right) \ldots \left(1 — \frac{x^{2}}{ \left( n-1 \right)^{2}\pi^{2}} \right)[/latex]

Тесты:

x	n-Excel	sin — Excel	deviation — Excel	e — input	exact sinus	n — program	deviation — program
12	22	-1,029367	0.56	0.56	-0.536573	22	0.524789
5	7	-1,346966	0.54	0.54	-0.958924	7	0.461469
2.5	2	0,771704	-1.15	-1.15	0.598472	2	-0.318384
1	2	0,875915	-1.38	-1.38	0.841471	2	-0.057208
0	2	0	-0.53	-0.53	0	2	0
-1	2	-0,875915	0.3	0.3	-0.841471	2	0.057208
-2.5	6	-0,659746	0.08	0.08	-0.598472	6	0.073087
-5	4	1,700161	-1.62	-1.62	0.958924	4	-1.061024
-12	12	1,755690	-1.63	-1.63	0.536573	12	-1.417062

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

#include <stdio.h>
#include <math.h>

double pow2( double x ) //вторая степень
{
   return x*x;
}

int main()
{
   // рабочие переменные
   double x, e, d, r;
   unsigned int n, nMax = 0xffffffff; // лимит числа итераций чтобы избежать бесконечного цикла
  
   // ввод данных - аргумента функции и заданной погрешности
   scanf("%lf", &x);  
   scanf("%lf", &e);

   for( r = x, n = 2; n < nMax; n++ ) // основной цикл вычислений
   {
      r = r * ( 1 - pow2( x ) / ( pow2( n - 1 ) * pow2( M_PI ) ) );
      d = sin( x ) - r ;  
      if( fabs( d ) <= fabs( e ) ) break;
   }      
   
   // вывод результата
   printf("sin(x) = %lf\n", sin( x ) );
   printf("calculated sinus = %lf\n", r );
   printf("inaccuracy = %lf\n", d );
   printf("number of iterations: %d\n", n );
   
   return 0;
}

#include <stdio.h>

#include <math.h>

double pow2( double x ) //вторая степень

{

return x*x;

}

int main()

{

// рабочие переменные

double x, e, d, r;

unsigned int n, nMax = 0xffffffff; // лимит числа итераций чтобы избежать бесконечного цикла

// ввод данных - аргумента функции и заданной погрешности

scanf("%lf", &x);

scanf("%lf", &e);

for( r = x, n = 2; n < nMax; n++ ) // основной цикл вычислений

{

r = r * ( 1 - pow2( x ) / ( pow2( n - 1 ) * pow2( M_PI ) ) );

d = sin( x ) - r ;

if( fabs( d ) <= fabs( e ) ) break;

}

// вывод результата

printf("sin(x) = %lf\n", sin( x ) );

printf("calculated sinus = %lf\n", r );

printf("inaccuracy = %lf\n", d );

printf("number of iterations: %d\n", n );

return 0;

}

Код программы на языке Java:

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

class SinusApp
{
   public static Double scanDouble( Scanner in )
   {
       return ( ( in.hasNextDouble() ) ? in.nextDouble() : null );
   }
   
   public static double pow2( double x ) //вторая степень
   {
      return x*x;
   }
   
   public static void main( String[] args )
   {
      // рабочие переменные
      double x, e, d, r;
      long n, nMax = Long.MAX_VALUE; // лимит числа итераций чтобы избежать бесконечного цикла
     
     
      // ввод данных - аргумента функции и заданной погрешности
      Scanner in = new Scanner(System.in);
      
      x = scanDouble( in );
      e = scanDouble( in );
   
      in.close(); 
   
      for( d = 0, r = x, n = 2; n < nMax; n++ ) // основной цикл вычислений
      {
         r = r * ( 1 - pow2( x ) / ( pow2( n - 1 ) * pow2( Math.PI ) ) );
         d = Math.sin( x ) - r ;  
         if( Math.abs( d ) <= Math.abs( e ) ) break;
      }      
      
      // вывод результата
      System.out.printf("sin(x) = %f\n", Math.sin( x ) );
      System.out.printf("calculated sinus = %f\n", r );
      System.out.printf("inaccuracy = %f\n", d );
      System.out.printf("number of iterations: %d\n", n );

   }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class SinusApp

{

public static Double scanDouble( Scanner in )

{

return ( ( in.hasNextDouble() ) ? in.nextDouble() : null );

}

public static double pow2( double x ) //вторая степень

{

return x*x;

}

public static void main( String[] args )

{

// рабочие переменные

double x, e, d, r;

long n, nMax = Long.MAX_VALUE; // лимит числа итераций чтобы избежать бесконечного цикла

// ввод данных - аргумента функции и заданной погрешности

Scanner in = new Scanner(System.in);

x = scanDouble( in );

e = scanDouble( in );

in.close();

for( d = 0, r = x, n = 2; n < nMax; n++ ) // основной цикл вычислений

{

r = r * ( 1 - pow2( x ) / ( pow2( n - 1 ) * pow2( Math.PI ) ) );

d = Math.sin( x ) - r ;

if( Math.abs( d ) <= Math.abs( e ) ) break;

}

// вывод результата

System.out.printf("sin(x) = %f\n", Math.sin( x ) );

System.out.printf("calculated sinus = %f\n", r );

System.out.printf("inaccuracy = %f\n", d );

System.out.printf("number of iterations: %d\n", n );

}

Ссылка:http://ideone.com/nZluY8

Программа состоит из следующих частей:

Определение вспомогательной функции
Рабочие переменные
Определяем лимит числа итераций чтобы избежать бесконечного цикла
Ввод данных — аргумента функции и заданной погрешности
Условие выполнения
Вывод результата

Правильность результата проверялась на калькуляторе. тестирование показало, что правильные значения получаются только при очень большом n . Только начиная с десятков тысяч результат близок к показанию калькулятора.

Данные для проверки подготавливались в Excel ввиду относительно большого количества итераций, необходимых для расчётов. Полученная погрешность с точным значением синуса использовались как входное [latex]e[/latex]. Результирующее количество итераций программы сравнивалось с числом итераций, сделанных в Excel. Ввиду того, что double намного точнее чем значения в Excel, возможны различия в числе итераций ( назначенных ).

Ссылка на ideone.com: http://ideone.com/fork/Wh91nH

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().

Related Images:

Ю11.12

21/10/2014 by Бронфен-Бова Роман

Задача:
Интерполяционный многочлен Лагранжа. Значения функции [latex]y=f\left(x\right)[/latex] заданы таблично в массиве [latex]Y\left(x\right)[/latex] при соответствующих значениях аргумента в упорядоченном массиве [latex]X\left(x\right)[/latex]. Найти значение функции в произвольной точке [latex]x[/latex] по формуле Лагранжа:
[latex]y={L}_{n}\left(x\right)=\sum _{i=1}^{n}{{y}_{i}\prod _{\underset{j\neq i}{j=1}}^{n}{\frac{x-{x}_{j}}{{x}_{i}-{x}_{j}}}}[/latex]

Вводимые значения:

X:	-1	0	1	2
Y:	1	2	3	-1

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

#include <iostream>
#include <vector>
using namespace std;

double LP(double x, vector<double> xv, vector<double> yv) { //Lagrange polynomial
	int size = xv.size(); //Количество точек (для удобства)
	double sum = 0; //Значение функции
	for(int i = 0; i < size; i++){
		double mul = 1; //Произведение
		for(int j = 0; j < size; j++){
			if(i!=j) mul *= (x - xv[j])/(xv[i]-xv[j]);
		}
		sum += yv[i]*mul;
	}
	return sum;
}

int main() {
	int counter = 0;
	double a = -3; //Левая грань
	double b = 3; //Правая грань
	int fragments = 101; //Разбиение
	vector<double> xv {};
	vector<double> yv {};
	double inp;
	while(cin >> inp) counter++%2 ? yv.push_back(inp) : xv.push_back(inp); //Заполнение
	for(int i = 0; i < fragments; i++){
		double x = a + (b-a)/(fragments-1)*i;
		printf("%6.3lf\t%6.3lf\n", x, LP(x, xv, yv));
	}
	return 0;
}

#include <iostream>

#include <vector>

using namespace std;

double LP(double x, vector<double> xv, vector<double> yv) { //Lagrange polynomial

int size = xv.size(); //Количество точек (для удобства)

double sum = 0; //Значение функции

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

double mul = 1; //Произведение

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

if(i!=j) mul *= (x - xv[j])/(xv[i]-xv[j]);

}

sum += yv[i]*mul;

}

return sum;

}

int main() {

int counter = 0;

double a = -3; //Левая грань

double b = 3; //Правая грань

int fragments = 101; //Разбиение

vector<double> xv {};

vector<double> yv {};

double inp;

while(cin >> inp) counter++%2 ? yv.push_back(inp) : xv.push_back(inp); //Заполнение

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

double x = a + (b-a)/(fragments-1)*i;

printf("%6.3lf\t%6.3lf\n", x, LP(x, xv, yv));

}

return 0;

}

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

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Main
{
 
	static double LP(double x, double[] xv, double[] yv){
		int size = xv.length;
		double sum = 0;
		for(int i = 0; i < size; i++){
			double mul = 1;
			for(int j = 0; j < size; j++){
				if(i != j){
					mul *= (x-xv[j])/(xv[i]-xv[j]);
				}
			}
			sum += yv[i]*mul;
		}
		return sum;
	}
 
	static Scanner sc = new Scanner(System.in);
 
	public static void main (String[] args) throws java.lang.Exception
	{
		int counter = 0;
		double a = -3;
		double b = 3;
		int fragments = 101;
		ArrayList<Double> xvinp = new ArrayList<Double>();
		ArrayList<Double> yvinp = new ArrayList<Double>();
		double[] xv;
		double[] yv;
		while(sc.hasNext()){
			double inp = sc.nextDouble();
			if(counter%2 == 0){
				xvinp.add(inp);
			}else{
				yvinp.add(inp);
			}
			counter++;
		}
		xv = new double[xvinp.size()];
		yv = new double[yvinp.size()];
		for(int i = 0; i < xvinp.size(); i++){
			xv[i] = xvinp.get(i);
			yv[i] = yvinp.get(i);
		}
		for(int i = 0; i < fragments; i++){
			double x = a + (b-a)/(fragments-1)*i;
			System.out.println(x + "\t" + LP(x, xv, yv));
		}
	}
}

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

static double LP(double x, double[] xv, double[] yv){

int size = xv.length;

double sum = 0;

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

double mul = 1;

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

if(i != j){

mul *= (x-xv[j])/(xv[i]-xv[j]);

}

sum += yv[i]*mul;

}

return sum;

}

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

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

{

int counter = 0;

double a = -3;

double b = 3;

int fragments = 101;

ArrayList<Double> xvinp = new ArrayList<Double>();

ArrayList<Double> yvinp = new ArrayList<Double>();

double[] xv;

double[] yv;

while(sc.hasNext()){

double inp = sc.nextDouble();

if(counter%2 == 0){

xvinp.add(inp);

}else{

yvinp.add(inp);

}

counter++;

}

xv = new double[xvinp.size()];

yv = new double[yvinp.size()];

for(int i = 0; i < xvinp.size(); i++){

xv[i] = xvinp.get(i);

yv[i] = yvinp.get(i);

}

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

double x = a + (b-a)/(fragments-1)*i;

System.out.println(x + "\t" + LP(x, xv, yv));

}

Идея решения:
Использование отдельной функции, которой надо передать 3 параметра: значение аргумента, массив исходных значений аргумента и массив исходных значений функции при соответствующих аргументах. Эта функция возвращает значение многочлена Лагранжа при подстановки вместо [latex]x[/latex] конкретного значения.

В функции был использован внешний цикл for для вычисления суммы в формуле и внутренний цикл for для вычисления произведения [latex]\prod _{\underset{j\neq i}{j=1}}^{n}{\frac{x-{x}_{j}}{{x}_{i}-{x}_{j}}}[/latex].

В программе мы разбиваем отрезок [-3, 3] на 101 отдельную точку и вычисляем значение полинома Лагранжа для каждой из этих точек. Выводим на экран.

График:

Комментарии: Точки выбраны специально. Мне просто захотелось увидеть, как выглядит график функции, которую мы разбирали на паре (кстати по той же самой теме =) ). График сделан в xls. Векторы выбраны по причине ограниченности массива.

Related Images:

А58г

16/10/2014 by Швандт Максим Альбертович

Задача: Дано действительное число [latex]a[/latex]. Для функции [latex]f(x)[/latex], график которой представлен на рисунке, вычислить [latex]f(a)[/latex].
График:

Тесты:

a	f(a)
1	1
3.2	-0.015371
6	-0.027469
0	0
-1	1
-2.5	2.5
1.5	1
1.8	1
1.001	1

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

#include <stdio.h>

int main(void) {
	
   // Объявление переменных a, y, k, b типа float для хранения данных
   double a;
   double y;	
   double k;
   double b;	

   // Ввод пользователем значений переменной а с помощью scanf
   scanf("%lf", &a);
    
   // Вычисление и вывод результата по формуле с предварительным сравнением значения а,
   if( a <= 0 )
   { k = -1; b = 0; }
   else if ( a <= 1 )
   { k = 1; b = 0; }
   else if ( a < 2 )
   { k = 0; b = 1; }
   else 
   { k = -2; b = 5; }
   y = k*a + b;
    
   printf("result is %lf", y);
   // Завершение программы
   return 0;
}

#include <stdio.h>

int main(void) {

// Объявление переменных a, y, k, b типа float для хранения данных

double a;

double y;

double k;

double b;

// Ввод пользователем значений переменной а с помощью scanf

scanf("%lf", &a);

// Вычисление и вывод результата по формуле с предварительным сравнением значения а,

if( a <= 0 )

{ k = -1; b = 0; }

else if ( a <= 1 )

{ k = 1; b = 0; }

else if ( a < 2 )

{ k = 0; b = 1; }

else

{ k = -2; b = 5; }

y = k*a + b;

printf("result is %lf", y);

// Завершение программы

return 0;

}

Код программы на языке Java:

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

class GraphicApp
{
   public static Double scanDouble( Scanner in )
   {
       return ( ( in.hasNextDouble() ) ? in.nextDouble() : null );
   }
   
   public static void main( String[] args )
   {
      
      // ќбъ¤вление переменных a, y, k, b типа double дл¤ хранени¤ данных
      double a;
      double y;    
      double k;
      double b;    
      
      Scanner in = new Scanner(System.in);
      
      a = scanDouble( in );
       
      in.close(); 
       
      // ¬ычисление и вывод результата по формуле с предварительным сравнением значени¤ а,
      if( a <= 0 )
      { k = -1; b = 0; }
      else if ( a <= 1 )
      { k = 1; b = 0; }
      else if ( a < 2 )
      { k = 0; b = 1; }
      else 
      { k = -2; b = 5; }
      y = k*a + b;
       
      System.out.printf("result is %f\n", y);
   }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class GraphicApp

{

public static Double scanDouble( Scanner in )

{

return ( ( in.hasNextDouble() ) ? in.nextDouble() : null );

}

public static void main( String[] args )

{

// ќбъ¤вление переменных a, y, k, b типа double дл¤ хранени¤ данных

double a;

double y;

double k;

double b;

Scanner in = new Scanner(System.in);

a = scanDouble( in );

in.close();

// ¬ычисление и вывод результата по формуле с предварительным сравнением значени¤ а,

if( a <= 0 )

{ k = -1; b = 0; }

else if ( a <= 1 )

{ k = 1; b = 0; }

else if ( a < 2 )

{ k = 0; b = 1; }

else

{ k = -2; b = 5; }

y = k*a + b;

System.out.printf("result is %f\n", y);

}

Ссылка:http://ideone.com/e6UFys

Результат вычисляем по формуле:
[latex]y = ka + b[/latex] Программа состоит из следующих частей:

Объявление переменных a, y, k, b типа float для хранения данных
Ввод пользователем значений переменной а с помощью scanf
Вычисление и вывод результата по формуле с предварительным сравнением значения а
Завершение программы

Программа сравнивает значение переменной [latex]a[/latex] с значениями переменной [latex]x[/latex] на четырёх диапазонах, и в зависимости от диапазона использует для функции [latex]y = ka + b[/latex] нужные значения [latex]k[/latex] и [latex]b[/latex]. Так вычисляется [latex]f(a)[/latex].
Ссылка на ideone.com : http://ideone.com/N2toyp

Related Images:

Ю2.10

22/09/2014 by Швандт Максим Альбертович

Задача: Посылка. Можно ли коробку размером [latex]a \times b \times c[/latex] упаковать в посылку размером [latex]r \times s \times t[/latex] ? «Углом» укладывать нельзя.

Тесты:

a	b	c	r	s	t	result
1	1	1	3	3	3	Package is fitting to the box
23	2	4	54	45	22	Package is fitting to the box
0	0	0	1	1	0	Package cannot fit !
109	122	222	11	22	33	Package cannot fit !
13	43	21	55	76	89	Package is fitting to the box
23	15	17	44	81	92	Package is fitting to the box

Исходный код программы:

#include <stdio.h>
#include <math.h>

int main(void)
{

  // Объявление переменных a,b,c,r,s,t типа float для хранения входных данных

  float a = 0;
  float b = 0;
  float c = 0;
  float r = 0;
  float s = 0;
  float t = 0;
  

  // Ввод пользователем значений переменных a, b, c, r, s, t с помощью scanf

  scanf("%f",&a);
  scanf("%f",&b);
  scanf("%f",&c);
  scanf("%f",&r);
  scanf("%f",&s);
  scanf("%f",&t);

 
  // Сравниваем рёбра пакета с каждым ребром коробки
if (
     ( a<r && b<s && c<t ) ||
     ( a<r && c<s && b<t ) ||
     ( b<r && a<s && c<t ) ||
     ( b<r && c<s && a<t ) ||
     ( c<r && a<s && b<t ) ||
     ( c<r && b<s && a<t )
   )
{
   printf("====== The package is fitting ======");
}
else
{
   printf("~~~~~~ The package cannot fit ! ~~~~~~ ");
}

  // Завершение программы

  return 0;
}

#include <stdio.h>

#include <math.h>

int main(void)

{

// Объявление переменных a,b,c,r,s,t типа float для хранения входных данных

float a = 0;

float b = 0;

float c = 0;

float r = 0;

float s = 0;

float t = 0;

// Ввод пользователем значений переменных a, b, c, r, s, t с помощью scanf

scanf("%f",&a);

scanf("%f",&b);

scanf("%f",&c);

scanf("%f",&r);

scanf("%f",&s);

scanf("%f",&t);

// Сравниваем рёбра пакета с каждым ребром коробки

if (

( a<r && b<s && c<t ) ||

( a<r && c<s && b<t ) ||

( b<r && a<s && c<t ) ||

( b<r && c<s && a<t ) ||

( c<r && a<s && b<t ) ||

( c<r && b<s && a<t )

)

{

printf("====== The package is fitting ======");

}

else

{

printf("~~~~~~ The package cannot fit ! ~~~~~~ ");

}

// Завершение программы

return 0;

}

Код программы на языке Java:

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

class BoxApp
{
   public static Float scanFloat( Scanner in )
   {
      
       return ( ( in.hasNextFloat() ) ? in.nextFloat() : null );
   }
   
   public static void main( String[] args )
   {
      // ќбъ¤вление переменных a,b,c,r,s,t типа float дл¤ хранени¤ входных данных
    
      float a = 0;
      float b = 0;
      float c = 0;
      float r = 0;
      float s = 0;
      float t = 0;
      
      // ¬вод пользователем значений переменных a, b, c, r, s, t с помощью scanf

      Scanner in = new Scanner(System.in);
      
      a = scanFloat( in );
      b = scanFloat( in );
      c = scanFloat( in );
      r = scanFloat( in );
      s = scanFloat( in );
      t = scanFloat( in );
      
      in.close();
       
      // —равниваем рЄбра пакета с каждым ребром коробки
    if (
         ( a<r && b<s && c<t ) ||
         ( a<r && c<s && b<t ) ||
         ( b<r && a<s && c<t ) ||
         ( b<r && c<s && a<t ) ||
         ( c<r && a<s && b<t ) ||
         ( c<r && b<s && a<t )
       )
    {
       System.out.printf("====== The package is fitting ======");
    }
    else
    {
       System.out.printf("~~~~~~ The package cannot fit ! ~~~~~~ ");
    }
    
   }
}

import java.util.*;

import java.lang.*;

import java.io.*;

class BoxApp

{

public static Float scanFloat( Scanner in )

{

return ( ( in.hasNextFloat() ) ? in.nextFloat() : null );

}

public static void main( String[] args )

{

// ќбъ¤вление переменных a,b,c,r,s,t типа float дл¤ хранени¤ входных данных

float a = 0;

float b = 0;

float c = 0;

float r = 0;

float s = 0;

float t = 0;

// ¬вод пользователем значений переменных a, b, c, r, s, t с помощью scanf

Scanner in = new Scanner(System.in);

a = scanFloat( in );

b = scanFloat( in );

c = scanFloat( in );

r = scanFloat( in );

s = scanFloat( in );

t = scanFloat( in );

in.close();

// —равниваем рЄбра пакета с каждым ребром коробки

if (

( a<r && b<s && c<t ) ||

( a<r && c<s && b<t ) ||

( b<r && a<s && c<t ) ||

( b<r && c<s && a<t ) ||

( c<r && a<s && b<t ) ||

( c<r && b<s && a<t )

)

{

System.out.printf("====== The package is fitting ======");

}

else

{

System.out.printf("~~~~~~ The package cannot fit ! ~~~~~~ ");

}

Ссылка http://ideone.com/cRnZc7

Программа состоит из следующих частей:

Объявление переменных a,b,c,r,s,t типа float для хранения входных данных
Ввод пользователем значений переменных a, b, c, r, s, t с помощью scanf
Вывод исходных данных
Сравниваем рёбра пакета с каждым ребром коробки
Завершение программы

Программа сверяет размеры коробки ( package ) с размерами посылки ( box ). Если размеры коробки меньше, чем посылки, программа сообщает о возможности упаковки коробки в посылку. В противном случае выводиться сообщение о невозможности упаковки коробки данных размеров в посылку.

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